Apple OpenCL Programming Guide for Mac Manuel
Apple sur Fnac.com
- Pour voir la liste complète des manuels APPLE, cliquez ici
TELECHARGER LE PDF sur :
http://developer.apple.com/library/mac/documentation/Performance/Conceptual/OpenCL_MacProgGuide/OpenCL_MacProgGuide.pdf
Commander un produit Apple sur Fnac.com
Voir également d'autres Guides et documentation APPLE :
Apple-TV_2nd_gen_Setup_Guide.pdf-manuel
Apple-Archives-and-Serializations-Programming-manuel
Apple-SafariWebContent.pdf-Guide-manuel
Apple-iTunes_ExtrasandiTunes_LPTestGuide1.1.pdf-manuel
Apple-Text-System-User-Interface-Layer-Programming-manuel
Apple-CocoaTextArchitecture.pdf-manuel
Apple-Key-Value-Observing-Programming-Guide-manuel
Apple-Location-Awareness-Programming-Guide-manuel
Apple-SharkUserGuide.pdf-manuel
Apple-drawingprintingios.pdf-manuel
Apple-QuickTime7_User_Guide.pdf-manuel
Apple-Event-Handling-Guide-for-iOS-manuel
Apple-ipod_nano_3rd_gen_features_guide.pdf-manuel
Apple-iTunes_VideoandAudio_Asset_Guide5.0.pdf-manuel
Apple-ARD3_AdminGuide.pdf-manuel
Apple-SafariWebContent.pdf-Guide-manue
Apple-iphone_3gs_finger_tips.pdf-manuel
Apple-InstrumentsUserGuide.pdf-manuel
Apple-Logic-Pro-9-TDM-Guide-manuel
Apple-macbook_air_users_guide.pdf-manuel
Apple-macbook_air-13-inch_mid-2012-qs_ta.pdf-manuel
Apple-AppStoreMarketingGuidelines-JP.pdf-Japon-manuel
Apple-macbook_pro_retina_qs_ta.pdf-manuel
Apple-ipad_user_guide_tu.pdf-manuel
Apple-ipad_user_guide_th.pdf-manuel
Apple-iphone_user_guide_gr.pdf-manuel
Apple-Nike_Plus_iPod_Sensor_UG_2A.pdf-manuel
Apple-ipad_manual_del_usuario.pdf-manuel
Apple-ipad_uzivatelska_prirucka.pdf-manuel
Apple-ipad_wifi_informations_importantes.pdf-manuel
Apple-Xsan_2_Admin_Guide_v2.3.pdf-manuel
Apple-macbook_pro-13-inch-late-2012-quick_start.pdf-manuel
Apple-CocoaDrawingGuide.pdf-manuel
Apple-Cryptographic-Services-Guide-manuel
Apple-Resource-Programming-Guide-manuel
AppleSafariVisualEffectsProgGuide.pdf-manuel
/Apple-WorkingWithUSB.pdf-manuel
Apple-macbook_pro-retina-mid-2012-important_product_info_f.pdf-manuel
Apple-iOS_Security_May12.pdf-manue
Apple-Mac-Pro-2008-Performance-and-Productivity-for-Creative-Pros
Apple-iPod_shuffle_4thgen_Manuale_utente.pdf-Italie-Manuel
Apple-KernelProgramming.pdf-manuel
Apple-Core-Data-Model-Versioning-and-Data-Migration-Programming-Guide-manuel
Apple-RED_Workflows_with_Final_Cut_Pro_X.pdf-manuel
Apple-Transitioning-to-ARC-Release-Notes-manuel
Apple-iTunes-Connect-Sales-and-Trends-Guide-manuel
Apple-App-Sandbox-Design-Guide-manuel
Apple-String-Programming-Guide-manuel
Apple-Secure-Coding-Guide-manuel
Apple_AirPort_Networks_Early2009.pdf-manuel
Apple-TimeCapsule_SetupGuide_TA.pdf-manuel
Apple-time_capsule_4th_gen_setup.pdf-manuel
Apple-TimeCapsule_SetupGuide.pdf-manuel
Apple-TimeCapsule_SetupGuide_CH.pdf-Chinois-manuel
Apple-CodeSigningGuide.pdf-manuel
Apple-ViewControllerPGforiOS.pdf-manuel
Apple-KeyValueObserving.pdf-manuel
Apple-mac_mini-late-2012-quick_start.pdf-manuel
Apple-OS-X-Mountain-Lion-Core-Technologies-Overview-June-2012-manuel
Apple-OS-X-Server-Product-Overview-June-2012-manuel
Apple-Apple_Server_Diagnostics_UG_109.pdf-manuel
Apple-PackageMaker_UserGuide.pdf-manuel
Apple-InstrumentsUserGuide.pdf-manuel
Apple-Logic-Pro-9-TDM-Guide-manuel
Apple-macbook_air_users_guide.pdf-manuel
Apple-macbook_air-13-inch_mid-2012-qs_ta.pdf-manuel
Apple-AppStoreMarketingGuidelines-JP.pdf-Japon-manuel
Apple-macbook_pro_retina_qs_ta.pdf-manuel
Apple-ipad_user_guide_tu.pdf-manuel
Apple-ipad_user_guide_th.pdf-manuel
Apple-iphone_user_guide_gr.pdf-manuel
Apple-Nike_Plus_iPod_Sensor_UG_2A.pdf-manuel
Apple-ipad_manual_del_usuario.pdf-manuel
Apple-ipad_uzivatelska_prirucka.pdf-manuel
Apple-ipad_wifi_informations_importantes.pdf-manuel
Apple-Xsan_2_Admin_Guide_v2.3.pdf-manuel
Apple-macbook_pro-13-inch-late-2012-quick_start.pdf-manuel
Apple-CocoaDrawingGuide.pdf-manuel
Apple-Cryptographic-Services-Guide-manuel
Apple-Resource-Programming-Guide-manuel
AppleSafariVisualEffectsProgGuide.pdf-manuel
/Apple-WorkingWithUSB.pdf-manuel
Apple-macbook_pro-retina-mid-2012-important_product_info_f.pdf-manuel
Apple-iOS_Security_May12.pdf-manue
Apple-Mac-Pro-2008-Performance-and-Productivity-for-Creative-Pros
Apple-iPod_shuffle_4thgen_Manuale_utente.pdf-Italie-Manuel
Apple-KernelProgramming.pdf-manuel
Apple-Core-Data-Model-Versioning-and-Data-Migration-Programming-Guide-manuel
Apple-RED_Workflows_with_Final_Cut_Pro_X.pdf-manuel
Apple-Transitioning-to-ARC-Release-Notes-manuel
Apple-iTunes-Connect-Sales-and-Trends-Guide-manuel
Apple-App-Sandbox-Design-Guide-manuel
Apple-String-Programming-Guide-manuel
Apple-Secure-Coding-Guide-manuel
Apple_AirPort_Networks_Early2009.pdf-manuel
Apple-TimeCapsule_SetupGuide_TA.pdf-manuel
Apple-time_capsule_4th_gen_setup.pdf-manuel
Apple-TimeCapsule_SetupGuide.pdf-manuel
Apple-TimeCapsule_SetupGuide_CH.pdf-Chinois-manuel
Apple-CodeSigningGuide.pdf-manuel
Apple-ViewControllerPGforiOS.pdf-manuel
Apple-KeyValueObserving.pdf-manuel
Apple-mac_mini-late-2012-quick_start.pdf-manuel
Apple-OS-X-Mountain-Lion-Core-Technologies-Overview-June-2012-manuel
Apple-OS-X-Server-Product-Overview-June-2012-manuel
Apple-Apple_Server_Diagnostics_UG_109.pdf-manuel
Apple-PackageMaker_UserGuide.pdf-manuel
Apple-Instrumentos_y_efectos_de_Logic_Studio.pdf-Manuel
Apple-ipod_nano_kayttoopas.pdf-Finlande-Manuel
Apple_ProRes_White_Paper_October_2012.pdf-Manuel
Apple-wp_osx_configuration_profiles.pdf-Manuel
Apple-UsingiTunesProducerFreeBooks.pdf-Manuel
Apple-ipad_manual_do_usuario.pdf-Portugais-Manuel
Apple-Instruments_et_effets_Logic_Studio.pdf-Manuel
Apple-ipod_touch_gebruikershandleiding.pdf-Neerlandais-Manuel
AppleiPod_shuffle_4thgen_Manual_del_usuario.pdf-Espagnol-Manuel
Apple-Premiers-contacts-avec-votre-PowerBook-G4-Manuel
Apple_Composite_AV_Cable.pdf-Manuel
Apple-iPod_shuffle_3rdGen_UG_DK.pdf-Danemark-Manuel
Apple-iPod_classic_160GB_Benutzerhandbuch.pdf-Allemand-Manuel
Apple-VoiceOver_GettingStarted-Manuel
Apple-iPod_touch_2.2_Benutzerhandbuch.pdf-Allemand-Manuel
Apple-Apple_TV_Opstillingsvejledning.pdf-Allemand-Manuel
Apple-iPod_shuffle_4thgen_Manuale_utente.pdf-Italie-Manuel
Apple-iphone_prirucka_uzivatela.pdf-Manuel
Apple-Aan-de-slag-Neerlandais-Manuel
Apple-airmac_express-80211n-2nd-gen_setup_guide.pdf-Thailande-Manuel
Apple-ipod_nano_benutzerhandbuch.pdf-Allemand-Manuel
Apple-aperture3.4_101.pdf-Manuel
Apple-Pages09_Anvandarhandbok.pdf-Manuel
Apple-nike_plus_ipod_sensor_ug_la.pdf-Mexique-Manuel
Apple-ResEdit-Reference-For-ResEdit02.1-Manuel
Apple-ipad_guide_de_l_utilisateur.pdf-Manuel
Apple-Compressor-4-Benutzerhandbuch-Allemand-Manuel
Apple-AirPort_Networks_Early2009_DK.pdf-Danemark-Manuel
Apple-MacBook_Pro_Mid2007_2.4_2.2GHz_F.pdf-Manuel
Apple-MacBook_13inch_Mid2010_UG_F.pdf-Manuel
Apple-Xserve-RAID-Presentation-technologique-Janvier-2004-Manuel
Apple-MacBook_Pro_15inch_Mid2010_F.pdf-Manuel
Apple-AirPort_Express-opstillingsvejledning.pdf-Danemark-Manuel
Apple-DEiPod_photo_Benutzerhandbuch_DE0190269.pdf-Allemand-Manuel
Apple-Final-Cut-Pro-X-Logic-Effects-Reference-Manuel
Apple-iPod_touch_2.1_Brugerhandbog.pdf-Danemark-Manuel
Apple-Remote-Desktop-Administratorhandbuch-Version-3.1-Allemand-Manuel
Apple-Qmaster-4-User-Manual-Manuel
Apple-Server_Administration_v10.5.pdf-Manuel
Apple-ipod_classic_features_guide.pdf-Manuel
Apple-Lecteur-Optique-Manuel
Apple-Carte-AirPort-Manuel
Apple-iPhone_Finger_Tips_Guide.pdf-Anglais-Manuel
Apple-Couvercle-Manuel
Apple-battery.cube.pdf-Manuel
Apple-Boitier-de-l-ordinateur-Manuel
Apple-Pile-Interne-Manuel
Apple-atacable.pdf-Manuel
Apple-videocard.pdf-Manuel
Apple-Guide_de_configuration_de_l_Airport_Express_5.1.pdf-Manuel
Apple-iMac_Mid2010_UG_F.pdf-Manuel
Apple-MacBook_13inch_Mid2009_F.pdf-Manuel
Apple-MacBook_Mid2007_UserGuide.F.pdf-Manuel
Apple-Designing_AirPort_Networks_10.5-Windows_F.pdf-Manuel
Apple-Administration_de_QuickTime_Streaming_et_Broadcasting_10.5.pdf-Manuel
Apple-Opstillingsvejledning_til_TimeCapsule.pdf-Danemark-Manuel
Apple-iPod_nano_5th_gen_Benutzerhandbuch.pdf-Manuel
Apple-iOS_Business.pdf-Manuel
Apple-AirPort_Extreme_Installationshandbuch.pdf-Manuel
Apple-Final_Cut_Express_4_Installation_de_votre_logiciel.pdf-Manuel
Apple-MacBook_Pro_15inch_2.53GHz_Mid2009.pdf-Manuel
Apple-Network_Services.pdf-Manuel
Apple-Aperture_Performing_Adjustments_f.pdf-Manuel
Apple-Supplement_au_guide_Premiers_contacts.pdf-Manuel
Apple-Administration_des_images_systeme_et_de_la_mise_a_jour_de_logiciels_10.5.pdf-Manuel
Apple-Mac_OSX_Server_v10.6_Premiers_contacts.pdf-Francais-Manuel
Apple-Designing_AirPort_Networks_10.5-Windows_F.pdf-Manuel
Apple-Mise_a_niveau_et_migration_v10.5.pdf-Manue
Apple-MacBookPro_Late_2007_2.4_2.2GHz_F.pdf-Manuel
Apple-Mac_mini_Late2009_SL_Server_F.pdf-Manuel
Apple-Mac_OS_X_Server_10.5_Premiers_contacts.pdf-Manuel
Apple-iPod_touch_2.0_Guide_de_l_utilisateur_CA.pdf-Manuel
Apple-MacBook_Pro_17inch_Mid2010_F.pdf-Manuel
Apple-Comment_demarrer_Leopard.pdf-Manuel
Apple-iPod_2ndGen_USB_Power_Adapter-FR.pdf-Manuel
Apple-Feuille_de_operations_10.4.pdf-Manuel
Apple-Time_Capsule_Installationshandbuch.pdf-Allemand-Manuel
Apple-F034-2262AXerve-grappe.pdf-Manuel
Apple-Mac_Pro_Early2009_4707_UG_F
Apple-imacg5_17inch_Power_Supply
Apple-Logic_Studio_Installieren_Ihrer_Software_Retail
Apple-IntroductionXserve1.0.1
Apple-Aperture_Getting_Started_d.pdf-Allemand
Apple-getting_started_with_passbook
Apple-iPod_mini_2nd_Gen_UserGuide.pdf-Anglais
Apple-Deploiement-d-iPhone-et-d-iPad-Reseaux-prives-virtuels
Apple-F034-2262AXerve-grappe
Apple-Mac_OS_X_Server_Glossaire_10.5
Apple-FRLogic_Pro_7_Guide_TDM
Apple-iphone_bluetooth_headset_userguide
Apple-Administration_des_services_reseau_10.5
Apple-imacg5_17inch_harddrive
Apple-iPod_nano_4th_gen_Manuale_utente
Apple-iBook-G4-Getting-Started
Apple-XsanGettingStarted
Apple-Mac_mini_UG-Early2006
Apple-Guide_des_fonctionnalites_de_l_iPod_classic
Apple-Guide_de_configuration_d_Xsan_2
Apple-MacBook_Late2006_UsersGuide
Apple-sur-Fnac.com
Apple-Mac_mini_Mid2010_User_Guide_F.pdf-Francais
Apple-PowerBookG3UserManual.PDF.Anglais
Apple-Installation_de_votre_logiciel_Logic_Studio_Retail
Apple-Pages-Guide-de-l-utilisateur
Apple-MacBook_Pro_13inch_Mid2009.pdf.Anglais
Apple-MacBook_Pro_15inch_Mid2009
Apple-Installation_de_votre_logiciel_Logic_Studio_Upgrade
Apple-FRLogic_Pro_7_Guide_TDM
Apple-airportextreme_802.11n_userguide
Apple-iPod_shuffle_3rdGen_UG
Apple-iPod_classic_160GB_User_Guide
Apple-iPod_nano_5th_gen_UserGuide
Apple-ipod_touch_features_guide
Apple-Wireless_Mighty_Mouse_UG
Apple-Advanced-Memory-Management-Programming-Guide
Apple-iOS-App-Programming-Guide
Apple-Concurrency-Programming-Guide
Apple-MainStage-2-User-Manual-Anglais
Apple-iMacG3_2002MultilingualUserGuide
Apple-iBookG3_DualUSBUserGuideMultilingual.PDF.Anglais
Apple-imacG5_20inch_AirPort
Apple-Guide_de_l_utilisateur_de_Mac_Pro_Early_2008
Apple-Installation_de_votre_logiciel_Logic_Express_8
Apple-iMac_Guide_de_l_utilisateur_Mid2007
Apple-imacg5_20inch_OpticalDrive
Apple-FCP6_Formats_de_diffusion_et_formats_HD
Apple-prise_en_charge_des_surfaces_de_controle_logic_pro_8
Apple-Aperture_Quick_Reference_f
Apple-Shake_4_User_Manual
Apple-aluminumAppleKeyboard_wireless2007_UserGuide
Apple-ipod_shuffle_features_guide
Apple-Color-User-Manual
Apple-XsanGettingStarted
Apple-Migration_10.4_2e_Ed
Apple-MacBook_Air_SuperDrive
Apple-MacBook_Late2007-f
ApplePowerMacG5_(Early_2005)_UserGuide
Apple-iSightUserGuide
Apple-MacBook_Pro_Early_2008_Guide_de_l_utilisateur
Apple-Nouvelles-fonctionnalites-aperture-1.5
Apple-premiers_contacts_2e_ed_10.4.pdf-Mac-OS-X-Server
Apple-premiers_contacts_2e_ed_10.4
Apple-eMac_2005UserGuide
Apple-imacg5_20inch_Inverter
Apple-Keynote2_UserGuide.pdf-Japon
Apple-Welcome_to_Tiger.pdf-Japon
Apple-XsanAdminGuide_j.pdf-Japon
Apple-PowerBookG4_UG_15GE.PDF-Japon
Apple-Xsan_Migration.pdf-Japon
Apple-Xserve_Intel_DIY_TopCover_JA.pdf-Japon
Apple-iPod_nano_6thgen_User_Guide_J.pdf-Japon
Apple-Aperture_Photography_Fundamentals.pdf-Japon
Apple-nikeipod_users_guide.pdf-Japon
Apple-QuickTime71_UsersGuide.pdf-Japon
Apple-iMacG5_iSight_UG.pdf-Japon
Apple-Aperture_Performing_Adjustments_j.pdf-Japon
Apple-iMacG5_17inch_HardDrive.pdf-Japon
Apple-iPod_shuffle_Features_Guide_J.pdf-Japon
Apple-MacBook_Air_User_Guide.pdf-Japon
Apple-MacBook_UsersGuide.pdf-Japon
Apple-iPad_iOS4_Brukerhandbok.pdf-Norge-Norvege
Apple-Apple_AirPort_Networks_Early2009_H.pd-Norge-Norvege
Apple-iPod_classic_120GB_no.pdf-Norge-Norvege
Apple-StoreKitGuide.pdf-Japon
Apple-Xserve_Intel_DIY_ExpansionCardRiser_JA.pdf-Japon
Apple-iMacG5_Battery.pdf-Japon
Apple-Logic_Pro_8_Getting_Started.pdf-Japon
Apple-PowerBook-handbok-Norge-Norveg
Apple-iWork09_formler_og_funksjoner.pdf-Norge-Norvege
Apple-MacBook_Pro_15inch_Mid2010_H.pdf-Norge-Norvege
Apple-MacPro_HardDrive_DIY.pdf-Japon
Apple-iPod_Fifth_Gen_Funksjonsoversikt.pdf-Norge-Norvege
Apple-MacBook_13inch_white_Early2009_H.pdf-Norge-Norvege
Apple-GarageBand_09_Komme_i_gang.pdf-Norge-Norvege
Apple-MacBook_Pro_15inch_Mid2009_H.pdf-Norge-Norvege
Apple-imac_mid2011_ug_h.pdf-Norge-Norvege
Apple-iDVD_08_Komme_i_gang.pdf-Norge-Norvege
Apple-MacBook_Air_11inch_Late2010_UG_H.pdf-Norge-Norvege
Apple-iMac_Mid2010_UG_H.pdf-Norge-Norvege
Apple-MacBook_13inch_Mid2009_H.pdf-Norge-Norvege
/Apple-iPhone_3G_Viktig_produktinformasjon_H-Norge-Norvege
Apple-MacBook_13inch_Mid2010_UG_H.pdf-Norge-Norvege
Apple-macbook_air_13inch_mid2011_ug_no.pdf-Norge-Norvege
Apple-Mac_mini_Early2009_UG_H.pdf-Norge-Norvege
Apple-ipad2_brukerhandbok.pdf-Norge-Norvege
Apple-iPhoto_08_Komme_i_gang.pdf-Norge-Norvege
Apple-MacBook_Air_Brukerhandbok_Late2008.pdf-Norge-Norvege
Apple-Pages09_Brukerhandbok.pdf-Norge-Norvege
Apple-MacBook_13inch_Late2009_UG_H.pdf-Norge-Norvege
Apple-iPhone_3GS_Viktig_produktinformasjon.pdf-Norge-Norvege
Apple-MacBook_13inch_Aluminum_Late2008_H.pdf-Norge-Norvege
Apple-Wireless_Keyboard_Aluminum_2007_H-Norge-Norvege
Apple-NiPod_photo_Brukerhandbok_N0190269.pdf-Norge-Norvege
Apple-MacBook_Pro_13inch_Mid2010_H.pdf-Norge-Norvege
Apple-MacBook_Pro_17inch_Mid2010_H.pdf-Norge-Norvege
Apple-Velkommen_til_Snow_Leopard.pdf-Norge-Norvege.htm
Apple-TimeCapsule_Klargjoringsoversikt.pdf-Norge-Norvege
Apple-iPhone_3GS_Hurtigstart.pdf-Norge-Norvege
Apple-Snow_Leopard_Installeringsinstruksjoner.pdf-Norge-Norvege
Apple-iMacG5_iSight_UG.pdf-Norge-Norvege
Apple-iPod_Handbok_S0342141.pdf-Norge-Norvege
Apple-ipad_brukerhandbok.pdf-Norge-Norvege
Apple-GE_Money_Bank_Handlekonto.pdf-Norge-Norvege
Apple-MacBook_Air_11inch_Late2010_UG_H.pdf-Norge-Norvege
Apple-iPod_nano_6thgen_Brukerhandbok.pdf-Norge-Norvege
Apple-iPod_touch_iOS4_Brukerhandbok.pdf-Norge-Norvege
Apple-MacBook_Air_13inch_Late2010_UG_H.pdf-Norge-Norvege
Apple-MacBook_Pro_15inch_Early2011_H.pdf-Norge-Norvege
Apple-Numbers09_Brukerhandbok.pdf-Norge-Norvege
Apple-Welcome_to_Leopard.pdf-Japon
Apple-PowerMacG5_UserGuide.pdf-Norge-Norvege
Apple-iPod_touch_2.1_Brukerhandbok.pdf-Norge-Norvege
Apple-Boot_Camp_Installering-klargjoring.pdf-Norge-Norvege
Apple-MacOSX10.3_Welcome.pdf-Norge-Norvege
Apple-iPod_shuffle_3rdGen_UG_H.pdf-Norge-Norvege
Apple-iPhone_4_Viktig_produktinformasjon.pdf-Norge-Norvege
Apple_TV_Klargjoringsoversikt.pdf-Norge-Norvege
Apple-iMovie_08_Komme_i_gang.pdf-Norge-Norvege
Apple-iPod_classic_160GB_Brukerhandbok.pdf-Norge-Norvege
Apple-Boot_Camp_Installering_10.6.pdf-Norge-Norvege
Apple-Network-Services-Location-Manager-Veiledning-for-nettverksadministratorer-Norge-Norvege
Apple-iOS_Business_Mar12_FR.pdf
Apple-PCIDualAttachedFDDICard.pdf
Apple-Aperture_Installing_Your_Software_f.pdf
Apple-User_Management_Admin_v10.4.pdf
Apple-Compressor-4-ユーザーズマニュアル Japon
Apple-Network_Services_v10.4.pdf
Apple-iPod_2ndGen_USB_Power_Adapter-DE
Apple-Mail_Service_v10.4.pdf
Apple-AirPort_Express_Opstillingsvejledning_5.1.pdf
Apple-MagSafe_Airline_Adapter.pdf
Apple-L-Apple-Multiple-Scan-20-Display
Apple-Administration_du_service_de_messagerie_10.5.pdf
Apple-System_Image_Admin.pdf
Apple-iMac_Intel-based_Late2006.pdf-Japon
Apple-iPhone_3GS_Finger_Tips_J.pdf-Japon
Apple-Power-Mac-G4-Mirrored-Drive-Doors-Japon
Apple-AirMac-カード取り付け手順-Japon
Apple-iPhone開発ガイド-Japon
Apple-atadrive_pmg4mdd.j.pdf-Japon
Apple-iPod_touch_2.2_User_Guide_J.pdf-Japon
Apple-Mac_OS_X_Server_v10.2.pdf
Apple-AppleCare_Protection_Plan_for_Apple_TV.pdf
Apple_Component_AV_Cable.pdf
Apple-DVD_Studio_Pro_4_Installation_de_votre_logiciel
Apple-Windows_Services
Apple-Motion_3_New_Features_F
Apple-g4mdd-fw800-lowerfan
Apple-MacOSX10.3_Welcome
Apple-Print_Service
Apple-Xserve_Setup_Guide_F
Apple-PowerBookG4_17inch1.67GHzUG
Apple-iMac_Intel-based_Late2006
Apple-Installation_de_votre_logiciel
Apple-guide_des_fonctions_de_l_iPod_nano
Apple-Administration_de_serveur_v10.5
Apple-Mac-OS-X-Server-Premiers-contacts-Pour-la-version-10.3-ou-ulterieure
Apple-boot_camp_install-setup
Apple-iBookG3_14inchUserGuideMultilingual
Apple-mac_pro_server_mid2010_ug_f
Apple-Motion_Supplemental_Documentation
Apple-imac_mid2011_ug_f
Apple-iphone_guide_de_l_utilisateur
Apple-macbook_air_11inch_mid2011_ug_fr
Apple-NouvellesfonctionnalitesdeLogicExpress7.2
Apple-QT_Streaming_Server
Apple-Web_Technologies_Admin
Apple-Mac_Pro_Early2009_4707_UG
Apple-guide_de_l_utilisateur_de_Numbers08
Apple-Decouverte_d_Aperture_2
Apple-Guide_de_configuration_et_d'administration
Apple-mac_integration_basics_fr_106.
Apple-iPod_shuffle_4thgen_Guide_de_l_utilisateur
Apple-ARA_Japan
Apple-081811_APP_iPhone_Japanese_v5.4.pdf-Japan
Apple-Recycle_Contract120919.pdf-Japan
Apple-World_Travel_Adapter_Kit_UG
Apple-iPod_nano_6thgen_User_Guide
Apple-RemoteSupportJP
Apple-Mac_mini_Early2009_UG_F.pdf-Manuel-de-l-utilisateur
Apple-Compressor_3_Batch_Monitor_User_Manual_F.pdf-Manuel-de-l-utilisateur
Apple-Premiers__contacts_avec_iDVD_08
Apple-Mac_mini_Intel_User_Guide.pdf
Apple-Prise_en_charge_des_surfaces_de_controle_Logic_Express_8
Apple-mac_integration_basics_fr_107.pdf
Apple-Final-Cut-Pro-7-Niveau-1-Guide-de-preparation-a-l-examen
Apple-Logic9-examen-prep-fr.pdf-Logic-Pro-9-Niveau-1-Guide-de-preparation-a-l-examen
Apple-aperture_photography_fundamentals.pdf-Manuel-de-l-utilisateu
Apple-emac-memory.pdf-Manuel-de-l-utilisateur
Apple-Apple-Installation-et-configuration-de-votre-Power-Mac-G4
Apple-Guide_de_l_administrateur_d_Xsan_2.pdf
Apple-premiers_contacts_avec_imovie6.pdf
Apple-Tiger_Guide_Installation_et_de_configuration.pdf
Apple-Final-Cut-Pro-7-Level-One-Exam-Preparation-Guide-and-Practice-Exam
Apple-Open_Directory.pdf
Apple-Nike_+_iPod_User_guide
Apple-ard_admin_guide_2.2_fr.pdf
Apple-systemoverviewj.pdf-Japon
Apple-Xserve_TO_J070411.pdf-Japon
Apple-Mac_Pro_User_Guide.pdf
Apple-iMacG5_iSight_UG.pdf
Apple-premiers_contacts_avec_iwork_08.pdf
Apple-services_de_collaboration_2e_ed_10.4.pdf
Apple-iPhone_Bluetooth_Headset_Benutzerhandbuch.pdf
Apple-Guide_de_l_utilisateur_de_Keynote08.pdf
APPLE/Apple-Logic-Pro-9-Effectsrfr.pdf
Apple-Logic-Pro-9-Effectsrfr.pdf
Apple-iPod_shuffle_3rdGen_UG_F.pdf
Apple-iPod_classic_160Go_Guide_de_l_utilisateur.pdf
Apple-iBookG4GettingStarted.pdf
Apple-Administration_de_technologies_web_10.5.pdf
Apple-Compressor-4-User-Manual-fr
Apple-MainStage-User-Manual-fr.pdf
Apple-Logic_Pro_8.0_lbn_j.pdf
Apple-PowerBookG4_15inch1.67-1.5GHzUserGuide.pdf
Apple-MacBook_Pro_15inch_Mid2010_CH.pdf
Apple-LED_Cinema_Display_27-inch_UG.pdf
Apple-MacBook_Pro_15inch_Mid2009_RS.pdf
Apple-macbook_pro_13inch_early2011_f.pdf
Apple-iMac_Mid2010_UG_BR.pdf
Apple-iMac_Late2009_UG_J.pdf
Apple-iphone_user_guide-For-iOS-6-Software
Apple-iDVD5_Getting_Started.pdf
Apple-guide_des_fonctionnalites_de_l_ipod_touch.pdf
Apple_iPod_touch_User_Guide
Apple_macbook_pro_13inch_early2011_f
Apple_Guide_de_l_utilisateur_d_Utilitaire_RAID
Apple_Time_Capsule_Early2009_Setup_F
Apple_iphone_4s_finger_tips_guide_rs
Apple_iphone_upute_za_uporabu
Apple_ipad_user_guide_ta
Apple_iPod_touch_User_Guide
apple_earpods_user_guide
apple_iphone_gebruikershandleiding
apple_iphone_5_info
apple_iphone_brukerhandbok
apple_apple_tv_3rd_gen_setup_tw
apple_macbook_pro-retina-mid-2012-important_product_info_ch
apple_Macintosh-User-s-Guide-for-Macintosh-PowerBook-145
Apple_ipod_touch_user_guide_ta
Apple_TV_2nd_gen_Setup_Guide_h
Apple_ipod_touch_manual_del_usuario
Apple_iphone_4s_finger_tips_guide_tu
Apple_macbook_pro_retina_qs_th
Apple-Manuel_de_l'utilisateur_de_Final_Cut_Server
Apple-iMac_G5_de_lutilisateur
Apple-Cinema_Tools_4.0_User_Manual_F
Apple-Personal-LaserWriter300-User-s-Guide
Apple-QuickTake-100-User-s-Guide-for-Macintosh
Apple-User-s-Guide-Macintosh-LC-630-DOS-Compatible
Apple-iPhone_iOS3.1_User_Guide
Apple-iphone_4s_important_product_information_guide
Apple-iPod_shuffle_Features_Guide_F
Liste-documentation-apple
Apple-Premiers_contacts_avec_iMovie_08
Apple-macbook_pro-retina-mid-2012-important_product_info_br
Apple-macbook_pro-13-inch-mid-2012-important_product_info
Apple-macbook_air-11-inch_mid-2012-qs_br
Apple-Manuel_de_l_utilisateur_de_MainStage
Apple-Compressor_3_User_Manual_F
Apple-Color_1.0_User_Manual_F
Apple-guide_de_configuration_airport_express_4.2
Apple-TimeCapsule_SetupGuide
Apple-Instruments_et_effets_Logic_Express_8
Apple-Manuel_de_l_utilisateur_de_WaveBurner
Apple-Macmini_Guide_de_l'utilisateur
Apple-PowerMacG5_UserGuide
Disque dur, ATA parallèle Instructions de remplacement
Apple-final_cut_pro_x_logic_effects_ref_f
Apple-Leopard_Installationshandbok
Manuale Utente PowerBookG4
Apple-thunderbolt_display_getting_started_1e
Apple-Compressor-4-Benutzerhandbuch
Apple-macbook_air_11inch_mid2011_ug
Apple-macbook_air-mid-2012-important_product_info_j
Apple-iPod-nano-Guide-des-fonctionnalites
Apple-iPod-nano-Guide-des-fonctionnalites
Apple-iPod-nano-Guide-de-l-utilisateur-4eme-generation
Apple-iPod-nano-Guide-de-l-utilisateur-4eme-generation
Apple-Manuel_de_l_utilisateur_d_Utilitaire_de_reponse_d_impulsion
Apple-Aperture_2_Raccourcis_clavier
AppleTV_Setup-Guide
Apple-livetype_2_user_manual_f
Apple-imacG5_17inch_harddrive
Apple-macbook_air_guide_de_l_utilisateur
Apple-MacBook_Early_2008_Guide_de_l_utilisateur
Apple-Keynote-2-Guide-de-l-utilisateur
Apple-PowerBook-User-s-Guide-for-PowerBook-computers
Apple-Macintosh-Performa-User-s-Guide-5200CD-and-5300CD
Apple-Macintosh-Performa-User-s-Guide
Apple-Workgroup-Server-Guide
Apple-iPod-nano-Guide-des-fonctionnalites
Apple-iPad-User-Guide-For-iOS-5-1-Software
Apple-Boot-Camp-Guide-d-installation-et-de-configuration
Apple-iPod-nano-Guide-de-l-utilisateur-4eme-generation
Power Mac G5 Guide de l’utilisateur APPLE
Guide de l'utilisateur PAGE '08 APPLE
Guide de l'utilisateur KEYNOTE '09 APPLE
Guide de l'Utilisateur KEYNOTE '3 APPLE
Guide de l'Utilisateur UTILITAIRE RAID
Guide de l'Utilisateur Logic Studio
Power Mac G5 Guide de l’utilisateur APPLE
Guide de l'utilisateur PAGE '08 APPLE
Guide de l'utilisateur KEYNOTE '09 APPLE
Guide de l'Utilisateur KEYNOTE '3 APPLE
Guide de l'Utilisateur UTILITAIRE RAID
Guide de l'Utilisateur Logic Studio
Guide de l’utilisateur ipad Pour le logiciel iOS 5.1
PowerBook G4 Premiers Contacts APPLE
Guide de l'Utilisateur iphone pour le logiciel ios 5.1 APPLE
Guide de l’utilisateur ipad Pour le logiciel iOS 4,3
Guide de l’utilisateur iPod nano 5ème génération
Guide de l'utilisateur iPod Touch 2.2 APPLE
Guide de l’utilisateur QuickTime 7 Mac OS X 10.3.9 et ultérieur Windows XP et Windows 2000
Guide de l'utilisateur MacBook 13 pouces Mi 2010
Guide de l’utilisateur iPhone (Pour les logiciels iOS 4.2 et 4.3)
Guide-de-l-utilisateur-iPod-touch-pour-le-logiciel-ios-4-3-APPLE
Guide-de-l-utilisateur-iPad-2-pour-le-logiciel-ios-4-3-APPLE
Guide de déploiement en entreprise iPhone OS
Guide-de-l-administrateur-Apple-Remote-Desktop-3-1
Guide-de-l-utilisateur-Apple-Xserve-Diagnostics-Version-3X103
Guide-de-configuration-AirPort-Extreme-802.11n-5e-Generation
Guide-de-configuration-AirPort-Extreme-802-11n-5e-Generation
Guide-de-l-utilisateur-Capteur-Nike-iPod
Guide-de-l-utilisateur-iMac-21-5-pouces-et-27-pouces-mi-2011-APPLE
Guide-de-l-utilisateur-Apple-Qadministrator-4
Guide-d-installation-Apple-TV-3-eme-generation
User-Guide-iPad-For-ios-5-1-Software
OpenCL Programming
Guide for MacContents
About Open CL for OS X 7
At a Glance 7
Prerequisites 8
See Also 8
Developing OpenCL Programs Using Xcode 9
Concepts 9
Essential Development Tasks 11
Hello World! 12
Creating An Application That Uses OpenCL In Xcode 12
Compiling From the Command Line 18
Debugging 19
Basic Programming Sample 20
Basic Kernel Code Sample 20
Basic Host Code Sample 21
Identifying Parallelizable Routines 29
Using Grand Central Dispatch With OpenCL 32
Discovering Available Compute Devices 32
Enqueueing A Kernel To A Dispatch Queue 33
Determining the Characteristics Of A Kernel On A Device 34
Obtaining the Kernel’s Workgroup Size 35
Sample Code: Creating a Dispatch Queue 37
Creating and Managing Memory Objects in OS X OpenCL 43
Overview 43
Workflow 43
Memory Visibility 44
Memory Consistency 46
Creating and Using Buffers in OpenCL 46
Representing Data With Buffer Objects 46
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
2Allocating Memory For Buffer Objects In OS X v10.7 47
Reading, Writing, and Copying Buffer Objects 48
Kernel Support For Data Processing In OpenCL-C 48
Releasing Buffer Objects 49
Setting the finalizer 49
Example: Allocating, Using, Releasing Buffer Objects 50
Creating and Using Images in OpenCL 54
Image Objects 54
Example 59
IOSurface and GL: What OpenCL Supports 64
How the Kernel Interacts With Data 64
Passing Data To a Kernel 64
Accessing Buffer Objects From a Kernel 64
Retrieving Results From a Kernel 65
OpenCL/ OpenGL Interoperation: Data Sharing 66
Sharegroups 67
Synchronizing Access To Shared OpenCL/OpenGL Objects 68
Example 68
Controlling OpenCL/OpenGL Interoperation With GCD 69
Using GCD To Synchronize A Host With OpenCL 69
Synchronizing A Host With OpenCL Using A Dispatch Semaphore 70
Synchronizing Multiple Queues 75
Using IOSurfaces With OpenCL 76
Creating Or Obtaining An IOSurface 76
Creating An Image Object from An IOSurface 76
Sharing the IOSurface With An OpenCL Device 77
Autovectorizer 79
Features 79
Without the Autovectorizer 79
Writing Optimal Code For the CPU: Let the autovectorizer do the work for you 81
Do 81
Don’t 81
What the autovectorizer does 81
Vectorization Example 81
Xcode 81
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
3
ContentsImproving Performance 82
Before Optimizing Code 82
Reducing Overhead 82
Measuring Performance 86
Measuring Performance On the Host 86
Measuring Performance On Devices 86
Estimating Optimal Performance 87
Tuning OpenCL Code For the CPU 89
In Practice 90
Tuning OpenCL Code For the GPU 99
In Practice 100
Document Revision History 108
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
4
ContentsFigures, Tables, and Listings
Developing OpenCL Programs Using Xcode 9
Figure 1-1 OpenCL Development Process 11
Hello World! 12
Figure 2-1 A simple OpenCL kernel in Xcode 12
Figure 2-2 Build settings for kernel files 13
Figure 2-3 OpenCL host code in Xcode 16
Figure 2-4 Adding the OpenCL framework 17
Figure 2-5 OpenCL framework was added 17
Figure 2-6 Results 18
Basic Programming Sample 20
Listing 3-1 Kernel code sample 20
Listing 3-2 Host code sample 21
Identifying Parallelizable Routines 29
Listing 4-1 Pseudocode that computes the final grade for each student 29
Listing 4-2 The isolated grade average task 30
Using Grand Central Dispatch With OpenCL 32
Listing 5-1 Creating a dispatch queue 37
Listing 5-2 Obtaining workgroup information 40
Creating and Managing Memory Objects in OS X OpenCL 43
Figure 6-1 Physical memory of an OpenCL system 45
Listing 6-1 Sample host function creates buffers then calls kernel function 50
Listing 6-2 Sample kernel squares an input array 54
Listing 6-3 Creating a 2D image object 55
Listing 6-4 An image-processing kernel function 58
Listing 6-5 Sample host function creates images then calls kernel function 59
Listing 6-6 Sample kernel swaps the red and green channels 63
OpenCL/ OpenGL Interoperation: Data Sharing 66
Figure 7-1 OpenGL and OpenCL share data using sharegroups 67
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
5Controlling OpenCL/OpenGL Interoperation With GCD 69
Figure 8-1 Rendering loop - each pass on the main thread creates a new frame for display 71
Listing 8-1 Synchronizing the host with OpenCL processing 70
Listing 8-2 Synchronizing a host with OpenCL using a dispatch semaphore 71
Listing 8-3 Synchronizing multiple queues 75
Using IOSurfaces With OpenCL 76
Listing 9-1 Creating an IOSurface-backed CL Image 77
Listing 9-2 Extracting an Image From an IOSurface 77
Autovectorizer 79
Figure 10-1 Before autovectorization: A simple float sent to the CPU and the GPU 80
Listing 10-1 Passing single floats into a kernel 80
Improving Performance 82
Figure 11-1 Memory copy speed in GB/s (read+write) vs buffer size 88
Table 11-1 Benchmarks of boxAvgH5 variants: 103
Table 11-2 Benchmarks of boxAvgH5 variants where each work item processes 4 columns: 106
Listing 11-1 Using the gettimeofday function 86
Listing 11-2 Sample benchmarking loop on the kernel 87
Listing 11-3 Kernel for estimating performance 87
Listing 11-4 The boxAvg kernel in two passes 91
Listing 11-5 Modify the horizontal pass to compute one row per work item instead of one pixel 92
Listing 11-6 Modify the algorithm to read fewer values per pixel and to incrementally update the sum 94
Listing 11-7 Modify the horizontal pass by moving division and conditionals out of the inner loop 95
Listing 11-8 Modify vertical pass to combine rows; each work item computes a block of rows 96
Listing 11-9 Ensure the image width is always a multiple of 4 97
Listing 11-10 A safer variant that will work for any image width 97
Listing 11-11 Fused kernel 98
Listing 11-12 Kernel before optimization 101
Listing 11-13 Move the data to local memory 102
Listing 11-14 Modify the kernel to compute several rows in each work item 103
Listing 11-15 Provide a dedicated kernel for each value of RANGE 104
Listing 11-16 Fastest variant: Unroll the inner loop and convert float data to float4 106
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
6
Figures, Tables, and ListingsOpenCL™ (Open Computing Language) is an open standard for cross-platform, parallel programming of modern
processors such as multicore CPUs and programmable GPUs. Introduced with OS X v10.6, OpenCL lets your
application tap into the parallel computing power of these processors to improve performance and deliver
features made possible by compute-intensive algorithms. OpenCL is comprised of thee parts: a C99-based
kernel programing language, a powerful scheduling API and a runtime that efficiently executes kernels on the
CPU or GPU.
Going beyond the standard, OS X v10.7 adds integration between OpenCL, Grand Central Dispatch and Xcode
making it even easer take advantage of the power of the OpenCL in your application.
At a Glance
Using OpenCL is easier than ever in OS X v10.7:
● OpenCL is fully supported by Xcode. The Xcode offline compiler removes a configuration step that used
to have to be performed before the kernel could be run and aids in debugging earlier in the development
process. See “Hello World!” (page 12).
● You can write OpenCL functions in separate files and include them in your Xcode project. These files can
be compiled as your application is built. This improves application performance because kernels need not
be compiled when the application is running
● OpenCL now integrates with Grand Central Dispatch, making it easier for you to focus on making your
OpenCL kernels more efficient. See “Using Grand Central Dispatch With OpenCL” (page 32).
● The autovectorizer is used for compiling kernels that will run on the CPU. It accelerates performance up
to four times without additional effort. The autovectorizer allows you to write one kernel that runs efficiently
on both a CPU and a GPU. It is invoked regardless of whether the openclc compiler is called from Xcode
or if the kernel is built at runtime. See “Autovectorizer” (page 79).
● You can, of course, continue to use code you’ve already written to the OpenCL 1.1 standard.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
7
About Open CL for OS XPrerequisites
This guide assumes that you program in C and have access to The OpenCL Specification . Although this guide
discusses many key OpenCL API functions, it does not provide detailed information on the OpenCL API or the
OpenCL-C programming language.
See Also
The OpenCL Specification , available from the Khronos Group at http://www.khronos.org/registry/cl/ provides
information on the OpenCL standard.
The OpenCL Programming Guide by Aaftab Munshi, Benedict Gaster, Timothy G. Mattson, James Fung, and
Dan Ginsburg, available from Pearson Education, Inc.
For more information about Grand Central Dispatch queues, see Concurrency Programming Guide: Dispatch
Queues.
About Open CL for OS X
Prerequisites
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
8This chapter describes a streamlined process in which, using tools provided by OS X v10.7, you can include
OpenCL kernels as resources in Xcode projects, compile them along with the rest of your application, and use
Grand Central Dispatch as the queuing API for executing OpenCL commands and kernels on the CPU and GPU.
If you need to create OpenCL programs at run-time, with source loaded as a string or from a file, or if you want
API-level control over queueing, see The OpenCL Specification , available from the Khronos Group at
http://www.khronos.org/registry/cl/.
Concepts
In the OpenCL specification, computational processors are called devices. An OpenCL device has one or more
compute units. A workgroup executes on a single compute unit. A compute unit is composed of one or more
processing elements and local memory.
A Macintosh computer has a single CPU and GPUs. The CPU on a Macintosh has multiple compute units, which
is why it is called a multi-core CPU. The number of compute units in a CPU limits the number of workgroups
that can execute concurrently.
CPUs commonly contain two to eight compute units, with the maximum increasing year-to-year. A graphics
processing unit (GPU) typically contains many compute units—the GPUs in current Macintosh systems feature
tens of compute units, and future GPUs may contain hundreds. As used by OpenCL, a CPU with eight compute
units is considered a single device, as is a GPU with 100 compute units.
The OS X v10.7 implementation of the OpenCL API facilitates designing and coding data parallel programs to
run on both CPU and GPU devices. In a data parallel program, the same program (or kernel) runs concurrently
on different pieces of data and each invocation is called a work item and given a work item ID. The work item
IDs are organized in up to three dimensions (called an N-D range).
A kernel is essentially a function written in the OpenCL language that enables it to be compiled for execution
on any device thatsupports OpenCL. Although kernels are enqueued for execution by host applications written
in C, C++, or Objective C, a kernel must be compiled separately to be customized for the device on which it is
going to run. You can write your OpenCL kernel source code in a separate file or include it inline in your host
application source code.
OpenCL kernels can be:
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
9
Developing OpenCL Programs Using Xcode● Compiled at compile time, then run when queued by the host application
or
● Compiled and then run at runtime when queued by the host application
or
● Run from a previously-built binary
A work item is a parallel execution of a kernel on some data. It is analogousto a thread. Each kernel is executed
upon hundreds of thousands of work items
A workgroup is set of work items. Each workgroup is executed on a compute unit.
Workgroup dimensions determine how the input is operated upon in parallel. The application usually specifies
the dimensions based on the size of the input. There are constraints: for example, there may be a maximum
number of work items that can be launched for a certain kernel on a certain device.
The program that calls OpenCL functions to set up the context in which kernels run and enqueue the kernels
for execution is known asthe host application. The application isrun by OS X on the CPU. The device on which
the host application executes is known as the host device. Before kernels can be run, the host application
typically completes the following steps:
1. Determine what compute devices are available, if necessary.
2. Select compute devices appropriate for the application.
3. Create dispatch queues for selected compute devices.
4. Allocate the memory objects needed by the kernels for execution. (This step may occur earlier in the
process, as convenient.)
Note that the host device (the CPU) can itself be an OpenCL device and can be used to execute kernels.
The host application can enqueue commands to read from and write to memory objects. See “Creating and
Managing Memory Objects in OS X OpenCL” (page 43). Memory objects are used to manipulate device
memory. There are two types of memory objects used in OpenCL: buffer objects and image objects. Buffer
objects can contain any type of data; image objects contain data organized into pixels in a given format.
Developing OpenCL Programs Using Xcode
Concepts
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
10Essential Development Tasks
In OS X v10.7, the OpenCL development process includes these major steps:
Figure 1-1 OpenCL Development Process
Step 1:
Parallelize.
Step 2:
Code kernel.
Step 3:
Code host.
Step 4:
Compile.
Step 5:
Execute.
Step 6:
Debug.
Step 7:
Optimize.
1. Identify the tasks to be parallelized.
Determining how to parallelize your program effectively is often the hardest part of developing an OpenCL
program. See “Identifying Parallelizable Routines” (page 29).
2. In Xcode, write your kernel functions. See “Basic Kernel Code Sample” (page 20).
3. In Xcode, write the host code that will be calling the kernel(s). See “Basic Host Code Sample” (page 21).
4. Compile using Xcode. See “Creating An Application That Uses OpenCL In Xcode” (page 12).
5. Execute.
6. Debug (if necessary). See “Debugging” (page 19).
7. Improve performance (if necessary). See “Improving Performance” (page 82).
Developing OpenCL Programs Using Xcode
Essential Development Tasks
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
11Creating an OpenCL program in OS X v10.7 is easy with support built into Xcode. This chapter describes
step-by-step how to create an OpenCL project in Xcode. If you already have a working OpenCL project, you
need not regenerate it, but you can find information in this chapter about support for OpenCL now built into
Xcode.
Creating An Application That Uses OpenCL In Xcode
To create a project that uses OpenCL in OS X v10.7:
1. Create your OpenCL project in Xcode as a new OS X project (empty is fine).
2. Place your kernel code in one or more .cl files in your Xcode project. You can place all your kernels into a
single .cl file, or you can separate them as you choose. You can also include non-kernel code that will run
on the same OpenCL device as the kernel in each .cl file.
Each .cl file is compiled by default into three files containing bitcode for i386, x86_64, and gpu_32
architectures. You can change this using the OpenCL Architectures Build Setting.)
At runtime your host application discovers what kind(s) of devices are available, and determines which of
the compiled kernels to enqueue and execute.
Figure 2-1 A simple OpenCL kernel in Xcode
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
12
Hello World!3. You can set the following build settings for your kernel (.cl) files:
Figure 2-2 Build settings for kernel files
● OpenCL Compiler Version
● Compiler Version
The OpenCL C compiler version supported by the platform. The default is OpenCL C 1.1. To set
this parameter from the command line, use:
-cl-std=CL1.1
● OpenCL - Architectures
● Valid Architectures
A StringList specifying the list of the architectures for which the product will be built. This is
usually set to a predefined build setting provided by the platform. The default is that the product
is built for all three architectures. To set this parameter from the command line, use:
● -triple i386-applecl-darwin
● -triple x86_64-applecl-darwin
● -triple gpu_32-applecl-darwin
(So to compile for the first two, the command line would read:
-triple i386-applecl-darwin -triple x86_64-applecl-darwin
● OpenCL - Preprocessing
● Preprocessor Macros
Space-separated list of preprocessor macros of the form "foo" or "foo=bar". To set this
parameter from the command line, use:
-D
Hello World!
Creating An Application That Uses OpenCL In Xcode
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
13● OpenCL - Code Generation
● Use MAD
Boolean. If true, allow expressions of the type a * b + c to be replaced by a Multiply-Add (MAD)
instruction. If MAD is enabled, multistep instructions in the form a * b + c are performed in a
single step, but the accuracy of the results may be compromised. For example, to optimize
performance, some OpenCL devices implement MAD by truncating the result of the a * b
operation before adding it to c.
The default for this parameter is NO. To set this parameter from the command line, use:
-cl-mad-enable
● Relax IEEE Compliance
Boolean. If true, allows optimizations for floating-point arithmetic that may violate the IEEE 754
standard and the OpenCL numerical compliance requirements defined in in section 7.4 for
single-precision floating-point, section 9.3.9 for double-precision floating-point, and edge case
behavior in section 7.5 of the OpenCL 1.1 specification.
This is intended to be a performance optimization.
This option causes the preprocessor macro __FAST_RELAXED_MATH__ to be defined in the
OpenCL program. The default is NO. To set this parameter from the command line, use:
-cl-fast-relaxed-math
● Double as single
Boolean. If true, double precision floating-point expressions are treated as single precision
floating-point expressions. This option is available for GPUs only. The default is NO. To set this
parameter from the command line, use:
-cl-double-as-single
● Flush denorms to zero
Boolean that controls how single precision and double precision denormalized numbers are
handled. Ifspecified as a build option, the single precision denormalized numbers may be flushed
to zero; double precision denormalized numbers may also be flushed to zero if the optional
extension for double precision is supported. This is intended to be a performance hint and the
OpenCL compiler can choose not to flush denorms to zero if the device supports single precision
(or double precision) denormalized numbers.
This option isignored forsingle precision numbersif the device does notsupportsingle precision
denormalized numbers i.e. CL_FP_DENORM bit is not set in CL_DEVICE_SINGLE_FP_CONFIG.
This option isignored for double precision numbersif the device does notsupport double precision
or if it does support double precision but not double precision denormalized numbers i.e.
CL_FP_DENORM bit is not set in CL_DEVICE_DOUBLE_FP_CONFIG.
Hello World!
Creating An Application That Uses OpenCL In Xcode
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
14This flag only applies for scalar and vector single precision floating-point variables and
computations on these floating-point variables inside a program. It does not apply to reading
from or writing to image objects.
The default is NO. To set this parameter from the command line, use:
-cl-denorms-are-zero
● Auto-vectorizer
Auto-vectorizes the OpenCL kernels for the CPU. This setting takes effect only for the CPU. This
makes it possible to write a single kernel that is portable and performant across CPUs and GPUs.
The default is YES. To set this parameter from the command line, use:
-cl-auto-vectorize-enable
or
-cl-autovectorize-disable
● Optimization Level
You can choose whether to optimize for smallest code size or not.
The default is fast O1 optimization.
To set this parameter from the command line, use:
● -Os sets it to optimize for smallest code size
● -O, O1 sets it to fast
● -O2 sets it to faster
● -O3 sets it to fastest
● -O0 sets it to not optimize
Hello World!
Creating An Application That Uses OpenCL In Xcode
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
154. Place your host code in one or more .c files in your Xcode project.
Figure 2-3 OpenCL host code in Xcode
5. Link to the OpenCL framework.
a. Click on the target.
b. Click the Build Phases tab.
c. Open Link Binary With Libraries.
d. Click the + sign.
Hello World!
Creating An Application That Uses OpenCL In Xcode
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
16e. Select OpenCL.framework from the dropdown.
Figure 2-4 Adding the OpenCL framework
f. Press Add.
Figure 2-5 OpenCL framework was added
6. Build.
Hello World!
Creating An Application That Uses OpenCL In Xcode
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
177. Run.
Figure 2-6 Results
See “Basic Programming Sample” (page 20) for a line-by-line description of the host and kernel code in the
Hello World sample project.
Compiling From the Command Line
To compile from the command line, call openclc.
Hello World!
Compiling From the Command Line
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
18Debugging
Here are a few hints to help you debug your OpenCL application:
● Run your kernel on the CPU first. There is no memory protection on GPUs. If an index goes out of bounds
on the GPU, it is likely to take the whole system down. If an index goes out of bounds on the CPU, it may
crash the program that’s running, but it will not take the whole system down.
● You can use the printf function from within your kernel.
● You can use the gdb debugger to look at the assembly code once you’ve built your program. See GDB
website.
● On the GPU, use explicit addressrange checksto look for out-of-range address accesses. (Remember: there
is no memory protection on current GPUs.)
Hello World!
Debugging
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
19This chapter provides a tour through the code of a simple OpenCL application that performs calculations on
a test data set. The code in Listing 3-2 (page 21) calls the kernel defined in Listing 3-1 (page 20). The kernel
squares each value. Once the kernel completes its work, the host validates that every value was processed by
the kernel.
Basic Kernel Code Sample
Listing 3-1 (page 20) is example kernel code. See to download the project.
Listing 3-1 Kernel code sample
////////////////////////////////////////////////////////////////////////////////
// Simple OpenCL kernel that squares an input array.
// This code is stored in a file called mykernel.cl.
kernel void square(global float* input, global float* output) [1]
{
size_t i = get_global_id(0);
output[i] = input[i] * input[i];
}
Notes:
1. Wrap your kernel code into a kernel block:
kernel void kernelName (
global float* inputParameterName,
global float* [anotherInputParameter] ,
…,
global float* outputParameterName)
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
20
Basic Programming Sample{
...
}
Note: Kernels always return void.
Basic Host Code Sample
Listing 3-2 (page 21) is example code that would run on a host. It calls a kernel to square a set of values, then
tests to ensure that the kernel processed all the data. See to download the project.
Listing 3-2 Host code sample
////////////////////////////////////////////////////////////////////////////////
#include
#include
// This include pulls in everything you need to develop with OpenCL on OS X v10.7.
#include
// Include the header file generated by Xcode. This header file contains the
// kernel block declaration.
#include "mykernel.cl.h" [1]
// Hardcoded number of values to test, for convenience.
#define NUM_VALUES 1024
// A utility function that checks that our kernel execution performs the
// requested work over the entire range of data.
static int validate(cl_float* input, cl_float* output) {
int i;
for (i = 0; i < NUM_VALUES; i++) {
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
21// The kernel was supposed to square each value.
if ( output[i] != (input[i] * input[i]) ) {
fprintf(stdout, "Error: Element %d did not match expected output.\n",
i);
fprintf(stdout, " Saw %1.4f, expected %1.4f\n", output[i],
input[i] * input[i]);
fflush(stdout);
return 0;
}
}
return 1;
}
int main (int argc, const char * argv[]) {
int i;
char name[128];
// First, try to obtain a dispatch queue that can send work to the
// GPU in our system. [2]
dispatch_queue_t queue = gcl_create_dispatch_queue(CL_DEVICE_TYPE_GPU,
NULL);
// In the event that our system does NOT have an OpenCL-compatible GPU,
// we can use the OpenCL CPU compute device instead.
if (queue == NULL) {
queue = gcl_create_dispatch_queue(CL_DEVICE_TYPE_CPU, NULL);
}
// This is not required, but let's print out the name of the device
// we are using to do work. We could use the same function,
// clGetDeviceInfo, to obtain all manner of information about the device.
cl_device_id gpu = gcl_get_device_id_with_dispatch_queue(queue);
clGetDeviceInfo(gpu, CL_DEVICE_NAME, 128, name, NULL);
fprintf(stdout, "Created a dispatch queue using the %s\n", name);
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
22// Now we gin up some test data. This is typically the case: you have some
// data in your application that you want to process with OpenCL. This
// test_in buffer represents such data. Normally, this would come from
// some REAL source, like a camera, a sensor, or some compiled collection
// of statistics -- it just depends on the problem you want to solve.
float* test_in = (float*)malloc(sizeof(cl_float) * NUM_VALUES);
for (i = 0; i < NUM_VALUES; i++) {
test_in[i] = (cl_float)i;
}
// Once the computation using CL is done, we'll want to read the results
// back into our application's memory space. Allocate some space for that.
float* test_out = (float*)malloc(sizeof(cl_float) * NUM_VALUES);
// Our test kernel takes two parameters: an input float array and an
// output float array. We can't send the application's buffers above, since
// our CL device operates on its own memory space. Therefore, we allocate
// OpenCL memory for doing the work. Notice that for the input array,
// we specify CL_MEM_COPY_HOST_PTR and provide the fake input data we
// created above. This tells OpenCL to copy over our data into its memory
// space before it executes the kernel. [3]
void* mem_in = gcl_malloc(sizeof(cl_float) * NUM_VALUES, test_in,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR);
// The output array is not initalized; we're going to fill it up when
// we execute our kernel. [4]
void* mem_out = gcl_malloc(sizeof(cl_float) * NUM_VALUES, NULL,
CL_MEM_WRITE_ONLY);
// Dispatch your kernel block using one of the dispatch_ commands and the
// queue we created above. [5]
dispatch_sync(queue, ^{
// Though we COULD pass NULL as the workgroup size, which would tell
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
23// OpenCL to pick the one it thinks is best, we can also ask
// OpenCL for the suggested size, and pass it ourselves. [6]
size_t wgs;
gcl_get_kernel_block_workgroup_info(square_kernel,
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(wgs), &wgs, NULL);
// The N-Dimensional Range over which we'd like to execute our
// kernel. In our example case, we're operating on a 1D buffer, so
// it makes sense that our range is 1D.
cl_ndrange range = {
1, // The number of dimensions to use.
{0, 0, 0}, // The offset in each dimension. We want to
// process ALL of our data, so this is 0 for
// our test case. [7]
{NUM_VALUES, 0, 0}, // The global range -- this is how many items
// IN TOTAL in each dimension you want to
// process.
{workgroup_size, 0, 0} // The local size of each workgroup. This
// determines the number of workitems per
// workgroup. It indirectly affects the
// number of workgroups, since the global
// size / local size yields the number of
// workgroups. So in our test case, we will
// have NUM_VALUE / wgs workgroups.
};
// Calling the kernel is easy; you simply call it like a function,
// passing the ndrange as the first parameter, followed by the expected
// kernel parameters. Note that we case the 'void*' here to the
// expected OpenCL types. Remember -- if you use 'float' in your
// kernel, that's a 'cl_float' from the application's perspective. [8]
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
24square_kernel(&range,(cl_float*)mem_in, (cl_float*)mem_out);
// Getting data out of the device's memory space is also easy; we
// use gcl_memcpy. In this case, we take the output computed by the
// kernel and copy it over to our application's memory space. [9]
gcl_memcpy(test_out, mem_out, sizeof(cl_float) * NUM_VALUES);
});
// Now we can check to make sure our kernel really did what we asked
// it to:
if ( validate(test_in, test_out)) {
fprintf(stdout, "All values were properly squared.\n");
}
// Don't forget to free up the CL device's memory when you're done. [10]
gcl_free(mem_in);
gcl_free(mem_out);
// And the same goes for system memory, as usual.
free(test_in);
free(test_out);
// Finally, release your queue just as you would any GCD queue. [11]
dispatch_release(queue);
}
Notes:
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
251. Include the header file that contains the kernel block declaration. The name of the header file for a .cl file
will be the name of the .cl file with .h appended to it. For example, if the .cl file is named mykernel.cl,
the header file you must include will be mykernel.cl.h.
2. Call gcl_create_dispatch_queue to create the dispatch queue.
3. Create memory objects to hold input and output data and write input data to the input objects. Allocate
an array on the OpenCL device from which to read kernel results back into host memory. Use gcl_malloc
and make sure to use the OpenCL size of the datatype being returned (e.g.,
gcl_malloc(sizeof(cl_float) * NUM_VALUES). Because the CL device operates on its own memory
space, allocate OpenCL memory for the input data upon which the kernel will work. Specify
CL_MEM_COPY_HOST_PTR to tell OpenCL to copy over the input data from host memory into its memory
space before it executes the kernel.
4. Allocate OpenCL memory in which the kernel will store its results.
5. Dispatch your kernel block using one of the dispatch commands and the queue you created above. In
your dispatch call, you can specify workgroup parameters.
6. Describe the data parallel range over which to execute the kernel. You will describe the data-parallel range
for the OpenCL kernel in the host code. The cl_ndrange structure is used to specify the data parallel
range.
OpenCL always executes kernels in a data parallel fashion—that is, instances of the same kernel (work
items) execute on different portions of the total data set. See “Representing Data With Buffer Objects” (page
46). (If you want task-parallel execution you must enqueue multiple kernels on different devices.) Each
work item is responsible for executing the kernel once and operating on its assigned portion of the data
set. It is your responsibility to tell OpenCL the total number of work items that you need to process all of
your data. Because data sets are commonly organized in one, two, or three dimensions (representing such
things as audio data streams, two- or three-dimensional images, or three-dimensional objects), you also
need to indicate to OpenCL in how many dimensions your data extends (that is, how many coordinates
to use for each data point).
● Determining the Data Dimensions
The first step in preparing a kernel for execution is to identify the number of dimensions that you
want to use to represent your data. For example, if your data represents a flat image that is m pixels
wide by n pixels high, then you have a two-dimensional data set with each data pointed represented
by its coordinates on the m and n axes. On the other hand, if you’re dealing with spatial data that
involves the (x, y, z) position of nodes in three-dimensional space, you have a three-dimensional data
set. Another way to look at the dimensionality of your data is in terms of nested loops in a traditional,
non-parallel processing model. If you can loop through your entire data set with a single loop, then
your data is one-dimensional. If you would use one loop nested in another, your data is
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
26two-dimensional, and if you would have loops nested three deep to cycle through all your data, your
data is three-dimensional. Whatever your data is, it’s up to you to determine how many dimensions
to use. As of OpenCL 1.0, dimensions greater than three are not supported.
● Determining the Number of Work Items
The next step in preparing your kernel for execution is determining how many work items you'll need
to process all of your data. This is known as the global work size, and it defines the total number of
work items needed for all dimensions combined. For one-dimensional data, the global work size
equals the number of data items. For two-dimensional data with m data items in one dimension and
n items in the second dimension, the global work size is n * m. Similarly, for three-dimensional data
with x , y , and z work itemsin the three dimensions, the global work size is x * y * z . There is practically
no limit on the number of work items, and this should be a large number (over 1000) for good
performance on GPUs.
● Choosing a Workgroup Size
When enqueuing a kernel to execute on a device, you can specify the size of the workgroup that you’d
like OpenCL to use during execution. A workgroup is a collection of work items that execute on the
same compute unit on the same OpenCL device. By providing OpenCL with a suggested workgroup
size, you are telling it how you would like it to delegate the work items to the various computational
units on the device. The work items executing in the same workgroup can share memory and execute
synchronously. In order to take advantage of these features, however, you have to know the maximum
workgroup size allowed by the OpenCL device on which your work items are executing. To get this
information, use the gcl_get_kernel_block_workgroup_info function and request the
CL_KERNEL_WORK_GROUP_SIZE property. This API isrequired to query the workgroup size of a kernel
block to use in cl_ndrange.local_work_size. Thisis needed for good performance across devices
asthe workgroup sizes vary across devices. This API must be called inside a block submitted to a Grand
Central Dispatch queue created using gcl_create_dispatch_queue. If you don’t need to share
data among work items, pass a NULL value to the local_work_size parameter when you enqueue
your kernel for execution to have OpenCL determine the workgroup size for you. Doing so will ensure
the most efficient use of the available devices.
Note that you also need to use clGetDeviceInfo with the selector
CL_DEVICE_MAX_WORK_ITEM_SIZES to get the maximum workgroup size in each dimension, and
call the gcl_get_kernel_block_workgroup_info function with the selector
CL_KERNEL_WORK_GROUP_SIZE to get the total workgroup size.
Three conditions must be met for the local dimensions to be valid:
a. The number of work items in each dimension (local_x, local_y, and local_z) in a single
workgroup must be less than the values returned for the device from
clGetDeviceInfo(CL_DEVICE_MAX_WORK_ITEM_SIZES).
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
27b. The total number of work items in a workgroup (local_x times local_y times local_z
) must be less than or equal to the value returned by the
gcl_get_kernel_block_workgroup_info(CL_KERNEL_WORK_GROUP_SIZE) function.
c. The number of work items in each dimension in a single workgroup must divide evenly into the
total number of work items in that dimension ( global_n mod local_n = 0).
7. Always pass an offset for each of three dimensions even though the workgroup may have fewer than
three dimensions.
8. Call the kernel as you would call a function. Pass the ndrange as the first parameter, followed by the
expected kernel parameters. Case the void* types to the expected OpenCL types. Remember -- if you
use float in your kernel, that's a cl_float from the application's perspective. The call to the kernel will
look something like this:
kernelName(
&range,
(cl_datatype*)inputArray,
(cl_datatype *)outputArray );
9. Retrieve the data from the OpenCL device's memory space with gcl_memcpy. The output computed by
the kernel is copied over to the host application's memory space.
10. Free OpenCL memory objects.
11. Call dispatch_release(...) on the dispatch queue you created with gcl_create_dispatch_queue(...)
once you are done with it.
Basic Programming Sample
Basic Host Code Sample
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
28The first step in using OpenCL to improve your application’s performance is to identify what portions of your
application are appropriate for parallelization. Whereas in a general application you can spawn a separate
thread for a task as long as the functions in the thread are re-entrant and you’re careful about how you
synchronize data access, to achieve the level of parallelism for which OpenCL isideal, it is much more important
for the work items to be independent of each other. Although work items in the same workgroup can share
local data, they execute synchronously and so no work item’s calculations depend on the result from another
work item. Parallelization works only when the tasks that you run in parallel do not depend on each other.
For example, assume that you are writing a simple application that keeps track of the grades for students in a
class. The application consists of two main tasks:
1. Compute the final grade for each student, assuming the final grade is the average of all the students’
grades.
2. Obtain a class average by averaging the final grades of all students.
You cannot perform these two tasks in parallel because they are not independent of each other: to calculate
the class average, you must have already calculated the final grade for each student.
Despite the fact that you cannot perform task 1 and task 2 simultaneously, there is still an opportunity for
parallelization. To see how it can be broken down, it helpsto look at a basic pseudocode example for computing
the final grade for each student serially.
Listing 4-1 Pseudocode that computes the final grade for each student
// assume 'class' is a collection of 'student' objects
foreach(student in class)
{
// assume getGrades() returns a collection of integer grades
grades = student.getGrades();
sum = 0;
count = 0;
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
29
Identifying Parallelizable Routines// iterate through each grade, adding it to sum
foreach(grade in grades)
{
sum += grade;
count++;
}
// cache the average grade in the student object
student.averageGrade = sum / count;
}
The pseudocode in Listing 4-1 (page 29) proceeds through each student in the class, one by one, calculating
the average of each student’s grades and caching it in the student object. Although this example computes
each grade average one at a time, there’s no reason that the grade averages for all the students couldn’t be
calculated at the same time. Because the grades of one student do not affect the grades of another, you can
calculate the grade averages for all the students at the same time instead of looping through the same set of
instructions for each student, one at a time. This is the idea behind data parallelism.
Data parallelism consists of taking a single task (in this case, calculating a student’s average grade), and repeating
it over multiple sets of data. Students’ grades do not affect each other, therefore you can process them in
parallel. To express this programmatically, you must first separate your task (calculating the grade average of
a student) from your data (the students in the class). Listing 4-2 (page 30) shows how you can isolate the
grade-averaging task.
Listing 4-2 The isolated grade average task
task calculateAverageGradeForStudent( student )
{
// assume getGrades() returns a collection of integer grades
grades = student.getGrades();
sum = 0;
count = 0;
// iterate through each grade, adding it to sum
foreach(grade in grades)
Identifying Parallelizable Routines
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
30{
sum += grade;
count++;
}
// store the average grade in the student object
student.averageGrade = sum / count;
}
Now that you have the task isolated, you need to apply it to allstudentsin the classin parallel. Because OpenCL
has native support for parallel computing, you can rewrite the task shown in Listing 4-2 (page 30) as an OpenCL
kernel function. Using the OpenCL framework API, you can enqueue this kernel to run on a device where each
compute unit on the device can apply an instance of the kernel (that is, a work item) to a different set of data.
The challenge in parallelizing your application is identifying the tasks that you can distribute across multiple
compute units. Sometimes, asin this example, the identification isrelatively trivial and requiresfew algorithmic
changes. Other times, it might require designing a new algorithm from scratch that lends itself more readily
to parallelization. Although there is no universal rule for parallelizing your application, there are a few tips you
can keep in mind:
● Pay attention to loops.
Often the opportunities for parallelization lie within a subroutine that is repeated over a range of results.
● Nested loops might be restructured as multi-dimensional parallel tasks.
● Find as many tasks as possible that do not depend on each other.
Finding a group of routines that do not share memory or depend on each other’s results is usually a good
indicator that you can perform them in parallel. If you have enough such tasks, you can consider writing
a task-parallel OpenCL program.
● Due to the overhead of setting up a context and transferring data over a PCI bus, you must be processing
a fairly large data set before you see any benefits from using OpenCL. The exact point at which you start
to see benefits depends on the OpenCL implementation and the hardware being used, so you will have
to experiment to see how fast you can get your algorithm to execute. In general, a high ratio of computation
to data access and lots of mathematical computations are good for OpenCL programs.
Identifying Parallelizable Routines
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
31Developers already use Grand Central Dispatch (GCD) queues to implement concurrency in their applications.
OS X v10.7 adds the ability to enqueue work coded as OpenCL kernels to GCD queues backed by OpenCL
compute devices.
You can use GCD with OS X v10.7 OpenCL to:
●
Investigate the computational environment in which your OpenCL application is running.
You can use OS X v10.7 OpenCL to learn about the devicesin the system that would be best for performing
particular OpenCL computations and to enqueue kernels to devices:
● You can find out about the computational power and technical characteristics of each OpenCL-capable
device in the system. See “Discovering Available Compute Devices” (page 32).
● GCD can suggest which OpenCL device(s) would be best for running a particular kernel.
● You can obtain recommendations about how to configure the kernel - get the suggested optimal size
of the workgroup for each kernel on any particular device. See “Obtaining the Kernel’s Workgroup
Size” (page 35).
● Enqueue the kernel.
● Synchronize work between the host and OpenCL devices and synchronize work between devices.
Your host can wait on completion of work in all queues (See “Using GCD To Synchronize A Host With
OpenCL” (page 69)) or one queue can wait on completion of another queue (See “Synchronizing Multiple
Queues” (page 75)).
Discovering Available Compute Devices
OpenCL kernels assume a Single instruction, Multiple Data (SIMD) parallel model of computation. This means
(roughly) that you have a large amount of data divided into chunks, and you want the kernel to perform the
same computation on each chunk. Some SIMD algorithms will execute better on a CPU rather than on a GPU,
or on one GPU rather than another, depending on many factors. Tools in OS X version 7 and later facilitate
discovery of the types of devices that are available to process data.
A context is needed to share memory objects between devices. If you use The OS X v10.7 gcl_ APIs, you can
just retrieve and use the default global context; no context creation is needed.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
32
Using Grand Central Dispatch With OpenCLNote: If you are using APIs defined in the OpenCL specification, you do need to create your own
contexts.
An OpenCL context is similar to an OpenGL sharegroup. A sharegroup is a set of tools that allow blocks of
memory to be accessed by both a GPU and a CPU. See “OpenCL/ OpenGL Interoperation: Data Sharing” (page
66).
When you retrieve the default global context in OS X v10.7 OpenCL, you can find out about the environment
in which OpenCL kernels execute. The context includes the set of devices, the memory accessible to those
devices, and one or more queues used to schedule execution of one or more kernels.
From the context, you can discover the types of devices in the system and can obtain recommendations as to
the optimal configuration for running a kernel. Your application can call on GCD to create a queue for a particular
type of device or to create a queue for a specific device.
1. Call the gcl_get_context function to get the "global" OpenCL context that OS X v10.7 creates for you.
Note: Since this context is created by the OpenCL, you should not retain / release it. (You should
retain/release any contexts that you explicitly create.)
2. Call the clGetDeviceIds( ... ) function (an API in the OpenCL standard API), specifying the context you
just obtained asthe context parameter. This call will return a list of the IDs of the OpenCL devices attached.
3. When you have the IDs of the devices in the context, you can call the clGetDeviceInfo() function for
each of the devices to obtain information about the device. The sample code in Listing 5-1 (page 37)
requeststhe vendor (the manufacturer) and the device name. You could also use the clGetDeviceInfo()
function to request more technical information like the number of compute cores, the cache line size and
so on. The types of information you can obtain are described in the OpenCL 1.1 specification. You can
choose to send different types of work to a device depending upon its characteristics and capabilities.
Enqueueing A Kernel To A Dispatch Queue
You must use an OpenCL-compatible dispatch queue for your OpenCL work. You can create a queue for a
particular device in the system or you can create a queue for a particular type of device. You can enqueue as
many kernels on each queue as you choose. You can create as many different queues as you would like:
● To create a dispatch queue to run on any device so long as it’s of a particular type, call the
gcl_create_dispatch_queue function passing CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_GPU, or
CL_DEVICE_TYPE_ACCELERATOR as the first parameter.
Using Grand Central Dispatch With OpenCL
Enqueueing A Kernel To A Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
33Note: The dispatch queue you create must be attached to a particular device type. You cannot
create an OpenCL-compatible dispatch queue for the default device type
(CL_DEVICE_TYPE_DEFAULT).
OS X v10.7 OpenCL will create a dispatch queue that uses a GPU or CPU, depending upon the device type
you specified. If more than one GPU is available, OS X v10.7 OpenCL will give enqueue the kernel on the
device of the type you specify that has the largest number of compute cores.
Note: If you've created your dispatch queue specifying CL_DEVICE_TYPE_GPU, you won't
know whichGPUis being used. Callthe gcl_get_device_id_with_dispatch_queue function
to find out which device is actually attached to a given dispatch queue.
●
If you know exactly which OpenCL device id you want to use because you've obtained it with the
clGetDeviceIds function and found out about it using the clGetDeviceInfo function, call the
cl_create_dispatch_queue function with CL_DEVICE_TYPE_USE_ID and pass the id of the device
you want to use.
Both of these methods are illustrated in the sample code. See Listing 5-1 (page 37).
Note: Always call the dispatch_release(...) function on the dispatch queue you created with
the gcl_create_dispatch_queue(...) function once you are done with it. All of the example code
contains this call.
Once you have created a queue, you can enqueue as many kernels onto that queue as necessary. Or, you can
create additional queues with different characteristics.
For more information about Grand Central Dispatch queues, see Concurrency Programming Guide: Dispatch
Queues.
Determining the Characteristics Of A Kernel On A Device
To obtain information specific to a kernel/device pair, including how much private and local memory the kernel
will consume (on that device), as well as the workgroup size OpenCL thinks will be most optimal for execution,
call the gcl_get_kernel_block_workgroup_info function. Thisinformation is useful when you are tuning
performance for a particular device or debugging performance issues.
Using Grand Central Dispatch With OpenCL
Determining the Characteristics Of A Kernel On A Device
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
34Obtaining the Kernel’s Workgroup Size
To find out what OpenCL thinks is the best workgroup size for executing a kernel on a particular device, call
the gcl_get_kernel_block_workgroup_info function. You can use this value as the
cl_ndrange.local_work_size for a kernel on a particular device.
Note: You must call this API inside a block submitted to a GCD dispatch queue created using the
gcl_create_dispatch_queue function.
In Listing 5-1 (page 37), notice that we first execute this method in a block on a dispatch queue we've created
with OpenCL requesting the local memory size:
gcl_get_kernel_block_workgroup_info(
square_kernel,
CL_KERNEL_LOCAL_MEM_SIZE,
sizeof(local_memsize),
&local_memsize, NULL);
Then, in Listing 5-2 (page 40), we call the gcl_get_kernel_block_workgroup_info function to ask OpenCL
to return what it considers to be the optimal workgroup size for this kernel, on this device:
gcl_get_kernel_block_workgroup_info(
square_kernel, // this kernel
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(workgroup_size), &workgroup_size, NULL);
fprintf(stdout, "Workgroup size: %ld\n",
workgroup_size);
Finally, we call the gcl_get_kernel_block_workgroup_info function to once more to ask OpenCL for a
workgroup size multiple. This is a performance hint based on the capabilities of the underlying device:
gcl_get_kernel_block_workgroup_info(
square_kernel, // this kernel
CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
sizeof(preferred_workgroup_size_multiple),
&preferred_workgroup_size_multiple, NULL);
Using Grand Central Dispatch With OpenCL
Obtaining the Kernel’s Workgroup Size
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
35You can now use these workgroup valuesto craft an appropriate cl_ndrange structure to use in launching
your kernel.
cl_ndrange range = {
1, // The number of dimensions to use.
{0, 0, 0}, // The offset in each dimension. We want to
// process ALL of our data, so this is 0 for
// our test case.
// Always pass an offset for each of the
// three dimensions even though the workgroup
// may have fewer than three dimensions.
{NUM_VALUES, 0, 0}, // The global range -- this is how many items
// IN TOTAL in each dimension you want to
// process.
// Always pass the global range for each of the
// three dimensions even though the workgroup
// may have fewer than three dimensions.
{workgroup_size, 0, 0 } // The local size of each workgroup. This
// determines the number of workitems per
// workgroup. It indirectly affects the
// number of workgroups, since the global
// size / local size yields the number of
// workgroups. So in our test case, we will
// have NUM_VALUE/workgroup_size workgroups.
// Always pass the workgroup size for each of the
// three dimensions even though the workgroup
// may have fewer than three dimensions.
};
Using Grand Central Dispatch With OpenCL
Obtaining the Kernel’s Workgroup Size
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
36Sample Code: Creating a Dispatch Queue
Listing 5-1 (page 37) demonstrates how to get the global OpenCL context, and how to ask that context about
the devices it contains. It also shows how to create a dispatch queue by asking for a device type (CPU or GPU),
and by specifying the queue's OpenCL device directly.
Listing 5-2 (page 40) shows how to obtain workgroup information -- useful for obtaining peak performance
-- from the kernel block.
Listing 5-1 Creating a dispatch queue
#include
// Include OpenCL/opencl.h to include everything you need for OpenCL
//development on OS X v10.7.
#include
// In this example, mykernel.cl.h is the header file that contains our kernel block
// declaration.
// This header file is generated by Xcode.
#include "mykernel.cl.h"
static void print_device_info(cl_device_id device) {
char name[128];
char vendor[128];
clGetDeviceInfo(device, CL_DEVICE_NAME, 128, name, NULL);
clGetDeviceInfo(device, CL_DEVICE_VENDOR, 128, vendor, NULL);
fprintf(stdout, "%s : %s\n", vendor, name);
}
#pragma mark -
#pragma mark Hello World - Sample 1
// Demonstrates how to get the global OpenCL context, and how to ask that
// context about the devices it contains. It also shows how
// to create a dispatch queue by asking for a device type (CPU or GPU) and
Using Grand Central Dispatch With OpenCL
Sample Code: Creating a Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
37// by specifying the queue's OpenCL device directly.
static void hello_world_sample1 ()
{
int i;
// Ask for the global OpenCL context:
// Note: If you will not be enqueing to a specific device, you do not need
// to retrieve the context.
cl_context context = gcl_get_context();
// Query this context to see what kinds of devices are available to us.
size_t length;
cl_device_id devices[8];
clGetContextInfo(
context, CL_CONTEXT_DEVICES, sizeof(devices), devices, &length);
// Walk over these devices, printing out some basic information. We could
// query any of the information available about the device here.
fprintf(stdout, "The following devices are available for use:\n");
int num_devices = (int)(length / sizeof(cl_device_id));
for (i = 0; i < num_devices; i++) {
print_device_info(devices[i]);
}
// To do any work, you need to create a dispatch queue associated
// with some OpenCL device. You can either let the system give you
// a GPU -- perhaps the only GPU -- or the CPU device. Or, you can
// create a dispatch queue with a cl_device_id you specify. This
// device id comes from the OpenCL context, as above. Below are three
// examples.
Using Grand Central Dispatch With OpenCL
Sample Code: Creating a Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
38// 1. Ask for a GPU-based dispatch queue; notice that we do not provide a
// device id - we let the system give us the most capable GPU.
dispatch_queue_t gpu_queue =
gcl_create_dispatch_queue(CL_DEVICE_TYPE_GPU, NULL);
// Get the device from the queue, so we can ask OpenCL questions about it.
// Note that we check to make sure there WAS an OpenCL-capable GPU in the
// system by checking against a NULL return value.
if (gpu_queue != NULL) {
cl_device_id gpu_device =
gcl_get_device_id_with_dispatch_queue(gpu_queue);
fprintf(stdout, "\nAsking for CL_DEVICE_TYPE_GPU gives us:\n");
print_device_info(gpu_device);
} else {
fprintf(stdout, "\nYour system does not contain an OpenCL-compatible "
"GPU\n.");
}
// 2. Let's try the same thing for CL_DEVICE_TYPE_CPU. All Macintosh
// systems will have a CPU OpenCL device, so we don't have to worry about
// checking for NULL, as we did in the case of a GPU.
dispatch_queue_t cpu_queue =
gcl_create_dispatch_queue(CL_DEVICE_TYPE_CPU, NULL);
cl_device_id cpu_device = gcl_get_device_id_with_dispatch_queue(cpu_queue);
fprintf(stdout, "\nAsking for CL_DEVICE_TYPE_CPU gives us:\n");
print_device_info(cpu_device);
// 3. Or perhaps you are in a situation where you want a specific device
// from the list of devices you found on the context.
Using Grand Central Dispatch With OpenCL
Sample Code: Creating a Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
39// Notice the difference here:
// We pass CL_DEVICE_TYPE_USE_ID and a device_id. We'll just use the
// first device on the context from above, whatever that might be.
dispatch_queue_t custom_queue =
gcl_create_dispatch_queue(CL_DEVICE_TYPE_USE_ID, devices[0]);
cl_device_id custom_device =
gcl_get_device_id_with_dispatch_queue(custom_queue);
fprintf(stdout,
"\nAsking for CL_DEVICE_TYPE_USE_ID and our own device gives us:\n");
print_device_info(custom_device);
// Now we could use any of these dispatch queues to run some kernels!
// Use the GCD API to free your queues.
dispatch_release(custom_queue);
dispatch_release(cpu_queue);
if (gpu_queue != NULL) dispatch_release(gpu_queue);
}
Listing 5-2 Obtaining workgroup information
#pragma mark -
#pragma mark Hello World - Sample 2
// This listing shows how to obtain workgroup info –
// useful for obtaining peak performance - from the kernel block.
static void hello_world_sample2() {
// Get a queue backed by a GPU for running our squaring kernel.
dispatch_queue_t queue =
Using Grand Central Dispatch With OpenCL
Sample Code: Creating a Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
40gcl_create_dispatch_queue(CL_DEVICE_TYPE_GPU, NULL);
// Did we get a GPU? If not, fall back to the CPU device.
if (queue == NULL) {
gcl_create_dispatch_queue(CL_DEVICE_TYPE_GPU, NULL);
}
// In any case, print out the device we're using:
fprintf(stdout, "\nExamining workgroup info for square_kernel on device ");
print_device_info(gcl_get_device_id_with_dispatch_queue(queue));
// Now find out what OpenCL thinks is the best workgroup size for
// executing this kernel on this particular device. Notice that we have
// to execute this method in a block, on a dispatch queue we've created
// with OpenCL.
dispatch_sync(queue,
^{
size_t wgs, preferred_wgs_multiple;
cl_ulong local_memsize, private_memsize;
// The next two calls give us information about how much
// memory, local and private, is used by the kernel on this
// particular device.
gcl_get_kernel_block_workgroup_info(square_kernel,
CL_KERNEL_LOCAL_MEM_SIZE,
sizeof(local_memsize),
&local_memsize, NULL);
fprintf(stdout, "Local memory size: %lld\n", local_memsize);
gcl_get_kernel_block_workgroup_info(square_kernel,
CL_KERNEL_PRIVATE_MEM_SIZE,
sizeof(private_memsize),
&private_memsize, NULL);
Using Grand Central Dispatch With OpenCL
Sample Code: Creating a Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
41fprintf(stdout, "Private memory size: %lld\n",
private_memsize);
// Here we ask OpenCL what it considers the optimal workgroup
// size for this kernel on this device.
gcl_get_kernel_block_workgroup_info(square_kernel,
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(wgs), &wgs, NULL);
fprintf(stdout, "Workgroup size: %ld\n", wgs);
// Finally, we can ask OpenCL for a workgroup size multiple.
// This is a performance hint.
gcl_get_kernel_block_workgroup_info(square_kernel,
CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
sizeof(preferred_wgs_multiple),
&preferred_wgs_multiple, NULL);
fprintf(stdout, "Preferred workgroup size multiple: %ld\n",
preferred_wgs_multiple);
// You could now use these workgroup values to craft an
// appropriate cl_ndrange structure for use in launching
your kernel.
});
dispatch_release(queue);
}
int main(int argc, const char* argv[]) {
hello_world_sample1();
hello_world_sample2();
}
Using Grand Central Dispatch With OpenCL
Sample Code: Creating a Dispatch Queue
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
42This chapter provides an overview of how memory is used with OpenCL (since this differsfrom the way memory
is used in conventional programs), describes how buffers are created and used in OpenCL, describes how
images are created and used in OpenCL, and provides information about using memory in situations such as
with IOSurfaces and OpenGL textures.
Overview
Like all computational processes, processes that run on OpenCL devices consist of:
● Data
The data accessed by OpenCL instructions exists as memory buffers and cl_image memory objects. Use
image objects for representing 2D or 3D images (see “Creating and Using Images in OpenCL” (page 54));
use buffer objects for containing other types of generic data (see “Creating and Using Buffers in
OpenCL” (page 46)).
●
Instructions (in kernel functions) that manipulate the data.
Even if they are physically contiguous, host memory is distinct from OpenCL memory. Kernel instructions can
only access data in the memory of OpenCL devices. The host computer can read and write to device memory,
but only to set it up and retrieve results. During computation, a device looks only in device memory, and the
host stays out of its way.
In other words, in OpenCL, you launch a set of work items against a bolus of data. While this data might have
been passed to the OpenCL device by the host, the data resides on the OpenCL device at the time of execution.
A kernel cannot read or write to the host memory; it can only access data its own separate memory area. For
many devices(like GPUs), the OpenCL is actually a physically distinct piece ofsilicon. For other devices, although
the memory is physically on the same chip, it can only be read/written by the OpenCL kernel code.
Workflow
The basic workflow with OpenCL is:
1. Create memory objects for use by OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
43
Creating and Managing Memory Objects in OS X
OpenCLThe host requests that memory be set aside for it on the device. The host can ask for as many memory
objects as it wants, up to the memory available.
2. Initialize the contents of the memory objects
a. The host can pass data to the device to be stored in its memory objects. Thisisthe data that the kernel
will process. The host can also instruct the device to leave some memory objects uninitialized so that
when the kernel runs on the device, it can fill up these memory objects as its output.
b. The host instructs the device to execute the kernel, passing it the memory objects it has created on
the OpenCL device as arguments. The host will wait until the kernel is done.
3. Execute the kernel
The kernel runs on the device, processing the data in the input memory, producing output to be stored
in the designated output memory.
4. Read results from the memory objects
When the host detects that the kernel has completed its tasks, it copies the results the kernel stored in
the designated output memory into memory the host can access."
5. Destroy the memory objects
Once the host has retrieved the output data, it instructs the device to free up the memory it had set aside
for the kernel to use.
Memory Visibility
In a typical multi-device environment, memory is distributed between devices. No device can access all memory.
For example, an OpenCL kernel resides in a separate memory space from the host that calls it. In order for the
kernel to accessthe data it isto process, the data must be moved into the device’s memory. However, transferring
data between memory areas to allow different devices to work can result in considerable overhead. Minimize
the amount of data being transferred to optimize performance.
The host specifies the memory space for a given buffer when it declares each kernel argument.
Creating and Managing Memory Objects in OS X OpenCL
Overview
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
44The memory spaces as an OpenCL device would see them are:
Figure 6-1 Physical memory of an OpenCL system
OpenCL Device
Host
Work Item
Local Memory
Workgroup
Global/Constant Memory
Host Memory
Private
Memory
Work Item
Private
Memory
Work Item
Local Memory
Workgroup
Private
Memory
Work Item
Private
Memory
● Private memory
Each work item has memory that only it can see. This is its private memory.
● Local memory
Local memory is memory that work items WITHIN a work group can share. Local memory is useful if more
than one work item in a group needs to use a particular chunk of global memory. You can write your
OpenCL program so that one work item loads from global memory to local memory, and then the rest of
the work items that need that piece of data can use the "local" copy. It takes GPU devices much less time
to access local memory than to access global memory.
● Global memory
This is the (relatively) massive chunk of device memory that ALL work items can "see". Any work item can
read / write to a buffer declared to be in global memory.
● Constant memory
Creating and Managing Memory Objects in OS X OpenCL
Overview
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
45Thisis a specialized section of global memory for data that you the programmer know will remain constant
throughout the execution of your kernel. It is more limited in size than global memory (typically), but is
faster to access on many devices than other global memory.
Memory Consistency
Changes a work item has made to global or local memory may not immediately become visible to other work
items within a workgroup. An system’s consistency has to do with when changes a work item has made to
global or local memory become visible to other work items within a workgroup.
OpenCL uses what is called a relaxed memory consistency model, which means that:
● Work items can access data within their own private memory, local memory, constant memory, and global
memory.
● Work items can share local memory during the execution of a workgroup. However, memory is only
guaranteed to be consistent after specific synchronization points.
If a work item needs to read something that another work item has written, then you will need to place
a barrier in your OpenCL code at the point where you want the memory to be consistent. The barrier will
stop any work item at the barrier until all other work items have "caught up". That's why it works -- every
work item in the workgroup has written its memory by that point, so it's safe to go on and read anything
any work item in the group has written. See “Using GCD To Synchronize A Host With OpenCL” (page 69).
Note: You can create a barrier that appliesto local memory or to global memory, but consistency
only appliesto work items within a work group. There is no such thing as a global memory barrier
that will make all threads in an execution wait. OpenCL only guarantees memory consistency
at a barrier within a work group.
Creating and Using Buffers in OpenCL
Representing Data With Buffer Objects
The OpenCL programming interface provides buffer objects for representing generic data in your OpenCL
programs. Instead of having to convert your data to the domain of a specific type of hardware, OpenCL enables
you to transfer your data as is to an OpenCL device via buffer objects and operate on the data using the same
language features that you are accustomed to in C.
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Buffers in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
46OpenCL is designed to share efficiently with OpenGL. Wherever possible, data is shared between OpenCL and
OpenGL programs; it is not copied.
Because transmitting data is costly, it is best to minimize reads and writes as much as possible. By packaging
all of your host data into a buffer object that can remain on the device, you reduce the amount of data traffic
necessary to process your data.
Allocating Memory For Buffer Objects In OS X v10.7
If you need a cl_mem object, (you will need one of these if you are going to be using a standard OpenCL API
call), call the gcl_malloc function to allocate the memory, then call the gcl_create_buffer_from_ptr
function to convert the handle gcl_malloc returns for use with the standard OpenCL API.
To create buffer objects:
● void * gcl_malloc(size_t bytes, void *host_ptr, cl_malloc_flags flags)
The gcl_malloc function returns a void * which is a memory object handle. The bytes parameter is
the number of bytes to be allocated. The host_ptr parameter . The flags parameter and can be 0 or
CL_MEM_USE_HOST_PTR.
Note: The void * value returned cannot be used to directly access the memory region on the
host CPU. To access this memory region for reading and writing on the host CPU, use APIs such
as cl_memcpy that can be passed in a block to GCD APIs that queue tasks for dispatch.
● cl_mem gcl_create_buffer_from_ptr(void *ptr)
The cl_mem gcl_create_buffer_from_ptr function creates a cl_mem buffer object from a ptr returned by
cl_malloc.
The cl_mem object returned can be used by CL API calls to enable sharing of objects between Grand CL
and the OpenCL API. The cl_mem object returned references the data store associated with the ptr
parameter.
Note: Be sure to release cl_mem objects created using gcl_create_buffer_from_ptr
before freeing this pointer using gcl_free.
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Buffers in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
47Reading, Writing, and Copying Buffer Objects
You can create memory objects outside a dispatch queue and the memory objects you create do not have to
be associated with any particular device. But before the memory object is accessed by OpenCL, it must be
associated with the device the data will be moving into and out of. You associate a memory object with its
device in the dispatch queue..
After you’ve created a buffer object, you can enqueue reads, writes, and copies. You can call the following
functions from your host application. These can be passed in a block(s) to the Grand Central Dispatch APIs that
queue tasks for dispatch such as dispatch_async. They enable you to move data to and from a host.
void gcl_memcpy(void *dst, const void *src, size_t size);
void gcl_memcpy_rect(void *dst, const void *src,
const size_t dst_origin[3],
const size_t src_origin[3],
const size_t region[3],
size_t dst_row_pitch,
size_t dst_slice_pitch,
size_t src_row_pitch,
size_t src_slice_pitch);
void *gcl_map_ptr(void *ptr, cl_map_flags map_flags, size_t cb);
void *gcl_map_image(cl_image image, cl_map_flags map_flags,
const size_t origin[3], const size_t region[3]);
void gcl_unmap(void *ptr);
Kernel Support For Data Processing In OpenCL-C
By associating your buffer object with specific kernel arguments, you make it possible to process your data
from the context of a kernel function. For example, in “Example: Allocating, Using, Releasing Buffer Objects” (page
50), notice how the code sample treats the input data pointer much as you would treat a pointer in C. In this
example the input data is an array of float values, and you can process each element of the float array by
indexing into the pointer. “Example: Allocating, Using, Releasing Buffer Objects” (page 50) does little more
than multiply a value by itself using the * operator, but OpenCL-C provides a wide array of data types and
operators that enable you to perform more complex arithmetic.
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Buffers in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
48Because OpenCL-C is based on C99, you are free to process your data in OpenCL-C functions as you would in
C with few limitations. Aside from support for recursion and function pointers, there are not many language
features that C has that OpenCL-C doesn’t have. In fact, OpenCL-C provides several beneficial features that the
C programming language does not offer natively, such as optimized image access functions.
OpenCL-C has built-in support for vector intrinsics and offers vector data types. The operators in OpenCL-C
are overloaded, and performing arithmetic between vector data typesissyntactically equivalent to performing
arithmetic between scalar values. Refer to the TheOpenCL Specification for more details on the built-in functions
and facilities of the OpenCL-C language.
Releasing Buffer Objects
To avoid memory leaks, free buffer objects when they are no longer needed. Call gcl_free to free buffer
objects created using gcl_malloc.
void gcl_free(void *ptr);
The ptr parameter is the handle of the buffer object to be released.
OpenCL uses a reference counting system to keep track of the memory objects currently being used. The
reference count represents how many other objects hold referencesto the particular memory object. Any time
you create a buffer object, it immediately receives a reference count of 1. Any time another object would also
like to maintain a reference to it, it should increment the buffer object’s reference count by calling the
clRetainMemObject function. When an object wishes to relinquish its reference to a buffer object, it should
call clReleaseMemObject. When the reference count for a buffer object reaches zero, OpenCL frees it,
returning the memory to the system and making any persisting references to the buffer object invalid.
Setting the finalizer
A finalizer is a function member of a reference class that is called automatically by the garbage collector when
destroying an object.
To specify which finalizer function the garbage collector calls for any objects created by gcl_malloc or
gcl_create_*** APIs (such as gcl_create_image), call:
void gcl_set_finalizer(void *object,
void (*gcl_pfn_finalizer)(void *object, void *user_data),
void *user_data);
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Buffers in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
49Example: Allocating, Using, Releasing Buffer Objects
In the following example, the host creates one input buffer and one output buffer, initializes the input buffer,
calls the kernel to square each value in the input buffer, then checks the results.
Listing 6-1 Sample host function creates buffers then calls kernel function
#include
#include
#include
// Include the automatically-generated header which provides the kernel block
// declaration.
#include "kernels.cl.h"
#define COUNT 2048
static void display_device(cl_device_id device)
{
char name_buf[128];
char vendor_buf[128];
clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(char)*128, name_buf, NULL);
clGetDeviceInfo(device, CL_DEVICE_VENDOR, sizeof(char)*128, vendor_buf, NULL);
fprintf(stdout, "Using OpenCL device: %s %s\n", vendor_buf, name_buf);
}
static void buffer_test(const dispatch_queue_t dq)
{
unsigned int i;
// We'll use a semaphore to synchronize the host and OpenCL device.
dispatch_semaphore_t dsema = dispatch_semaphore_create(0);
// Create some input data on the _host_ ...
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Buffers in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
50cl_float* host_input = (float*)malloc(sizeof(cl_float) * COUNT);
// ... and fill it with some initial data.
for (i=0; i
#include
#include
// Include the automatically-generated header which provides the kernel block
// declaration.
#include "kernels.cl.h"
#define COUNT 2048
static void display_device(cl_device_id device)
{
char name_buf[128];
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Images in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
59char vendor_buf[128];
clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(char)*128, name_buf, NULL);
clGetDeviceInfo(device, CL_DEVICE_VENDOR, sizeof(char)*128, vendor_buf, NULL);
fprintf(stdout, "Using OpenCL device: %s %s\n", vendor_buf, name_buf);
}
static void image_test(const dispatch_queue_t dq)
{
// As before, we use a dispatch semaphore to achieve synchronization between
// the host application and the work done for us by the OpenCL device.
dispatch_semaphore_t dsema = dispatch_semaphore_create(0);
// Let's create a "fake" RGBA, 8-bit-per channel image, solid red.
// In a real program, you would use some real raster data.
// Most OpenCL devices support a wide-variety of image formats.
unsigned int i;
size_t height = 2048, width = 2048;
unsigned int *pixels =
(unsigned int*)malloc( sizeof(unsigned int) * width * height );
for (i = 0; i < width*height; i++)
pixels[i] = 0xFF0000FF; // 0xAABBGGRR: 8bits per channel, all red.
// This image data is on the host side.
// We need to create two OpenCL images in order to perform some
// manipulations: one for the input and one for the ouput.
// This describes the format of the image data.
cl_image_format format;
format.image_channel_order = CL_RGBA;
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Images in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
60format.image_channel_data_type = CL_UNSIGNED_INT8;
cl_mem input_image = gcl_create_image(&format, width, height, 1, NULL);
cl_mem output_image = gcl_create_image(&format, width, height, 1, NULL);
dispatch_async(dq, ^{
// Our kernel is written such that each work item processes one pixel.
// Thus, we execute over a two-dimensional range,
// with the width and height of the image determining the dimensions
// of execution.
cl_ndrange range = {
2, // We're using a 2-dimensional execution.
{0}, // Start at the beginning of the range.
{width, height}, // Execute width * height work items.
{0} // And let OpenCL decide how to divide the work
items
// into work-groups.
};
// Copy the host-side, initial pixel data to the image memory object on
// the OpenCL device. We copy the whole image, but you could use the
// origin and region parameters to specify an offset and sub-region of
// the image, if you'd like.
const size_t origin[3] = { 0, 0, 0 };
const size_t region[3] = { width, height, 1 };
gcl_copy_ptr_to_image(input_image, pixels, origin, region);
// Do it!
red_to_green_kernel(&range, input_image, output_image);
// Read back the results; let's reuse the host-side buffer we started with.
gcl_copy_image_to_ptr(pixels, output_image, origin, region);
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Images in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
61// Let the host know we're done.
dispatch_semaphore_signal(dsema);
});
// Do other work, if you'd like...
// ... but eventually, you will want to wait for OpenCL to finish up.
dispatch_semaphore_wait(dsema, DISPATCH_TIME_FOREVER);
// Alright - we expect '0xFF00FF00' for each pixel. Solid green, all the way.
int results_ok = 1;
for (i = 0; i < width*height; i++) {
if (pixels[i] != 0xFF00FF00) {
fprintf(stdout,
"Oh no. Pixel %d was not correct. Expected 0xFF00FF00, saw %x\n",
i, pixels[i]);
results_ok = 0;
break;
}
}
if (results_ok)
fprintf(stdout, "Image results OK!\n");
// Clean up device-size allocations.
// Note that we use the "standard" OpenCL API here.
clReleaseMemObject(input_image);
clReleaseMemObject(output_image);
// Clean up host-side allocations.
free(pixels);
}
int main (int argc, const char * argv[])
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Images in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
62{
// Grab a CPU-based dispatch queue.
dispatch_queue_t dq = gcl_create_dispatch_queue(CL_DEVICE_TYPE_CPU, NULL);
if (!dq)
{
fprintf(stdout, "Unable to create a CPU-based dispatch queue.\n");
exit(1);
}
// Display the OpenCL device associated with this dispatch queue.
display_device(gcl_get_device_id_with_dispatch_queue(dq));
image_test(dq);
fprintf(stdout, "\nDone.\n\n");
dispatch_release(dq);
}
Listing 6-6 Sample kernel swaps the red and green channels
// A simple kernel that swaps the red and green channels.
const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST;
kernel void red_to_green(read_only image2d_t input, write_only image2d_t output)
{
size_t x = get_global_id(0);
size_t y = get_global_id(1);
uint4 tap = read_imageui(input, sampler, (int2)(x,y));
write_imageui(output, (int2)(x,y), tap.yxzw);
}
Creating and Managing Memory Objects in OS X OpenCL
Creating and Using Images in OpenCL
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
63IOSurface and GL: What OpenCL Supports
How the Kernel Interacts With Data
Passing Data To a Kernel
Xcode uses your kernel code to automatically generate the kernel function prototype in the kernel header file.
To pass data to a kernel, when you call the kernel from your host code, passthe memory objects as parameters,
just as you would pass parameters to any other function. OpenCL kernel arguments can be scoped with a local
or global qualifier, designating the memory storage for these arguments. In OS X v10.7, for arguments to
OpenCL kernels that would have been declared with the local or __local address qualifier, the argument
type used in the block declaration of the kernel will be a size_t.
Consider the following kernel that has an argument declared with the local address qualifier:
kernel void foo(global float *a, local float *shared);
The extern declaration of this kernel block that will be generated for you in the host code will be:
extern void (^foo_kernel)(const cl_ndrange *ndrange,
float *a, size_t shared);
Accessing Buffer Objects From a Kernel
Once the data has been enqueued, in order for a device to actually process this data, you have to make this
data available to the work items that execute on the device. The following sections show you how to pass your
data to the compute kernels for further processing.
In your host application source code, it’s your responsibility to:
● Prepare the input data.
● Create a buffer object of the appropriate size.
● Move the input data from host memory. You can do this using the clCreateBuffer function by pointing
to the data on the host, or you can use the clEnqueueWriteBuffer function to enqueue a write from
host memory.
● Associate the input data with the kernel’s arguments. Use the clSetKernelArg function to do this.
Creating and Managing Memory Objects in OS X OpenCL
IOSurface and GL: What OpenCL Supports
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
64Kernels written in OpenCL-C need a data structure to describe the data parallel range over which to execute
the kernel. In OS X v10.7, you’ll use the cl_ndrange structure for this purpose:
typedef struct _cl_ndrange
{
size_t work_dim;
size_t global_work_offset[3];
size_t global_work_size[3];
size_t local_work_size[3];
} cl_ndrange;
Retrieving Results From a Kernel
To read the results back, call dispatch_sync. For example,
dispatch_sync(queue,
^{
gcl_memcpy(ptr_c, device_c,num_floats * sizeof(float));
});
Creating and Managing Memory Objects in OS X OpenCL
How the Kernel Interacts With Data
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
65OpenGL (Open Graphics Library) is an API for writing applications that produce 2D and 3D computer graphics.
See OpenGL.
OpenCL / OpenGL interoperability enables applicationsto share data between OpenCL and OpenGL efficiently.
You do not have to create multiple copies of the same content in OpenCL and OpenGL. An OpenCL memory
object created from an OpenGL object and the original OpenGL object both refer to the same memory and
both GLSL (OpenGL Shading Language) shaders and OpenCL kernels can access the shared data. Another
advantage of using OpenCL / OpenGL interoperability isthat the overhead of passing data for compute/display
purposes is greatly reduced. If the computation and rendering are performed on the GPU, the data need not
be moved between the host and the GPU.
This chapter describes the OpenCL APIs that can be used to create OpenCL memory objects from OpenGL
vertex buffer objects(VBOs), texture objects, and renderbuffer objects. An OpenCL buffer object may be created
from an OpenGL buffer object. An OpenCL image object may be created from an OpenGL texture or renderbuffer
object.
To create an OpenCL memory object from an OpenGL object, an OpenCL context has to be created from an
OpenGL share group (CGLShareGroup) object. An OpenGL share group object manages the OpenGL objects
on the devices in the rendering context. When an OpenCL context is connected to an OpenGL share group
object, both the OpenCL context and the OpenGL context can reference the same data objects.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
66
OpenCL/ OpenGL Interoperation: Data SharingSharegroups
In the example illustrated in Figure 7-1 (page 67), OpenCL is used to generate geometry on the GPU and
OpenGL is used to render the shared geometry, also using the GPU. The OpenCL and OpenGL contextsreference
the same sharegroup (CGLShareGroupObj). Both OpenCL and OpenGL see the same devices and can access
the shared geometry. OpenGL sees the data as a VBO and OpenCL sees it as a buffer memory object.
Figure 7-1 OpenGL and OpenCL share data using sharegroups
CPU GPU
OpenCL CGLShareGroupObj
cl_context
cl_mem VBO
gl_context
To use OpenCL / OpenGL interoperability:
1. Set the sharegroup:
CGLContextObj cgl_context = CGLGetCurrentContext();
CGLShareGroupObj sharegroup = CGLGetShareGroup(cgl_context);
gcl_gl_set_sharegroup(sharegroup);
...
2. After the sharegroup has been set, you can create OpenCL memory objects from the existing OpenGL
objects:
● Use the following API to create an OpenCL buffer object from an OpenGL buffer object:
void * gcl_gl_create_ptr_from_buffer(GLuint bufobj);
● Use the following API to create an OpenCL image object from an OpenGL texture object:
OpenCL/ OpenGL Interoperation: Data Sharing
Sharegroups
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
67cl_image gcl_gl_create_image_from_texture(
GLenum texture_target,
GLint mip_level,
GLuint texture);
● Use the following API to create an OpenCL 2D image object from an OpenGL render buffer object:
cl_image gcl_gl_create_image_from_renderbuffer(GLuint render_buffer);
Synchronizing Access To Shared OpenCL/OpenGL Objects
To ensure data integrity, the application is responsible for synchronizing access to shared OpenCL/OpenGL
objects by their respective APIs. Failure to provide such synchronization may result in race conditions and
other undefined behavior including non-portability between implementations. For information about
synchronizing OpenCL and OpenGL events and fences, see “Controlling OpenCL/OpenGL Interoperation With
GCD” (page 69).
Example
OpenCL/ OpenGL Interoperation: Data Sharing
Synchronizing Access To Shared OpenCL/OpenGL Objects
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
68An application running on a host (a CPU) can route work or data (possibly in disparate chunks) to a device
using the standard OpenCL and OpenGL APIs and OS X v10.7 extensions. While the device does the work it
has been assigned, the host can continue working asynchronously. But at a certain point, the host will need
to wait for the results generated by the device performing the work it was assigned,so it will wait for the device
to notify it that the assigned work has been completed.
OpenCL and OpenGL can also share work and data. Typically, OpenCL will be used to generate or modify buffer
data which will then be rendered by OpenGL. Or, you might use OpenGL to create an image and then
post-process it using OpenCL. In either case, you have to make sure you synchronize correctly.
This chapter describes how to use GCD to synchronize:
● A host with OpenCL
See “Using GCD To Synchronize A Host With OpenCL” (page 69).
● A host with OpenCL using a dispatch semaphore
See “Synchronizing A Host With OpenCL Using A Dispatch Semaphore” (page 70).
● Multiple OpenCL Queues
See “Synchronizing Multiple Queues” (page 75).
You can still use the standard OpenCL and OpenGL APIs to obtain fine-grained synchronization when working
on shared data, where you either:
● Call OpenGL then OpenCL
● Call OpenCL then OpenGL
See the OpenGL and OpenGL specifications for more information.
Using GCD To Synchronize A Host With OpenCL
In Listing 8-1 (page 70), the host enqueues data in two queues to Grand Central Dispatch. The queued data
is processed while the host continues to do its own work. When the host needs the results, it waits for both
queues to complete their work.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
69
Controlling OpenCL/OpenGL Interoperation With
GCDListing 8-1 Synchronizing the host with OpenCL processing
// Create a workgroup so host can wait for results from more than one kernel.
dispatch_group_t group = dispatch_group_create();
// Enqueue some of the data to the add_arrays_kernel on q0.
dispatch_group_async(group, q0,
^{ // Because the call is asynchronous,
// the host will not wait for the results
cl_ndrange ndrange = { 1, {0}, {N/2}, {0} };
add_arrays_kernel(&ndrange, a, b, c);
});
// Enqueue some of the data to the add_arrays_kernel on q1.
dispatch_group_async(group, q1,
^{ // Because the call is asynchronous,
// the host will not wait for the results
cl_ndrange ndrange = { 1, {N/2}, {N/2}, {0} };
add_arrays_kernel(&ndrange, a, b, c);
});
// Perform more work independent of the work being done by the kernels.
...
// At this point, the host needs the results before it can proceed.
// So it waits for the entire workgroup (on both queues) to complete its work.
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
Synchronizing A Host With OpenCL Using A Dispatch Semaphore
The sample Listing 8-2 (page 71) illustrates how you can use OpenCL and OpenGL together in an application.
In this example, we create two vertex buffer objects (VBOs) using OpenGL (not shown). These VBOs represent
the positions of some objects in an N-body simulation. We then create OpenCL memory objects from these
VBOs (line [2]), which allows us to operate directly on the device memory containing this data in our OpenCL
kernel. We update these positions according to our desired algorithm, expressed as a per-object operation in
the included kernel, and then render the resulting VBO using OpenGL (commented, but not shown, at [4]).
Controlling OpenCL/OpenGL Interoperation With GCD
Synchronizing A Host With OpenCL Using A Dispatch Semaphore
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
70Since we are updating positions using OpenCL on a dispatch queue that runs asynchoronously with respect
to the thread that does the OpenGL rendering, we need to take action to ensure that we do not render before
the kernel has finished updating the positions. We utilize a mechanism that is common in applications that
require synchronization in GCD-compatible applications: a dispatch semaphore.
Before entering the main loop, we create a dispatch_semaphore_t (line [1]). In the block that we submit
to the dispatch queue created in OpenCL, just after our kernel call, we signal the semaphore. Meanwhile, the
"main" thread of execution has been rolling along -- perhaps doing more work -- eventually arriving at the call
to dispatch_semaphore_wait(...) (line [3]). The main thread stops at this point and waits until the
post-kernel signal "flips" the semaphore. Once that occurs, the code can continue to the OpenGL rendering
portion of the code, safe in the knowledge that the position update for this round is complete.
Figure 8-1 Rendering loop - each pass on the main thread creates a new frame for display
Synchronization point “I’m done”
OpenCL-created Dispatch Queue
integration_kernel(…)
Just might take
a bit of time
dispatch_semaphore_wait(…)
“Main” Thread of Execution
dispatch_async(…)
Note: that the main thread could do
other work here before stopping to wait.
But eventually, we call:
dispatch_semaphore_wait(…)
Here we sit and wait on CL to be done.
render_with_OpenGL(…)
glFlush(…)
Listing 8-2 Synchronizing a host with OpenCL using a dispatch semaphore
// In this case, the kernel code will update the position of the vertex.
...
// The host code is:
// Create the dispatch semaphone. [1]
Controlling OpenCL/OpenGL Interoperation With GCD
Synchronizing A Host With OpenCL Using A Dispatch Semaphore
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
71dispatch_queue_t queue;
dispatch_semaphore_t cl_gl_semaphore;
void *pos_gpu[2], *vel_gpu[2];
GLuint vbo[2];
float *host_pos_data, *host_vel_data;
int num_bodies;
int curr_read_index, curr_write_index;
// Extern OpenCL kernel declarations
extern void (^integrateNBodySystem_kernel)(const cl_ndrange *ndrange,
float4 *newPos, float4 *newVel,
float4 *oldPos, float4 *oldVel,
float deltaTime, float damping,
float softening, int numBodies,
size_t sharedPos);
void initialize_cl()
{
gcl_gl_set_sharegroup(CGLGetShareGroup(CGLGetCurrentContext());
// Create a CL dispatch queue.
queue = gcl_create_dispatch_queue(CL_DEVICE_TYPE_GPU, NULL);
// Create a dispatch semaphore used for CL / GL sharing.
cl_gl_semaphore = dispatch_semaphore_create(0);
// Create CL objects from GL VBOs that have already been created. [2]
pos_gpu[0] = gcl_gl_create_ptr_from_buffer(vbo[0]);
pos_gpu[1] = gcl_gl_create_ptr_from_buffer(vbo[1]);
vel_gpu[0] = gcl_malloc(sizeof(float4)*num_bodies, NULL, 0);
vel_gpu[1] = gcl_malloc(sizeof(float4)*num_bodies, NULL, 0);
Controlling OpenCL/OpenGL Interoperation With GCD
Synchronizing A Host With OpenCL Using A Dispatch Semaphore
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
72// Allocate and generate position and velocity data
// in host_pos_data and host_vel_data.
//
...
// Initialize CL buffers with host position and velocity data.
dispatch_async(queue,
^{gcl_memcpy(pos_gpu[curr_read_index], host_pos_data,
sizeof(float4)*num_bodies);
gcl_memcpy(vel_gpu[curr_read_index], host_vel_data,
sizeof(float4)*num_bodies);});
}
void execute_cl_gl_main_loop()
{
// Queue CL kernel to dispatch queue.
dispatch_async(queue,
^{
ndrange_t ndrange = { 1, {0}, {num_bodies} } ;
// Get local workgroup size that kernel can use for
// device associated with queue.
gcl_get_kernel_block_workgroup_info(
integrateNBodySystem_kernel,
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(size_t), &nrange.local_work_size[0],
NULL);
// Queue CL kernel to dispatch queue.
integrateNBodySystem_kernel(&ndrange,
pos_gpu[curr_write_index],
vel_gpu[curr_write_index],
pos_gpu[curr_read_index],
vel_gpu[curr_read_index],
Controlling OpenCL/OpenGL Interoperation With GCD
Synchronizing A Host With OpenCL Using A Dispatch Semaphore
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
73damping, softening, num_bodies,
sizeof(float4)*ndrange.local_work_size[0]);
// Signal the dispatch semaphore to indicate that
// GL can now use resources.
dispatch_semaphore_signal(cl_gl_semaphore);});
// Do work not related to resources being used by CL in dispatch block.
// Need to use VBOs that are being used by CL so wait for the CL commands
// in dispatch queue to be issued to the GPU’s command-buffer. [3]
dispatch_semaphore_wait(cl_gl_semaphore, DISPATCH_TIME_FOREVER);
// Bind VBO that has been modified by CL kernel.
glBindBuffer(GL_ARRAY_BUFFER, pos_gpu[curr_write_index]);
// Now render with GL. [4]
// Flush GL commands.
glFlush();
}
void release_cl()
{
gcl_free(pos_gpu[0]);
gcl_free(pos_gpu[1]);
gcl_free(vel_gpu[0]);
gcl_free(vel_gpu[1]);
dispatch_release(cl_gl_semaphore);
dispatch_release(queue);
}
Controlling OpenCL/OpenGL Interoperation With GCD
Synchronizing A Host With OpenCL Using A Dispatch Semaphore
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
74Synchronizing Multiple Queues
In Listing 8-3 (page 75), the host enqueues data in two queues to Grand Central Dispatch. The second queue
waits for the first queue to complete its processing before doing its work. The host application does not wait
for completion of either queue.
Listing 8-3 Synchronizing multiple queues
// Create the workgroup which will consist of just the work items
// that must be completed first.
dispatch_group_t group = dispatch_group_create();
dispatch_group_enter(group);
// Start work on the workgroup.
dispatch_async(q0,
^{
cl_ndrange ndrange = { 1, {0}, {N/2}, {0} };
add_arrays_kernel(&ndrange, a, b, c);
dispatch_group_leave(group);
});
// Simultaneously enqueue data on q1,
// but immediately wait until the workgroup on q0 completes.
dispatch_async(q1,
^{
// Wait for the work of the group to complete.
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
cl_ndrange ndrange = { 1, {N/2}, {N/2}, {0} };
add_arrays_kernel(&ndrange, a, b, c);
});
// Host application does not wait.
Controlling OpenCL/OpenGL Interoperation With GCD
Synchronizing Multiple Queues
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
75An IOSurface is an abstraction for sharing image data. IOSurfaces are an efficient way to manage image
memory because when you use an IOSurface, if no copy is necessary, no time is wasted on making a copy.
An IOSurface transcends APIs, architectures, address spaces, and processes.
You can get an ID for an IOSurface that can be passed around from process to process, so that each of these
completely separate programs can use one single IOSurface. This makessharing an IOSurface between devices
very easy.
If you create an OpenCL image memory object from an existing IOSurface, you can modify the data contained
in the IOSurface either in your "main program" running on the CPU, or in an OpenCL kernel running on either
a GPU or a CPU.
Creating Or Obtaining An IOSurface
You can either create an IOSurface in code (see for an example) or you can request an IOSurface from another
running process such as Photo Booth. The underlying texture transfer mechanism for an IOSurface combines
GL_UNPACK_CLIENT_STORAGE_APPLE and GL_STORAGE_HINT_CACHED_APPLE together. The transfer is
done as a straight DMA to/from system memory and video memory with no format conversions of any kind
(other than some GPU-specific memory layout details). No matter how many different OpenGL contexts (in
the same process or not) bind a texture to an IOSurface, they all share the same system memory and GPU
memory copies of the data.
Creating An Image Object from An IOSurface
Once you’ve created or obtained an IOSurface, before you use it in OpenCL, you need to create an OpenCL
image memory object using the IOSurface. When you create the memory object, you are not making a copy;
the image memory object points at the same memory asthe original IOSurface. This makes using the IOSurface
very efficient.
If you are using GCD to interact with the IOSurface, create the IOSurface-backed CL image as shown in Listing
9-1 (page 77).
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
76
Using IOSurfaces With OpenCLListing 9-1 Creating an IOSurface-backed CL Image
cl_image gcl_create_image(
const cl_image_format *image_format,
size_t image_width,
size_t image_height,
size_t image_depth,
IOSurfaceRef io_surface);
// create a 2D image (depth = 0 or 1) or a 3D image (depth > 1).
// can also be used to create an image from an IOSurfaceRef.
If you are using the standard OpenCL API and not using GCD to create an IOSurface-backed CL object, use
clCreateImageFromIOSurface2D as shown in Listing 9-2 (page 77).
Listing 9-2 Extracting an Image From an IOSurface
cl_image_format image_format;
image_format.image_channel_order = CL_RGBA;
image_format.image_channel_data_type = CL_UNORM_INT8;
cl_mem image = clCreateImageFromIOSurface2D(
context, flags, image_format, width, height, surface, &err
);
Sharing the IOSurface With An OpenCL Device
Sharing an IOSurface in OpenCL is very simple. The key is to lock the IOSurface properly.
If your CPU (host) is going to modify the IOSurface and then share it with an OpenCL device, you should lock
the IOSurface before reading or writing to it, then unlock it before passing it to a kernel:
● The host creates or obtains the IOSurface and creates its CL image object .
●
If the host will be writing to the IOSurface, the host write-locks the IOSurface: IOSurfaceLock(...,
write type lock). If the host will only read from the IOSurface, the host read-locks it.
● The host writes to/reads from the IOSurface as necessary.
● The host unlocks the IOSurface: IOSurfaceUnlock(...). This tells the system that you changed the
data. You can then use the IOSurface-backed image in OpenCL -- the IOSurface object will handle any
necessary read locking internally for you.
Using IOSurfaces With OpenCL
Sharing the IOSurface With An OpenCL Device
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
77● The host enqueues the OpenCL kernel, passing it the IOSurface.
The locking and unlocking are simply the minimal calls needed to give OS X enough information to ensure
that each device always gets the latest, correct data.
If you will be using OpenCL to modify the IOSurface, you don't have to lock it. Just access the image memory
object directly.
Using IOSurfaces With OpenCL
Sharing the IOSurface With An OpenCL Device
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
78The autovectorizer detects operations in a scalar program that can be run in parallel and converts them into
sequential operations that can be handled efficiently by today's CPUs.
The autovectorizer frees you to write simple scalar code. It then vectorizes that code for you so that its
performance on the CPU is maximized while the same code runs on the GPU as well.
Note: Some GPUs also give higher performance when your code is vectorized. The autovectorizer
does not operate on GPU code, but you can vectorize your GPU code manually. If you do manually
vectorize your GPU code, test both vectorized and unvectorized versions to see which gives better
performance on specific hardware.
Features
● Runs by default when compiling to the CPU.
● Packs work items together.
● Generates a loop over the entire workgroup.
● Can provide performance improvement of up to the vector width of the CPU without additional effort.
● Allows you to write one scalar kernel that runs on CPU or GPU.
Without the Autovectorizer
The issue is that a GPU will process scalar data efficiently, but the CPU needs vectorized data to keep it fully
busy. Which means that, without the autovectorizer, you either have to write multiple device-specific kernels
that all perform the same function, or your performance will suffer.
OpenCL sees devices as having a number of compute cores and within them a number of processing elements.
When scalar code runs on the CPU, it will run on each core but will not take advantage of the vector unit.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
79
AutovectorizerFor example, on a SSE4 machine, scalar code would run in one lane of the vector unit when it could be running
in four lanes. The monitor would report that the CPU is completely busy because all the cores are running, but
the CPU is actually only using a quarter of its vector width.
Figure 10-1 Before autovectorization: A simple float sent to the CPU and the GPU
CPU GPU
If you pass simple floats into a kernel:
Listing 10-1 Passing single floats into a kernel
kernel void add_arrays(global float* a, global float* b, global float* c)
{
size_t i = get_global_id(0);
c[i] = a[i] + b[i];
}
The kernel will be doing a scalar addition; operating on one data element at a time. If you send the scalar float
to the CPU and the GPU, the GPU will become fully engaged in processing the data. In the CPU, although all
the cores are busy, only one quarter of the vector width of the processing element in each core is used.
If you instead passin float4* parametersto the kernel, that makesthe addition a vector addition. The addition
is now CPU-only, specialized for that device. That would extract as much work as possible from the CPU but
leave the GPU idle.
In other words, without the autovectorizer, you would have to write multiple device-specific, non-scalar kernels,
one for each type of device.
Autovectorizer
Without the Autovectorizer
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
80Writing Optimal Code For the CPU: Let the autovectorizer do the
work for you
Do
● Write one simple (non-vectorized) kernel that can run on any device.
Don’t
● Write device-specific optimizations.
● Write work item ID-dependent control flow, if possible. (If this occurs in many places in the code, it would
likely prevent autovectorization from succeeding.)
What the autovectorizer does
● Runs by default whenever compiling kernels to a CPU.
● Packs work items together into vector instructions.
● Workgroup size can be increased if autovectorization is successful.
● Achieves performance improvements of up to the vector width of the CPU without additional effort on
your part.
Vectorization Example
Xcode
Setting Type Default Command Line Flag
-cl-auto-vectorize-enable
If this is set to NO, the command line flag should be
-cl-autovectorize- disable
Auto-vectorizer Boolean YES
Autovectorizer
Writing Optimal Code For the CPU: Let the autovectorizer do the work for you
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
81This chapter providessuggestions asto how to structure OpenCL code so that it runs most efficiently, describes
how to measure performance of OpenCL applications, and what to expect - how to set performance objectives.
It also provides an example of an iterative process of performance tuning of a simple image filter application.
Before Optimizing Code
Before you decide to optimize code, it is important to answer the following questions:
1. Does the code really need to be optimized? This is the most important question, and answering it is not
trivial when the OpenCL code is used inside a large application. Answering this question is out of the scope
of this document, but it should be considered seriously before starting any optimization effort.
2. How to measure the performance of the code?
3. What is the expected performance?
Reducing Overhead
Here are some general principles you can follow to improve the efficiency of your OpenCL code:
● Choose an efficient algorithm.
OpenCL can take advantage of all the devices in the system, but only if the algorithms in your program
are written to allow parallel processing.
Consider the following when choosing an algorithm:
● The algorithm should be massively parallel, so that the computation can be carried out by a large
number of independent work items:
For data parallel calculations on a GPU, OpenCL works best where many work items are submitted to
the device..
When sending work to a CPU, which typically has fewer cores than the GPU, it is important to match
the number of work items to the number of threads the CPU can effectively support.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
82
Improving Performance● Most algorithms are memory-bound. Consequently, algorithms with the fewest memory accesses or
algorithms with a high compute:memory ratio are usually best for OpenCL applications. The
compute:memory ratio is the ratio between the number of floating-point operations and the number
of bytes transferred to and from memory.
● OpenCL is most efficient on large datasets. If possible, select an algorithm that works on large chunks
of data or merge several smaller tasks into one.
● For data parallel calculations on a GPU, OpenCL works best where there are a lot of work items
submitted to the device; however, some algorithms are much more efficient than others.
● Building an OpenCL program is computationally expensive and should ideally occur only once in a process.
Be sure to take advantage of tools in OS X v10.7 that allow you to compile once and then run many times.
If you do choose to compile a kernel during runtime, you will need to execute that kernel many times to
amortize the cost of compiling it. You can save the binary after the first time the program is run and reuse
the compiled code on subsequent invocations, but be prepared to recompile the kernel if the build fails
because of an OpenCL revision or a change in the hardware of the host machine.
You can also use bitcode generated by the OpenCL compiler instead of source code; compilation will be
much faster and you won’t have to ship source code with your application.
● Moving data to or from OpenCL devices is expensive.
OpenCL gives you complete control over allocation of memory and host-device memory transfers. Your
program will run much faster if you allocate memory on the OpenCL device, move your data to the device,
do as much computation as possible on the device, then move it off—rather than repeatedly going through
write-compute-read cycles.
● Allocating and freeing OpenCL resources (memory objects, kernels, etc.) takes time. Reuse these objects
whenever possible instead of releasing them and recreating them repeatedly. Note, however, that image
objects can be reused only if they are the same size and pixel format as needed by the new image.
● Local memory is faster than global memory and private memory is even faster.
When using memory on an OpenCL device, the local memory shared by all the work items in a single
workgroup is faster than the global memory shared by all the workgroups on the device. Private memory,
available only to a single work item, is even faster.
● Experiment with your code to find the kernel size that works best.
Using smaller kernels can be efficient because each tiny kernel uses minimal resources and breaking a job
down into many small kernels can allow for the creation of very large and efficient workgroups. On the
other hand, starting each kernel does take between 10-100 µs. When each kernel exits, the the results
must be stored in global memory. Because reading and writing to global memory is expensive,
concatenating many small kernels into one large kernel may save considerable overhead.
What kernel size is ideal for your application? To figure that out, you will have to experiment with your
code to find the kernel size that provides optimal performance.
Improving Performance
Reducing Overhead
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
83● OpenCL events on the GPU are expensive.
You can use eventsto coordinate execution between queues, but there is overhead to doing so. Use events
only where needed; otherwise take advantage of the in-order properties of queues.
● When tuning for performance, it's really easy to introduce subtle errors that make the code run faster but
produce bad output. After each iteration, always compare the output to a reference output computed on
the host. For the same reason, be sure to keep all revisions in case you realize that you need to revert your
code.
● Benchmark simple kernelsto estimate upper bounds and set optimization targets. See “Estimating Optimal
Performance” (page 87).
● Use OpenCL built-in functions whenever possible. Optimal code will be generated for these functions.
● Balance precision and speed. GPUs are designed for graphics, where the requirements for precision are
lower. The fastest variants are exposed in the OpenCL built-ins as fast_, half_, native_ functions. The
program build options allow control of some speed optimizations.
● Take advantage of the memory subsystem of the device:
● When writing for the CPU, take advantage of the memory subsystem: reuse data while it’s still in L1
or L2 cache. To achieve this, use loop blocking and access memory in a cache-friendly pattern.
● On the GPU, the memory access pattern is the most important factor. Use faster memory levels (local
memory, registers) to counter the effects of a sub-optimal pattern and to minimize accesses to the
slower global memory.
● Avoid divergent execution:
● The CPU predicts the result of conditional jump instructions (corresponding to if, for, while, etc.) and
starts processing the selected branch before knowing the effective result of the test. If the prediction
is wrong, the entire pipeline needs to be flushed, and we lose some cycles. If possible, use conditional
assignment instead.
● On the GPU, all threads scheduled together must execute the same code. As a consequence, when
executing a conditional, all threads execute both branches, with their output disabled when they are
in the wrong branch. It is best to avoid conditionals (replace them with a?x:y operators) or use
built-in functions.
● Know what kind of device your code is executing on.
OpenCL enables you to determine whether a device is a GPU or a CPU and how many devices are available.
You can optimize your code for the hardware on which it is running. The same OpenCL code may run
efficiently on both CPU and GPU, but optimal performance will usually require different code for each
device.
Improving Performance
Reducing Overhead
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
84GPUs and CPUs have fundamentally different architectures and so require different optimizations for
OpenCL. For example, whereas a CPU has a relatively small number of processing elements and a large
amount of memory (both a large cache and a much larger amount of RAM available on the circuit board),
a GPU has a relatively large number of processing elements and a comparatively small amount of memory.
● When writing for the CPU:
● Write simple scalar code first. The compiler and the autovectorizer work best on linear code and can
generate near-optimal code with no effort required from you. If the autovectorizer providessub-optimal
results, add vectors to the code by hand.
● Use the -cl-denorms-are-zero option in clBuildProgram, unless you need to use denormals
(denormals are very small numbers with a slightly different floating-point representation). Denormals
handling can be extremely slow (100x slower) and can lead to puzzling benchmark results.
● CPUs are not optimized for graphics processing. Avoid using images. CPUs provide no hardware
acceleration for images, and image access is slower than the equivalent buffer access.
See “Tuning OpenCL Code For the CPU” (page 89) for specific optimization strategies for CPUs.
● When writing for the GPU:
● Keep in mind that each family of GPUs has a unique architecture. To get the best possible performance
from a GPU, you need to understand that GPU’s architecture. For example, for a particular GPU it
might be more efficient to write to memory in blocks of a certain size, or it might be desirable to have
the number of work items in each workgroup a multiple of a particular number. Consult the literature
of the manufacturer of any GPU you wish to support to get details about that GPU’s architecture. This
document considers only general principles that should be true for any GPU.
● Avoid slow host-device transfers:
● Aggregate several transfers into a single, larger one.
● Design algorithms to keep the data on the device as long as possible.
● Try to maximize the compute/memory ratio and the number of independent dependency chains by
grouping the computation of several output elements into one single work item. The GPU has huge
computing power and kernels will usually be memory-bound.
● Try to use image objectsinstead of buffers. For certain memory access patterns, the different hardware
data path used when accessing images may be more efficient. This is especially the case when you
use 16-bit floating-point data (half).
See “Tuning OpenCL Code For the GPU” (page 99) for specific optimization strategies for GPUs.
Improving Performance
Reducing Overhead
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
85Measuring Performance
Execution time of OpenCL commands can be measured on the host or on the device.
It is best to measure performance on the host, because it is closer to the user-perceived execution time.
Measuring Performance On the Host
To measure OpenCL command execution time on the host:
1. Call the gettimeofday function to determine the start time. The gettimeofday function provides wall
clock time with microsecond granularity:
Listing 11-1 Using the gettimeofday function
#include
// Return wall clock time (s).
double getRealTime() {
struct timeval tv;
gettimeofday(&tv,0);
return (double)tv.tv_sec+1.0e-6*(double)tv.tv_usec;
}
2. Call clFinish(queue) to block the host thread until all the OpenCL commandsin the queue are executed.
3. When OpenCL processing completes, call the getTimeOfDay function to determine the elapsed time.
Measuring Performance On Devices
The following APIs allows you to measure time taken for various OpenCL commands and kernels queued in a
block to a dispatch queue.
● Start a timer
Call this function to start the timer:
cl_timer gcl_start_timer(void);
● Stop the timer
Call this function to stop the timer and return the elapsed time in seconds between when the call to
cl_start_timer associated with the timer parameter and when commands & kernelsin the block have
finished execution:
Improving Performance
Measuring Performance
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
86double gcl_stop_timer(cl_timer timer);
Measuring execution time of several consecutive calls to the same kernel(s) usually gives more reliable results.
“Warming-up” the device also improves consistency of benchmarking results. Listing 11-2 (page 87) shows
an example of benchmarking loop that can be included in kernel code:
Listing 11-2 Sample benchmarking loop on the kernel
const int iter = 10; // number of iterations to benchmark
cl_timer blockTimer;
for (int it=-2; it
}
clFinish(queue);
gcl_stop_timer(blockTimer);
// t = execution time for one iteration (s)
Estimating Optimal Performance
Before optimizing code, it is best to know what kind of performance is achievable.
The main factor determining the execution speed of an OpenCL kernel is memory usage. This is the case for
both CPU and GPU devices. Benchmarking the speed of the kernel function in Listing 11-3 (page 87) provides
a way to estimate the memory speed of an OpenCL device.
Listing 11-3 Kernel for estimating performance
kernel void copyBuffer(global const float * in,global float * out) {
int i = get_global_id(0);
out[i] = in[i]; // R+W one float
}
Improving Performance
Estimating Optimal Performance
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
87On our test machine we measured the following memory copy speeds for buffer sizes ranging from 1KiB to
16MiB:
Figure 11-1 Memory copy speed in GB/s (read+write) vs buffer size
100
1 KiB 4 KiB 16 KiB 64 KiB 256 KiB 1 MiB 4 MiB 16 MiB
75
50
25
0
Standard C library memcpy (running on one single thread)
The OpenCL code running on the CPU
The OpenCL code running on the GPU
Several interesting observations can be made from these curves:
● The measured cost of invoking the OpenCL kernels is in the 10-20 µs range, something like 50,000 CPU
clock cycles. For small tasks, it will be larger or comparable to the actual cost of the computation.
● The memcpy curve showsthe 4 different levels of the CPU memory hierarchy: L1 cache (90 GB/s), L2 cache
(50 GB/s), L3 cache (30 GB/s), and external memory (12 GB/s).
● The OpenCL GPU curve shows how GPU memory runs much faster than the CPU external memory. We
reach 36 GB/s for this mobile GPU, and some desktop GPUs can reach 160 GB/s.
Important: OpenCL is more efficient when data size increases. Try to process larger problems in fewer
kernel calls.
The asymptotic (maximum) value memory speed can be used to estimate the speed of a memory-bound
algorithm on large data.
Improving Performance
Estimating Optimal Performance
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
88Take, for example, the following boxAvg kernel. It takes a single channel floating point image as input, and
computes a single channel floating point image where each output pixel (x,y) is the average value of all pixels
in a square box centered at (x,y). A w by h image is stored in a buffer float * A, where pixel (x,y) is stored in
A[x+w*y].
Here is a first version of the code, before optimization:
constant int RANGE = 2;
kernel void boxAvg1(int w, int h, global const float * in, global float * out) {
int x = get_global_id(0); // pixel to process is (x,y)
int y = get_global_id(1);
float sumA = 0.0f; // sum of pixel values
float sum1 = 0.0f; // number of pixels
for (int dy=-RANGE;dy<=RANGE;dy++)
for (int dx=-RANGE;dx<=RANGE;dx++) {
int xx = x + dx;
int yy = y + dy;
// Accumulate if inside image
if (xx>=0 && xx=0 && yy=0 && xx=0 && yy=0 && xx= 0) { sumA -= inRow[x-RANGE-1]; sum1 -= 1.0f; }
if (x+RANGE < w) { sumA += inRow[x+RANGE]; sum1 += 1.0f; } // insert x+RANGE
// Store current value
out[x+w*y] = sumA/sum1;
Improving Performance
Tuning OpenCL Code For the CPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
94}
}
In this variant, we have reduced the memory accesses from 6 to 3 per iteration of the x loop. The execution
speed of this variant is now 1366 Mpix/s (and only 822 Mpix/s without the autovectorizer). This is 91% of our
upper bound.
We can move the conditionals and the division out of the x loop by splitting it into three parts:
Listing 11-7 Modify the horizontal pass by moving division and conditionals out of the inner loop
// Horizontal pass v4. Global work size: H
kernel void boxAvgH4(int w, int h, global const float * in, global float * out) {
int y = get_global_id(0); // row to process is y
global const float * inRow = in + y*w; // beginning of input row
global float * outRow = out + y*w; // beginning of output row
float sumA = 0.0f;
float sum1 = 0.0f;
// Left border
int x = -RANGE;
for (; x<=RANGE; x++) {
// Here, sumA corresponds to segment 0..x+RANGE-1, update to 0..x+RANGE.
sumA += inRow[x+RANGE]; sum1 += 1.0f;
if (x >= 0) outRow[x] = sumA/sum1;
}
// x is RANGE+1 here
// Internal pixels
float k = 1.0f/(float)(2*RANGE+1); // constant weight for internal pixels
for (; x+RANGE= number of CPU cores.
kernel void boxAvgV3(int w,int h,global const float * in,global float * out) {
// Numer of rows to process in each work item (rounded up)
int rowsPerItem = (h+get_global_size(0)-1)/get_global_size(0);
int y0 = rowsPerItem * get_global_id(0); // we update the range Y0..Y1-1
int y1 = min(h, y0 + rowsPerItem);
for (int y=y0; y= number of CPU cores.
// AUX[w*global_size(0)] is temporary storage, 1 row for each work item.
kernel void boxAvg2(int w, int h, global const float * in,
global float * out, global float * aux) {
// Number of rows to process in each work item (rounded up)
int rowsPerItem = (h+get_global_size(0)-1)/get_global_size(0);
int y0 = rowsPerItem * get_global_id(0); // we update the range Y0..Y1-1
int y1 = y0 + rowsPerItem;
aux += get_global_id(0) * w; // point to our work item’s row of temporary storage
float k = 1.0f/(float)(2*RANGE+1); // constant weight for internal pixels
// Process our rows. We need to process extra RANGE rows before and after.
for (int y=y0-RANGE; y=h) continue; // out of range
// Compute horizontal pass in AUX.
// The boxAvg4 code goes here on input row y
// The output is stored in AUX[W].
// Accumulate this row on output rows Y-RANGE..Y+RANGE
for (int dy=-RANGE; dy<=RANGE; dy++) {
int yy = y + dy;
if (yy < max(0, y0) || yy >= min(h, y1)) continue; // out of range
// Get number of rows accumulated in row YY, to get the weight
int nr = 1 + min(h-1, yy+RANGE)-max(0, yy-RANGE);
float u = 1.0f/(float)nr;
// Accumulate AUX in row YY
global float4 * outRow4 = (global float4 *)(out + w*yy);
global float4 * aux4 = (global float4 *)(aux);
for (int x=0; x<(w/4); x++) outRow4[x] += u * aux4[x];
}
}
}
Thisfused version runs at 1166 Mpix/s. Some rows will be processed twice,since we have to compute horizontal
filters on rows y0-RANGE to y1+RANGE-1 to update output rows y0 to y1-1. At any given time during the
execution, we will access one row in aux, one input row, and 2*RANGE+1 output rows. For a 4096x4096 image,
each row is 16 KiB, and all 7 rows fit in L2 cache.
Important: Merging two kernels called one after the other can reduce memory accesses, and works on
smaller data chunks fitting in faster cache levels, instead of of forcing the two kernels to resort to
communicate via via full round trips to external memory.
Tuning OpenCL Code For the GPU
The conditions to efficiently use a modern GPU are similar to the conditions we listed for the CPU, but with a
few notable differences. Efficient GPU optimization requires:
● Scheduling a large number of work items to use all resources and hide execution latency.
● Using the GPU memory hierarchy efficiently.
Improving Performance
Tuning OpenCL Code For the GPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
99The number of workgroups and work items required to efficiently utilize a GPU is much higher than for a CPU.
Inside the GPU we have a few cores (typically 2 to 16). Each core schedules work items in small groups (64
work items in the test machine). All these items are executed at the same time and can issue up to five
independent arithmetic ops. Instruction latency is much higher for the GPU. When all work items managed by
the core are waiting for the result of a previously issued instruction still in the pipeline, the GPU core stalls,
and we lose efficiency.
One way to avoid this is to increase the number of work items; another solution is to have more independent
dependency chains inside each work item.
The GPU memory hierarchy can be seen as four levels with the following orders of magnitude for access
bandwidth:
● Host memory accessed from the GPU through the PCI-Express bus, 10 GB/s
● OpenCL global memory, VRAM attached to the GPU, 100 GB/s
● OpenCL local memory, attached to each core, 1,000 GB/s
● OpenCL private memory, registers, 10,000 GB/s
Memory management is explicit: the host code manages host-device transfers and each variable belongs to
a unique address space (global, local, private, constant).
The most important factor in OpenCL efficiency is the memory access pattern: at a given time, we may have
hundreds of work items issuing a memory access instruction, each one with a different address. The hardware
is optimized to processsome of these patterns very quickly. Other access patterns can lead to hardware conflicts.
Hardware conflicts are resolved by serializing the accesses: they can’t occur in parallel,so the hardware schedules
them one after the other. A bad access pattern can make code run up to 30x slower.
A pattern where work item i accesses element x[i] of an array is fast. On the contrary, any pattern with a large
stride (especially a power of 2), x[s*i], will be extremely slow when s becomes large enough.
With such a large difference of bandwidth between the different layers, keeping reused data in the fastest
levels is another key to efficiency. In particular, it is best to avoid host-device transfers: keep data resident on
the GPU until it needs to be transferred to the host. If the output of OpenCL needs to be displayed, it is best
to use CL/GL interoperability and have the output image mapped to an OpenGL texture.
In Practice
We will tune the same boxAvg code we used in “Tuning OpenCL Code For the CPU” (page 89), but this time
for the GPU. We start from the same initial code for the horizontal pass as we did for the CPU:
Improving Performance
Tuning OpenCL Code For the GPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
100Listing
11-12
Kernel before optimization
// Horizontal pass v1. Global work size: w x h
kernel void boxAvgH1(int w,int h,global const float * in,global float * out) {
int x = get_global_id(0); // pixel to process is (x,y)
int y = get_global_id(1);
float sumA = 0.0f; // sum of pixel values
float sum1 = 0.0f; // number of pixels
for (int dx=-RANGE;dx<=RANGE;dx++) {
int xx = x + dx;
// Accumulate if inside image
if (xx>=0 && xx= 0 && xx < w)?in[xx+w*y]:0.0f;
}
// Block until all work items in the group finished updating AUX
barrier(CLK_LOCAL_MEM_FENCE);
// Compute our value
float sumA = 0.0f; // sum of pixel values
float sum1 = 0.0f; // number of pixels
for (int dx=-RANGE;dx<=RANGE;dx++) {
int xx = x + dx;
Improving Performance
Tuning OpenCL Code For the GPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
102sumA += aux[iid+dx+RANGE]; // will add 0 if out or range
sum1 += (xx >= 0 && xx < w)?1.0f:0.0f;
}
// Store output
out[x+w*y] = sumA/sum1;
}
In this example we are using all the work items in the workgroup to copy a segment of the input row to the
local memory buffer aux. Note that a barrier call is required to ensure all items in the group have actually
finished updating aux before we use the buffer.
This kernel runs slightly faster, at 1043 Mpix/s. It can be modified to process several consecutive rows inside
each work item, or several consecutive columns. The corresponding benchmarks are:
Table 11-1 Benchmarks of boxAvgH5 variants:
pix/item Mpix/s
1x1 1044
1x2 1630
1x4 1577
2x1 1300
4x1 1356
8x1 1123
Performance here is significantly improved, but is still far from the copy kernel reference speed of 4500 Mpix/s.
Let’s direct our attention to the vertical pass. If it proves to be much faster, we may be able to use it twice with
additional transpositions, assuming we can transpose an image efficiently.
The boxAvgV1 kernel presented in the CPU section runs at 884 Mpix/s. Let’s modify this kernel to compute
several rows in each work item:
Listing
11-14
Modify the kernel to compute several rows in each work item
// Vertical pass v4. Global work size: W x any
Improving Performance
Tuning OpenCL Code For the GPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
103kernel void boxAvgV4(int w, int h, global const float * in, global float * out) {
// Number of rows to compute
int rowsPerItem = (h+get_global_size(1)-1) / get_global_size(1);
int x = get_global_id(0); // column to process
int y0 = rowsPerItem * get_global_id(1); // rows to process are y0..y1-1
int y1 = min(h,y0+rowsPerItem);
float sumA = 0.0f; // sum of pixel values
float sum1 = 0.0f; // number of pixels
// Load values y0-RANGE-1..y0+RANGE-1
for (int y=max(0, y0-RANGE-1); y < min(h, y0+RANGE); y++) {
sumA += in[x+w*y]; sum1 += 1.0f;
}
// Process our rows
for (int y=y0; y= 0) { sumA -= in[x + w*yy]; sum1 -= 1.0f; }
yy = y+RANGE; if (yy < h) { sumA += in[x + w*yy]; sum1 += 1.0f; }
// Store value
out[x+w*y] = sumA/sum1;
}
}
This one runs at 2296 Mpix/s, and we read+write 2+1 float per pixel instead of 5+1. If we can provide a dedicated
kernel for each value of RANGE, we can reduce this to 1+1 float per pixel, by keeping a “ring” of previous
2*RANGE+1 values in registers. Doing so, we won’t need to reload the value for yy = y-RANGE-1 to remove it
from the sum. Here is the modified code:
Listing
11-15
Provide a dedicated kernel for each value of RANGE
// Register ring, RANGE=2
kernel void boxAvgV4_ring(int w,int h,global const float * in,global float * out)
Improving Performance
Tuning OpenCL Code For the GPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
104{
// Compute number of rows to compute
int rowsPerItem = (h+get_global_size(1)-1)/get_global_size(1);
int x = get_global_id(0); // column to process
int y0 = rowsPerItem * get_global_id(1); // rows to process are y0..y1-1
int y1 = min(h, y0+rowsPerItem);
float2 r0, r1, r2, r3, r4; // ring has 5 values
// Load values y0-RANGE-1..y0+RANGE-1 in the ring
int yy;
r0 = r1 = r2 = r3 = r4 = (float2)(0.0f);
yy = y0-2; if (yy>=0) r1 = (float2)(in[x + w*yy],1.0f);
yy = y0-1; if (yy>=0) r2 = (float2)(in[x + w*yy],1.0f);
yy = y0; r3 = (float2)(in[x + w*yy],1.0f);
yy = y0+1; if (yy=0) { r1 = in[x + w*yy]; s1 = 1.0f; }
yy = y0-1; if (yy>=0) { r2 = in[x + w*yy]; s2 = 1.0f; }
Improving Performance
Tuning OpenCL Code For the GPU
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
106yy = y0; { r3 = in[x + w*yy]; s3 = 1.0f; }
yy = y0+1; if (yy
This is a very short article.
The parser would report the following series of events to its delegate:
1. Started parsing document
2. Found start tag for element article
3. Found attribute author of element article, value “John Doe”
4. Found start tag for element para
5. Found characters This is a very short article.
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
6
Parser Capabilities and Architecture6. Found end tag for element para
7. Found end tag for element article
8. Ended parsing document
Both the tree-based and event-based parsing approaches have theirstrengths and disadvantages. It can require
considerable amounts of memory to construct an internal tree representing an XML document, especially if
that document is large. This problem is compounded if it becomes necessary to map the tree structure of the
parsed document to a more strongly typed, application-specific tree structure.
Event-driven parsing—because it deals with only one XML construct at a time and not all of them at
once—consumes much less memory than tree-based parsing. It is ideal for situations where performance is a
goal and modification of the parsed XML is not. One such application for event-driven parsing is searching a
repository of XML documents (or even one XML document with multiple “records”) for specific elements and
doing something with the element content. For example, you could use NSXMLParser to search the property-list
preferences files on all machines in a Bonjour network to gather network-configuration information.
Event-driven parsing is less suitable for tasks that require the XML to be subjected to extended user queries
or to be modified and written back to a file. Event-driven parsers such as NSXMLParser also do not offer any
help with validation (that is, it verifying whether XML conforms to the structuring rules as specified in a DTD
or other schema). For these kinds of tasks, you need a DOM-style tree. However, you can construct your own
internal tree structures using an event-driven parser such as NSXMLParser.
In addition to reporting parsing events, an NSXMLParser object verifies that the XML or DTD is well-formed.
For example, it checks whether a start tag for an element has a matching end tag or whether an attribute has
a value assigned. If it encounters any such syntactical error, it stops parsing and informs the delegate.
Although the parser “understands” only XML and DTD as markup languages, it can parse any XML-based
language schema such as RELAX NG and XML Schema.
Parser Capabilities and Architecture
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
7The essential steps for parsing an XML document using NSXMLParser are straightforward. It requires you
complete the following general steps:
1. Locate the XML.
Listing 1 shows code that lets the user select an XML file from a file-system browser (NSOpenPanel).
Listing 1 Opening an XML file
- (void)openXMLFile {
NSArray *fileTypes = [NSArray arrayWithObject:@"xml"];
NSOpenPanel *oPanel = [NSOpenPanel openPanel];
NSString *startingDir = [[NSUserDefaults standardUserDefaults]
objectForKey:@"StartingDirectory"];
if (!startingDir)
startingDir = NSHomeDirectory();
[oPanel setAllowsMultipleSelection:NO];
[oPanel beginSheetForDirectory:startingDir file:nil types:fileTypes
modalForWindow:[self window] modalDelegate:self
didEndSelector:@selector(openPanelDidEnd:returnCode:contextInfo:)
contextInfo:nil];
}
- (void)openPanelDidEnd:(NSOpenPanel *)sheet returnCode:(int)returnCode
contextInfo:(void *)contextInfo {
NSString *pathToFile = nil;
if (returnCode == NSOKButton) {
pathToFile = [[[sheet filenames] objectAtIndex:0] copy];
}
if (pathToFile) {
NSString *startingDir = [pathToFile
stringByDeletingLastPathComponent];
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
8
XML Parsing Basics[[NSUserDefaults standardUserDefaults] setObject:startingDir
forKey:@"StartingDirectory"];
[self parseXMLFile:pathToFile];
}
}
Although an XML file is the common case, the source of the XML might not be a file. You could receive
the XML from another object as a property-list object (such as an NSDictionary) or as a stream of bytes
over a network. In cases like these, you must convert the form of the XML to an NSData object before
initializing the NSXMLParser instance (see following step)
2. Create and initialize an instance of NSXMLParser., ensuring that you set a delegate.
Listing 2 illustrates how you might do this.
Listing 2 Creating and initializing a NSXMLParser instance
- (void)parseXMLFile:(NSString *)pathToFile {
BOOL success;
NSURL *xmlURL = [NSURL fileURLWithPath:pathToFile];
if (addressParser) // addressParser is an NSXMLParser instance variable
[addressParser release];
addressParser = [[NSXMLParser alloc] initWithContentsOfURL:xmlURL];
[addressParser setDelegate:self];
[addressParser setShouldResolveExternalEntities:YES];
success = [addressParser parse]; // return value not used
// if not successful, delegate is informed of error
}
In this method, the client object converts the path to the XML file to an NSURL object and then uses that
object to initialize the NSXMLParser instance with initWithContentsOfURL:. It also sets the delegate
to be itself and letsthe parser know it wantsto resolve external entities(such as external DTD declarations).
Other NSXMLParser methodslet you set various namespace-related options. Finally, the clientsends parse
to the NSXMLParser instance to have it begin parsing the XML.
If the XML was in some form other than a file, you would convert it to an NSData object and then use the
initWithData: initializer:
addressParser = [[NSXMLParser alloc] initWithData:xmlData];
XML Parsing Basics
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
93. Implement the delegation methods that are of interest to you.
When the NSXMLParser object parses the XML, it sends a message to its delegate for each XML construct
it encounters (but only if the delegate implements the associated method). Implementations of these
methods vary by type of construct: DTD declarations, namespace prefixes, elements, and so on. Elements
are the most common type of XML construct processed;see “Handling XML Elements and Attributes” (page
11) for details.
All parsing operations begin with the delegate receiving parserDidStartDocument: and end with the
delegate receiving parserDidEndDocument: (assuming, of course,the delegate implementsthemethods).
The former method offers an opportunity for allocating and setting up resources needed for the parsing
operation; the latter method is a good place to release those resources and properly dispose of any result.
4. Handle any parsing errors.
If the parser encounters an error, it stops parsing and invokes the delegation method
parser:parseErrorOccurred:. Implement this method to interpret the error and inform the user. (All
parser errors are nonrecoverable.) See “Handling Parsing Errors” (page 17) for further information.
Memory management becomes a heightened concern when you are parsing XML. Processing the XML often
requires you to create many objects; you should not allow these objects to accumulate in memory past their
span of usefulness. One technique for dealing with these generated objects is for the delegate to create a local
autorelease pools at the beginning of each implemented delegation method and release the autorelease pool
just before returning. NSXMLParser managesthe memory for each object it creates and sendsto the delegate.
XML Parsing Basics
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
10Generally, when you parse an XML document most of the processing involves elements and things related to
elements, such as attributes and textual content. Elements hold most of the information in an XML document.
When the NSXMLParser object traverses an element in an XML document, it sends at least three separate
message to its delegate, in the following order:
parser:didStartElement:namespaceURI:qualifiedName:attributes:
parser:foundCharacters:
parser:didEndElement:namespaceURI:qualifiedName:
The parser might send the parser:foundCharacters: message multiple times for one element; however,
if the characters consist of nothing but white-space characters (space, new line, tab, and similar characters)
the parser sends parser:foundIgnorableWhitespace: instead.
When you are parsing XML elements, an advanced technique you can adopt is to switch processing
responsibilities among multiple delegates, each of which knows how to handle a certain type of element. For
more information see “Using Multiple Delegates” (page 19).
Design Considerations
In an object-oriented environmentsuch as Cocoa, a common strategy for handling elementsisto map them—at
the higher nesting levels, at least—to objects. Root elements and other top-level elements are frequently
equivalent to collections represented in Cocoa by NSDictionary and NSArray objects. Other elements might
readily map to one or more of an application’s custom model objects.
However, not all elements are best expressed as objects. Some lower level and particularly “leaf” elements are
more logically viewed as properties of their parent element (if that element maps to an object). And, of course,
you would probably make the actual attributes of any element a property (that is, an instance variable) of the
corresponding object.
Notwithstanding these suggestions, there is no ready-made mapping formula, and indeed your application
might not have to perform any element-to-object mapping to achieve its ends. These design decisions require
some thought as well as some familiarity with the structure of the XML.
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
11
Handling XML Elements and AttributesHandling an Element: An Example
The example code referred to in the following discussion processes an XML file containing personal-address
information and converts that information into Address Book objects (ABPerson and ABMultipleValue) that
can be added to a specified user’s address database. A portion of the XML looks like the following:
Listing 1 Some of the sample XML
Doe
John
(201) 345-6789
jdoe@foo.com
100 Main Street
Somewhere
New Jersey
07670
Let’s look at how the first three of these elements might be handled. When the parser first encounters these
elements, it invokes the delegate’s
parser:didStartElement:namespaceURI:qualifiedName:attributes: method. For the first two
elements, the delegate creates an equivalent object. For the third element (lastName), the delegate sets an
appropriate property of the second object. Listing 2 shows the delegate’s implementation for the start tags of
the first three elements.
Handling XML Elements and Attributes
Handling an Element: An Example
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
12Listing 2 Implementing parser:didStartElement:namespaceURI:qualifiedName:attribute:
- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName
namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName
attributes:(NSDictionary *)attributeDict {
if ( [elementName isEqualToString:@"addresses"]) {
// addresses is an NSMutableArray instance variable
if (!addresses)
addresses = [[NSMutableArray alloc] init];
return;
}
if ( [elementName isEqualToString:@"person"] ) {
// currentPerson is an ABPerson instance variable
currentPerson = [[ABPerson alloc] init];
return;
}
if ( [elementName isEqualToString:@"lastName"] ) {
[self setCurrentProperty:kABLastNameProperty];
return;
}
// .... continued for remaining elements ....
}
The delegate identifies the element passed in (elementName), then processes it accordingly:
●
If it’s an addresses element (the root element) it creates a mutable array to hold the ABPerson objects.
This mutable array is held as an instance variable.
●
If it’s a person element, it creates an ABPerson object. This object is held as an instance variable named
currentPerson.
●
If it’s a lastName element, it sets an instance variable holding the current Address Book property; this
value is a enum constant declared in the Address Book framework.
The important action undertaken here is having a way (instance variables in this case) to track the current
element throughout the parser’s traversal of it. One reason for this importance is the semantics of
parser:foundCharacters:, most likely the next delegation method invoked. This method can be invoked
Handling XML Elements and Attributes
Handling an Element: An Example
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
13multiple times for the same element. In this method the delegate should append the characters passed in to
the characters accumulated so far for the element. The NSMutableString method appendString: is useful
for this purpose, as shown in Listing 3.
Listing 3 Implementing parser:foundCharacters:
- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string {
if (!currentStringValue) {
// currentStringValue is an NSMutableString instance variable
currentStringValue = [[NSMutableString alloc] initWithCapacity:50];
}
[currentStringValue appendString:string];
}
Again the code uses an instance variable (currentStringValue) as a way to track and gather the content
for the current element. If the parser encounters some white-space characters in the element content, it sends
the message parser:foundIgnorableWhitespace: to give the delegate the opportunity to retain any
white-space characters (such as tabs or new-lines).
Finally, when the parser encounters the end tag of an element, it invokes the delegation method
parser:didEndElement:namespaceURI:qualifiedName:. Listing 4 presents the approach taken by the
delegate in the example code.
Listing 4 Implementing parser:didEndElement:namespaceURI:qualifiedName:
- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName
namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName {
// ignore root and empty elements
if (( [elementName isEqualToString:@"addresses"]) ||
( [elementName isEqualToString:@"address"] )) return;
if ( [elementName isEqualToString:@"person"] ) {
// addresses and currentPerson are instance variables
[addresses addObject:currentPerson];
[currentPerson release];
return;
}
NSString *prop = [self currentProperty];
Handling XML Elements and Attributes
Handling an Element: An Example
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
14// ... here ABMultiValue objects are dealt with ...
if (( [prop isEqualToString:kABLastNameProperty] ) ||
( [prop isEqualToString:kABFirstNameProperty] )) {
[currentPerson setValue:(id)currentStringValue forProperty:prop];
}
// currentStringValue is an instance variable
[currentStringValue release];
currentStringValue = nil;
}
If the delegate determines that the end tag is for the person element, it adds the ABPerson object to the
addresses array and releases the ABPerson object. If the end tag is for the lastName element (for example),
the delegate uses the ABRecord method setValue:forProperty: to set the appropriate property in the
ABPerson object (ABRecord isthe superclass of ABPerson). Finally, the instance variable holding the accumulated
content for the element (currentStringValue) is released.
Handling an Attribute
The addresses element shown in the example XML in Listing 1 (page 12) includes an attribute:
In this hypothetical case, the attribute allows the application parsing the XML to store the created Address
Book information in a specific user directory on a multi-user system.
The NSXMLParser object presents attributes of an element to the delegate in a dictionary in the final parameter
of parser:didStartElement:namespaceURI:qualifiedName:attributes:. Listing 5 shows how the
delegate in the example handles the owner attribute.
Listing 5 Handling an attribute of an element
- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName
namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName
attributes:(NSDictionary *)attributeDict {
Handling XML Elements and Attributes
Handling an Attribute
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
15if ( [elementName isEqualToString:@"addresses"]) {
// addresses is an NSMutableArray instance variable
if (!addresses)
addresses = [[NSMutableArray alloc] init];
NSString *thisOwner = [attributeDict objectForKey:@"owner"];
if (thisOwner)
[self setOwner:thisOwner forAddresses:addresses];
return;
// ... continued ...
}}
The delegate extracts the user name of the owner from the attributeDict dictionary using the attribute
name (owner) as a key. It then invokes a private method that associates the owner with the imported Address
Book data.
Handling XML Elements and Attributes
Handling an Attribute
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
16When the parser encounters a syntactical error or any other problem in an XML document that prevents it
from being well-formed, it stops parsing and sends a message to its delegate. The delegate, if it implements
the parser:parseErrorOccurred: method, receives this message. In its implementation it should display
a message informing users what the problem is. The parsing error is fatal (that is, unrecoverable) so informing
the user is all that you can realistically accomplish. With this information, the user might be able to fix the XML
so the document can be successfully parsed.
Listing 1 illustrates how you might implement parser:parseErrorOccurred:.
Listing 1 Handling parsing errors
- (void)parser:(NSXMLParser *)parser parseErrorOccurred:(NSError *)parseError {
NSWindow *modWin = [self windowForSheet];
if (!modWin) modWin = [NSApp mainWindow];
NSAlert *parserAlert = [[NSAlert alloc] init];
[parserAlert setMessageText:@"Parsing Error!"];
[parserAlert setInformativeText:[NSString stringWithFormat:@"Error %i,
Description: %@, Line: %i, Column: %i", [parseError code],
[[parser parserError] localizedDescription], [parser lineNumber],
[parser columnNumber]]];
[parserAlert addButtonWithTitle:@"OK"];
[parserAlert beginSheetModalForWindow:modWin modalDelegate:self
didEndSelector:@selector(alertDidEnd:returnCode:contextInfo:)
contextInfo:nil];
[parserAlert release];
}
- (void)alertDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void
*)contextInfo { }
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
17
Handling Parsing ErrorsThe key line in this example is the one that constructs the NSAlert object’s informative text. This text includes
the error code (an NSXMLParserErrorenum constant), a localized description of the error, and a line number
and column (nesting level) number isolating the location of the error in the XML document. In the example,
the delegate obtains this information from two different sources: from the parser object itself (provided in the
first parameter of the method) or from the NSError object provided in the second parameter. From the parser
object it can also get an NSError object, and from that it can get a localized description.
However, the default localized description of NSError is rudimentary. You might want to provide your own
localized description instead of relying on the one obtained from the NSError object. Sometimes parsing errors
may require an application-specific interpretation. To implement a function or method for this purpose, you
can use the NSXMLParserError constant defining the error to determine which custom key to use in the
NSLocalizedString macro. (Of course, you must also create a strings file and do whatever else is necessary
to internationalize your application.)
Handling Parsing Errors
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
18For some XML documents, particularly large and complex documents, having a single delegate for the
NSXMLParser object might not be the best approach. The code for handling all of the different parsing events
can easily become overly intricate and hard to manage. One technique for making things more manageable
is to share the work of handling parsing events among multiple delegates.
Take as an example an application that constructs a DOM-style tree from elements as it encounters them.
Starting from the root element, one element creates a child element and passes off control to it by setting it
to be the delegate. That child element creates its children (and so on), each time resetting the delegate
appropriately. If an element has no children, or if it’s a mixed element, it accumulates the textual content for
itself. Finally, when the parser encounters an element’s end tag, the element sets the delegate to be its parent
element. Listing 1 shows the pertinent code that accomplishes this processing.
Listing 1 Resetting the delegate for the next element
- (void)parser:(NSXMLParser *)parser
didStartElement:(NSString *)elementName
namespaceURI:(NSString *)namespaceURI
qualifiedName:(NSString *)qualifiedName
attributes:(NSDictionary *)attributeDict {
// Element is a custom class for object representing element nodes
// Creation of element sets child as delegate (see below)
[self addChild:[Element elementWithName:elementName
attributes:attributeDict parent:self children:nil parser:parser]];
}
- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string {
[self appendString:string];
}
- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName
namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName {
Element *parent = [self parent];
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
19
Using Multiple Delegates[parser setDelegate:parent]; // RESET DELEGATE TO PARENT
}
+ (id)elementWithName:(NSString *)elementName attributes:(NSDictionary *)attributes
parent:(Element *)parent children:(NSArray *)children parser:(NSXMLParser *)parser
{
return [[[[self class] alloc] initWithName:elementName
attributes:attributes parent:parent children:children
parser:parser] autorelease];
}
- (id)initWithName:(NSString *)elementName attributes:(NSDictionary *)attributes
parent:(id)parent children:(NSArray *)children parser:(NSXMLParser *)parser {
self = [super init];
if (self) {
[self setName:elementName];
if (attributes) {
[self addAttributes:attributes];
}
[self setParent:parent];
if (children) {
[self addChildren:children];
}
[parser setDelegate:self]; // CHILD SET AS DELEGATE
}
return self;
}
Another technique for managing multiple delegates is maintaining a number of delegate objects, each with
its specialized role, in a collection such as an NSDictionary object. These objects would know who their child
and parent elements are in any given context and so would be able to set the delegate for the next element
(using the appropriate dictionary key) after their work with the current element has finished.
Using Multiple Delegates
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
20Generally, if you wish to add or modify the content of an XML document, you must construct a static tree
structure that completely represents the elements and other constructs in the document. Tree representations
are also essential if you intend to validate an XML document against the DTD (or other language schema) that
prescribes the logical structure of the document.
When most developers want to construct DOM-style tree representations of XML documents, they use a
tree-based parser, not a streaming parser such as NSXMLParser. (Tree-based parsing engines, however, are
typically built on top of streaming parsers.) Nonetheless, that does not mean that you cannot create tree
structures using an NSXMLParser instance. Although this article does not go into great detail about techniques
for constructing XML tree structures using NSXMLParser, it outlines a general approach that you could take.
Note: DOM (for Document Object Model) is a model proposed by the World Wide Web Consortium
for describing XML and HTML documents using a standard set of objects. It also defines an interface
for accessing and manipulating those objects, which represent (among other things) the elements
of a document and the attributes associated with each element. The procedure discussed below
does not make specific use of DOM, although there are similarities.
You can represent any XML document as a hierarchical tree whose “nodes” are elements exhibiting relationships
of parent and child with other elements. Each element can have one or more children and, with the exception
of the root element, has exactly one parent element. The tree is anchored by a root element, which is the only
element in the tree without a parent. The “leaf” nodes of the tree are typically those elements containing
nothing but text, although they can also be mixed elements or empty elements.
For example, consider the following short XML document:
Doe
John
(201) 345-6789
jdoe@foo.com
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
21
Constructing XML Tree Structures
100 Main Street
Somewhere
New Jersey
07670
The following tree of element nodes represents this document:
Figure 1 Tree representation of simple XML document
addresses
person
lastName firstName phone email address
street city state zip
There are several possible ways to construct a tree representation of an XML document using NSXMLParser.
This article, however, looks at a recursive, object-oriented approach that dynamically transfers delegation
responsibilities among the objects representing the elements of a document. (This strategic shifting of the
NSXMLParser delegate is discussed further in “Using Multiple Delegates” (page 19).) The programmatic result
is doubly-linked lists of objects and arrays of objects; the abstract result is a tree representation of the document.
The procedure for constructing a tree using this approach entails the following steps:
1. Create a class whose instances represent the elements of an XML document. The class should define the
name of the element and its parent (one-to-one) and children (one-to-many) relationships; it should also
encapsulate the attributes associated with the element. As a shorthand notation for this procedure, we’ll
call this class MyElement.
Constructing XML Tree Structures
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
222. From a top-level object in the application, load an XML document, create an NSXMLParser instance for it,
assign the top-level object as delegate, and begin parsing the document (see “XML Parsing Basics” (page
8)).
3. The parser encounters the document’s root element first and sends
parser:didStartElement:namespaceURI:qualifiedName:attributes: to its delegate. The
delegate creates a MyElement object to represent thisroot element and setsits parent to nil. The method
that creates and initializes the object also sets it to be the new delegate of the NSXMLParser instance.
4. The parser encounters the next element of the document—the first child of the root element—and again
sendsthe delegate parser:didStartElement:namespaceURI:qualifiedName:attributes:. The
delegate is now the MyElement object recently created to represent the root element. It creates another
MyElement object to represent the new element (in the process setting the new object to be the delegate
and setting itself to be the parent) and adds the new object to its list of children.
5. The new delegate receives the next
parser:didStartElement:namespaceURI:qualifiedName:attributes: message, identifying its
first child element, and it creates it and adds it to its list of children.
6. Thisrecursive descent through the first branch of the tree ends when the parser encounters“leaf” elements
containing text, mixed content, or empty elements. If there is mixed content the descent is not truly over
since parser:didStartElement:namespaceURI:qualifiedName:attributes: is sent to the
delegate even after it receives parser:foundCharacters: for the current element. Processing depends
on the kind of element:
●
If it’s an empty element, processing skips ahead to the next step (end-element tag)
●
If there is only text associated with the current element node, the delegate responds to the
parser:foundCharacters: message by accumulating text (in sequential
parser:foundCharacters: invocations).
●
If there is mixed content, the delegate will process the text even after it receives messages notifying
it of the start-element and end-element tags for the embedded elements. One way to handle this is
to wrap the text in special text-element objects and insert these (in the proper order) in the element’s
child list.
7. Finally,the parsersendsthe parser:didEndElement:namespaceURI:qualifiedName: to the delegate,
notifying it that the element is now complete. The delegate sets the new delegate to be its parent and
returns.
8. If the parent has more children elements, the parser sends it the next
parser:didStartElement:namespaceURI:qualifiedName:attributes: message; the parent
MyElement object creates a MyElement instance to represent its next child (in the process setting it to be
the new delegate and setting itself to be the parent of the new MyElement) and adds the newly created
Constructing XML Tree Structures
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
23object to its list of children. However, if the parent has no more children to add to its list (that is, it receives
the parser:didEndElement:namespaceURI:qualifiedName: message instead) it sets the new
delegate to be its parent and returns.
9. The procedure continues in this fashion until the entire XML document is processed and all branches of
the tree are constructed.
The objects that are the nodes of the tree (representing mostly elements) should be able to print themselves
out as XML code. Your application should also implement an algorithm that asksthe objectsto print themselves
in the proper document sequence.
Constructing XML Tree Structures
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
24Validation is a procedure that ensures an XML document conforms to the rules governing its logical structure
as specified in a language schema such as DTD (Document Type Definition). An XML document might be
well-formed—that is, it obeys the syntactical rules of XML—and at the same time be invalid. For example, an
element might include a child element when it issupposed to have only textual content, or a required attribute
of an element might be missing.
To perform validation it helpsto construct a tree of an XML document’sschema that is parallel to a tree structure
representing the document’s actual content (see “Constructing XML Tree Structures” (page 21)). The schema
tree presents a simple abstract view of how the document should be structured. Instead of nodes of objects
representing the actual elements and text of the document, the schema tree contains nodes that express the
rules by which the parts of the document can be combined. Validation tests the actual elements, attributes,
and other parts of the document against the rules of the schema to see if the document conforms. If your
application finds any violation of conformance, it can notify the user and perhaps require the user to fix the
error. You can validate an XML document when it is first read and processed and later when users attempt to
make any changes to it.
Because the programmatic interface of NSXMLParser is designed to report only XML constructs and DTD
declarations, this article focuses on that language schema. However, if you use an XML-based language schema,
such as RELAX NG, then NSXMLParser can process the schema just it would as any XML file, reporting what it
finds to its delegate. You can use the data you thereby acquire for validation.
The sections on constructing rules focus primarily on element and attribute declarations because these are by
far the most common and most important type of declaration. “Handling Other Declarations” (page 29) briefly
discusses what to do with other kinds of declarations, such as those for entities and notations.
Using NSXMLParser to Handle DTD Declarations
The NSXMLParser class reports to its delegate DTD declarations it encounters in a document (assuming the
delegate implements the necessary methods). If the language schema you use is DTD, NSXMLParser helps you
acquire the data you need either for validation or for other purposes, such as enforcing correctness when
dynamically constructing objects (for example, a menu template).
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
25
Validation Tips and TechniquesThe DTD Delegation Methods
The NSXMLParser class defines a half dozen delegation methods that the parser invokes when the parser
encounters a DTD declaration in a internal or external source. These methods are of the form:
parser:foundTypeDeclarationWithName:...
The third parameter and any subsequent parameters depend on the type of declaration. The following list
briefly describes the NSXMLParser delegation methods related to DTD declarations.
- parser:foundElementDeclarationWithName:model:
Example:
- parser:foundAttributeDeclarationWithName:forElement:type:defaultValue:
Example:
- parser:foundInternalEntityDeclarationWithName:value:
Example:
- parser:foundExternalEntityDeclarationWithName:publicID:systemID:
Example:
- parser:foundNotationDeclarationWithName:publicID:systemID:
Example:
- parser:foundUnparsedEntityDeclarationWithName:publicID:systemID: notationName:
Example:
Resolving External DTD Entities
An XML document, in the DOCTYPE declaration that occurs near its beginning, often identifies an external DTD
file whose declarations prescribe its logical structure. For example, the following DOCTYPE declaration says
that the DTD related to the root element “addresses” can be located by the system identifier “addresses.dtd”.
Often the system identifier assumes a standard file-system location for DTDs—for example,
/System/Library/DTDs. At the start of processing, the NSXMLParser delegate is given an opportunity to
resolve this external entity and give the parser a list of DTD declarations to parse.
1. When you prepare the NSXMLParser instance,send it the setShouldResolveExternalEntities: with
an argument of YES.
2. Implement the delegation method parser:resolveExternalEntityName:systemID: to return the
declarations in the external DTD file as an NSData object.
Validation Tips and Techniques
Using NSXMLParser to Handle DTD Declarations
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
26If the DTD declarations are internal to an XML document, then the delegate will receive the DTD-declaration
messages automatically (assuming, of course, that it implements the related methods).
Constructing Rules for Elements
Just as elements are typically the most common kind of construct in an XML document, element declarations
are the most common kind of declaration in a DTD. They express rules for the composition of elements from
child elements, text, and other constituents.
An element declaration has three parts: the !ELEMENT keyword, the element name, and a content model. The
content model is everything after the name up to the terminating angle bracket. Consider the following
examples:
The content model can specify no content (EMPTY), any content (ANY, which israre), textual content (#PCDATA),
and child elements. It may identify child elements by name or by an entity reference (such as %plistObject;
in the third example above). The model can also specify mixed content—that is, the element can contain text
and child elements in any order. Through occurrence modifiers (*, +, ?) and other syntactical conventions, the
content model can also specify the order of child elements, whether an element is required or optional, how
many times an element may occur, and acceptable choices between elements. Occurrence modifiers can be
applied to groups of elements (in parentheses) as well as individual elements.
The job required for validation is to examine the content model of an element declaration and derive rules for
the composition of that element. As one approach, you might design classes for each type of rule as well as
for the scope of a rule (individual element or group of elements). You could then associate instances of that
rule class with an element through the name of the element. During validation the instances are queried with
regard to a current or potential member of an element.
Table 1 lists the most important rules derivable from an element declaration’s content model.
Table 1 Possible rules for element validation
Rule Sample content model Comments
Textual content only (#PCDATA)
Validation Tips and Techniques
Constructing Rules for Elements
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
27Rule Sample content model Comments
Vertical bars in this case have a meaning
different from choice; when #PCDATA is
present, they mean that text and child elements
can be intermixed.
(#PCDATA | bold |
italic)
Mixed content
No content EMPTY For flag-type values.
(name, address, Commas indicate prescribed sequence.
phone)
Required sequence
Without #PCDATA being a member (see Mixed
content), the vertical bars mean that one of the
listed elements must be used.
(read | write |
readwrite)
Choice
No modifier punctuation mark. Can apply to
individual element or group.
(name, address,
phone)
Occurs exactly once
Occurrence modifier is asterisk (“*”). Can apply
to individual element or group.
Occurs zero or more (%plistObject;)*
times
Occurrence modifier is plus sign (“+”). Can
apply to individual element or group.
Occurs one or more (property+)
times
Occurrence modifier is question mark (“?”). Can
apply to individual element or group.
Occurs zero or one (%implementation;?)
time
Constructing Rules for Attributes
Elements frequently have attributes associated with them, and consequently attribute-list declarations are
frequently encountered in DTDs. Attribute-list declarations specify the rules for attributes using a syntax that
is different from element declarations. They specify, in order, the associated element, the name of the attribute,
the type of the attribute, and a default value. For example, the declaration
states that the defaultIndex attribute, which is associated with the modifierMap element, is of type
NMTOKEN (meaning that it must be a valid XML name); the #REQUIRED keyword given as the default value
means that a value for the attribute must be supplied.
Validation Tips and Techniques
Constructing Rules for Attributes
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
28When a NSXMLParser instance encounters an attribute-list declaration, it sends
parser:foundAttributeDeclarationWithName:forElement:type:defaultValue: to its delegate.
Passed in as parameters are attribute name, the associated element, the attribute type, and its default value.
The rules for attributes derive from combinations of the last two parameter (type and default value). Table 2
lists some the possible rules that you can construct from attribute-list declarations.
Table 2 Possible rules for attribute validation
Type or Comments
default
Keywords or
example
Rule
The attribute value must be unique in the
XML document.
Unique value ID type
The value of the attribute must be
specified in the document.
Required value #REQUIRED default
Value must refer to valid ID-type value
elsewhere in document. IDREFS specifies
a list of ID references (in parentheses).
Refers to unique IDREF | IDREFS type
attribute value
Value must be valid XML name (including
entity references). NMTOKENS specifies a
list of XML names (in parentheses).
NMTOKEN | type
NMTOKENS
Valid XML name
Value is fixed #FIXED "value" default Value must be “value”.
Attribute enumeration: value must be one
of the XML names in parentheses.
(name | address type
| phone)
Valid XML name
in list
Attribute enumeration: value must be one
of the defined types in parentheses.
NOTATION (tiff type
| gif | jpg)
Valid defined type
in list
Handling Other Declarations
Other DTD declarationssuch asthose for entities and notations are less common than element and attribute-list
declarations. You can easily derive rule constructions for these other declarations after reviewing some DTD
documentation. However, there are a couple of things to keep in mind:
● You need to record entity declarations in case they are used as part of the content model for an element
declaration.
● Because notations can be made an attribute type, you should also keep track of them.
Validation Tips and Techniques
Handling Other Declarations
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
29This glossary defines some of the terms specific to XML, DTD, and related specifications and technologies. It
focuses primarily on terms that are part of the names of methods and constants declared by the NSXMLParser,
NSXMLNode, NSXMLDocument, NSXMLElement, NSXMLDTD, and NSXMLDTDNode classes.
atomic value
A value with a simple type as defined by the XML Schema standard. The types include string, decimal,
integer, float, double, Boolean, date, URI, array, and binary data. An XQuery query returns a sequence of
items that can contain one or more nodes or atomic values.
attribute
A property of an element expressed as a name-value pair. Attributes are used to encode data or provide
metadata that is associated with an element. In the following example,“version”isthe name of an attribute
of element plist and its value is "1.0":
attribute list declaration
Identifiesin a DTD an element that has attributes, the names of those attributes, what valuesthe attributes
may have, and default values. Example:
In this example, phone is the element name, location is the attribute name, (home | office |
mobile) is the allowable values, and home is the default value.
canonical
A form of an XML document in which it can be compared against another document for equivalence. If
two documents with differing physical representations have the same canonical form, they are considered
logically equivalent within the given application context. The canonical form of an XML document is
defined by the World Wide Web Consortium at http://www.w3.org/TR/xml-c14n.
CDATA block
A section of text that the parsershould pass uninterpreted to the client application. It appears as element
content. CDATA blocks are often used for code or data that contains “prohibited” characters, that is
characters of special syntactical significance to the parser (for example, “<“ and “&”). You can also use an
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
30
XML Glossaryentity reference to express any of these prohibited characters (for example, <) is a built-in entity
reference for specifying the “escaped” < character.
content model
The part of an element declaration that defines what the element may contain. A content model consists
of the names of child elements, #PCDATA (indicating text), entity references, or EMPTY (indicating an
empty elementsuch as ). Child elements and #PCDATA are enclosed within parentheses. Commas
between child elements specify that the elements must occur in the given sequence. The vertical-bar
character (“|”) instead of a comma indicates a logical OR relationship and can be used with #PCDATA.
Occurrence modifiers can be applied to individual elements or groups of elements:
●
“+” indicates the element or group can be repeated more than once but must occur at lease once.
●
“?” indicates the element or group is optional and may occur only once.
●
“*” indicates the element or group is optional and can occur more than once.
● No modifier indicates that the element or group must occur only once.
Examples of content models.
(#PCDATA)
(%plistObject)*
(lastName, middleInitial?, firstName, phone*)*
document order
The order of XML mark-up constructs as they appear in a document. When you send the NSXMLNode
messages nextNode (or previousNode) to each successive node object encountered in an NSXML tree,
you are traversing the tree forward (or backward) in document order.
DOM (Document Object Model)
An API for accessing and manipulating XML documents as tree structures. DOM derives from a World
Wide Web Consortium recommendation for a general object model for storing hierarchically structured
documents in memory.
DTD (Document Type Definition)
A way to define the legal elements and other building blocks of an XML document.
element
Markup tagsthat identify the nature of the content they surround. Elements have names and may contain
textual data, child elements, processing instructions, comments, and CDATA blocks. An element has a
single parent element, except for a document’s root element, which has no parent. An element may also
XML Glossary
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
31have attributes and namespace prefixes associated with it. Elements can also be empty (that is, without
content) and the developer can use them as flags.
The following is an example of an element with an attribute and mixed content (in this case, text, a child
element, and a CDATA block):
The following C++ code gives an example of how
cout is used:
element declaration
Specifiesin a DTD the name of an element and what is permitted as content of the element. The declaration
may specify child elements, text, and entity references as content. It prescribesthe order of child elements
and (forsingle elements or for the entire group) whether it isrequired and whether it can appear multiple
times. Examples:
See also content model.
entity declaration
Associates in a DTD a name with some piece of XML content that is identified by an entity reference.
That content can be a literal value (such as identified by a character reference), a variable value specified
elsewhere in the DTD, orsome textual or binary value referenced in an external file. The last type of entity
is called an external entity. Examples:
entity and character reference
A reference in text to an externally or internally declared entity declaration. It must begin with an
ampersand and end with a semicolon. You can refer to entities that you declare elsewhere. There are five
predefined entities: “<“, “>”, “&”,single-quote character, and double-quote character. Character references
XML Glossary
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
32start with “&#” and are followed by numerical code points. Examples of references are ', >,
ç ; the first two are built-in entity references and the last is a character reference. See also unparsed
entity.
model
See content model.
namespace
A URI (Universal Resource Identifier) that qualifies an element or attribute name so as to avoid name
conflicts when a document contains XML from different sources. You declare a namespace in the start
tag of an element by appending a prefix to the predefined xmlns attribute (separated by a colon), and
then associating this with the value of the URI; for example:
Thereafter, you need only use a namespace prefix (“h” in the above example) with an element (separated
by a colon) to identify the element unambiguously. All child elements of the element with the namespace
declaration are associated with the same namespace through the prefix. The prefix-element name
combination (h:table from the example above) is called a qualified name. A namespace declaration
with no prefix after xmlns defines a default namespace, unlessthe value is an empty string, which means
“no namespace.” The URI in a namespace declaration doesn’t have to point to anything; it is just a
convenient way to get a unique name.
namespace prefix
A prefix defined in a namespace declaration to identify the namespace a particular element is associated
with. The namespace's qualified name (xmlns:localname ) appears only during output. All other operations,
such as those that get or set a namespace node’s value, use the local name only. See also namespace.
normalize
To coalesce all adjacent child text nodes into a single text node while removing empty text nodes.
Normalization is highly recommended before performing XPath and XQuery queries.
notation
Identifies by name the format either of an unparsed entity or an element bearing a specific notation
attribute; it can also identify the target of a processing instruction. A notation declaration gives a name
to the notation and an external identifier that enables a parser or its client to locate a helper application
that can process the data specified by the notation. Notations occur in attribute values, attribute-list
declarations, and entity declarations.
processing instruction
A construct that provides information to the application processing the XML document. The instructions
could instruct the application how, for example, to interpret the XML or display the results. Processing
instructions can occur within elements or at the top level of a document. The first word of the processing
instruction is called the target (its name) and every thing else is its object value. Example:
XML Glossary
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
33
qualified name
An element’s full name, consisting of prefix, colon, and local name. See also namespace.
sequence
A collection of items, each of which can be a node or an atomic value. XQuery queries return a sequence
(an NSArray in Cocoa), which may contain only a single item.
validation
A procedure that checks an XML document against the logical structure described by declarations in the
associated DTD (or other schema) to see if the XML conforms to it. Some of the constraints involved in
validation are proper element sequence and nesting, specification of required attributes, and correct
attribute type. For example, if an element is supposed to have one or more child elements but doesn’t,
the document containing the element is invalid. Before an XML document can be validated, it must first
be well-formed.
unparsed entity
An external resource referred to by entity reference whose contents may be binary data or text (including
non-XML text). Each unparsed entity has a notation associated with it.
well-formed
Refers to an XML document that obeys the syntax of XML. A parser cannot parse a document if its XML
is not well-formed. Some of the checks for whether a document is well-formed are:
● Element start tags must have end tags (except for empty elements).
● Attribute values must be quoted.
● Parameter entities must be declared before they are used.
● Markup constructs appear only where permitted.
XHTML
A more strictly prescribed version of HTML that makes it well-formed XML. XHTML is an official World
Wide Web Consortium recommendation.
XPath
An XML query language for locating nodes with an XML tree structure. It allowslocation paths, predicates,
and general expressions in queries. The Cocoa implementation uses XPath 2.0, which is a World Wide
Web Consortium recommendation. The NSXMLNode class enables XPath queries through its
nodesForXPath:error: method. (Note that the NSXML classes do not support deprecated XPath 1.0
features such as namespace axis.)
XML Glossary
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
34XQuery
A flexible and powerful XML query language that lets you compose logically complex queries using
operators, quantifiers, functions and FLOWR expressions (referring to the keywords for, let, order
by, where, and return). The NSXMLNode class enables XQuery 1.0 queries through its
objectsForXQuery:error: method
XSLT (Extensible Stylesheet Language Transformations)
An XML application for transforming an XML document into another XML document or into an HTML,
RTF, or plain-text document. The stylesheet used in a transformation has template rules, each consisting
of a pattern and a template. The NSXMLDocument class permits access to XSLT through its
objectByApplyingXSLT:error: and objectByApplyingXSLTAtURL:error: methods.
XML Glossary
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
35This table describes the changes to Event-Driven XML Programming Guide .
Date Notes
2010-03-24 Update example code to new initializer pattern.
2008-09-09 Added note about introduction of namespace support in v10.4.
2006-12-05 Added memory management guideline and corrected code examples.
Updated the glossary of XML terms. Changed title from "Event-Driven
XML Parsing." Changed "Rendezvous" to "Bonjour."
2005-04-29
Updated the XML glossary to define additional terms primarily related to
the NSXML set of classes. This glossary is shared with Tree-Based XML
Programming Guide .
2004-07-27 Minor bug fix.
2004-01-21 First version of Event-Driven XML Parsing .
2010-03-24 | © 2004, 2010 Apple Inc. All Rights Reserved.
36
Document Revision HistoryApple Inc.
© 2004, 2010 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Bonjour, Cocoa, Mac, and
OS X are trademarks of Apple Inc., registered in
the U.S. and other countries.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Date and Time
Programming GuideContents
About Dates and Times 5
At a Glance 5
Creating and Using Date Objects to Represent Absolute Points in Time 5
Working with Calendars and Date Components 6
Performing Date and Time Calculations 6
Working with Different Time Zones 6
Special Considerations for Historical Dates 6
How to Use this Document 7
See Also 7
Dates 8
Date Fundamentals 8
Creating Date Objects 9
Basic Date Calculations 10
Calendars, Date Components, and Calendar Units 11
Calendar Basics 11
Date Components and Calendar Units 12
Converting between Dates and Date Components 12
Converting from One Calendar to Another 14
Calendrical Calculations 16
Adding Components to a Date 16
Determining Temporal Differences 18
Checking When a Date Falls 20
Week-Based Calendars 21
Using Time Zones 23
Creating Time Zones 23
Application Default Time Zone 24
Creating Dates with Time Zones 24
Time Zones and Daylight Saving Time 25
Historical Dates 26
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
2The Gregorian Calendar Has No Year 0 26
The Julian to Gregorian Transition 27
Working with Eras with Backward Time Flow 27
Document Revision History 29
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
3Tables and Listings
Dates 8
Listing 1 Creating dates with time intervals 9
Listing 2 Creating dates by adding a time interval 9
Calendars, Date Components, and Calendar Units 11
Listing 3 Creating calendar objects 11
Listing 4 Creating a date components object 12
Listing 5 Getting a date’s components 13
Listing 6 Creating a date from components 13
Listing 7 Creating a yearless date 14
Listing 8 Converting date components from one calendar to another 14
Calendrical Calculations 16
Table 1 December 2009 Calendar 21
Table 2 January 2010 Calendar 21
Listing 9 An hour and a half from now 16
Listing 10 Getting the Sunday in the current week 16
Listing 11 Getting the beginning of the week 17
Listing 12 Getting the difference between two dates 18
Listing 13 Days between two dates, as the number of midnights between 19
Listing 14 Days between two dates in different eras 19
Listing 15 Determining whether a date is this week 20
Using Time Zones 23
Listing 16 Creating a date from components using a specific time zone 24
Historical Dates 26
Listing 17 Using negative years to represent BC dates 26
Listing 18 Tomorrow in the BC era 27
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
4Date and time objects allow you to store references to particular instances in time. You can use date and time
objectsto perform calculations and comparisonsthat account for the corner cases of date and time calculations.
At a Glance
There are three main classes used for working with dates and times.
● NSDate allows you to represent an absolute point in time.
● NSCalendar allows you to represent a particular calendar, such as a Gregorian or Hebrew calendar. It
providesthe interface for most date-based calculations and allows you to convert between NSDate objects
and NSDateComponents objects.
● NSDateComponents allows you to represent the components of a particular date, such as hour, minute,
day, year, and so on.
In addition to these classes, NSTimeZone allows you to represent a geopolitical region’stime zone information.
It eases the task of working across different time zones and performing calculations that may be affected by
daylight savings time transitions.
Creating and Using Date Objects to Represent Absolute Points in Time
Date objects represent dates and times in Cocoa. Date objects allow you to store absolute points in time which
are meaningful across locales, calendars and timezones.
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
5
About Dates and TimesRelevant Chapters: “Dates” (page 8)
Working with Calendars and Date Components
Date components allow you to break a date down into the various parts that comprise it, such as day, month,
year, hour, and so on. Calendars represent a particular form of reckoning time, such as the Gregorian calendar
or the Chinese calendar. Calendar objects allow you to convert between date objects and date component
objects, as well as from one calendar to another.
Relevant Chapters: “Calendars, Date Components, and Calendar Units” (page 11)
Performing Date and Time Calculations
Calendars and date components allow you to perform calculationssuch asthe number of days or hours between
two dates or finding the Sunday in the current week. You can also add components to a date or check when
a date falls.
Relevant Chapters: “Calendrical Calculations” (page 16)
Working with Different Time Zones
Time zone objects allow you to present absolute times as local—that is, wall clock—time. In addition to time
offsets, they also keep track of daylight saving time differences. Proper use of time zone objects can avoid
issues such as miscalculation of elapsed time due to daylight saving time transitions or the user moving to a
different time zone.
Relevant Chapters: “Using Time Zones” (page 23)
Special Considerations for Historical Dates
Dates in the past have a number of edge cases that do not exist for contemporary dates. These include issues
such as datesthat do not exist in a particular calendar—such asthe lack of the year 0 in the Gregorian calendar—
or calendar transitions—such as the Julian to Gregorian transition in the Middle Ages. There are also eras with
seemingly backward time flow—such as BC dates in the Gregorian calendar.
About Dates and Times
At a Glance
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
6Relevant Chapters: “Historical Dates” (page 26)
How to Use this Document
If your application keeps track of dates and times, read from “Dates” (page 8) to “Using Time Zones” (page
23). The NSDate, NSCalendar, NSDateComponents, and NSTimeZone classes described in these chapters
work together to store, compare, and manipulate dates and times.
If your application deals with dates in the past—particularly prior to the early 1900s, also read “Historical
Dates” (page 26) to learn about some of the issues that can arise when dealing with dates in the past.
See Also
If you are new to Cocoa, read:
● Cocoa Fundamentals Guide , which introduces the basic concepts, terminology, architectures, and design
patterns of the Cocoa frameworks and development environment.
If you display dates and times to users or create dates from user input, read:
● Data Formatting Guide , which explains how to create and format user-readable strings from date objects,
and how to create date objects from formatted strings.
About Dates and Times
How to Use this Document
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
7Date objects allow you to represent dates and times in a way that can be used for date calculations and
conversions. As absolute points in time, date objects are meaningful across locales, timezones, and calendars.
Date Fundamentals
Cocoa represents dates and times as NSDate objects. NSDate is one of the fundamental Cocoa value objects.
A date object represents an invariant point in time. Because a date is a point in time, it implies clock time as
well as a day, so there is no way to define a date object to represent a day without a time.
To understand how Cocoa handles dates, you must consider NSCalendar and NSDateComponents objects
as well. In a nontechnical context, a point in time is usually represented by a combination of a clock time and
a day on a particular calendar (such as the Gregorian or Hebrew calendar). Supporting different calendars is
important for localization. In Cocoa, you use a particular calendar to decompose a date object into its date
components such as year, month, day, hour, and minute. Conversely, you can use a calendar to create a date
object from date components. Calendar and date component objects are described in more detail in “Calendars,
Date Components, and Calendar Units” (page 11).
NSDate provides methods for creating dates, comparing dates, and computing intervals. Date objects are
immutable. The standard unit of time for date objects is floating point value typed as NSTimeInterval and
is expressed in seconds. Thistype makes possible a wide and fine-grained range of date and time values, giving
precision within milliseconds for dates 10,000 years apart.
NSDate computes time as seconds relative to an absolute reference time: the first instant of January 1, 2001,
Greenwich Mean Time (GMT). Dates before then are stored as negative numbers; dates after then are stored
as positive numbers. The sole primitive method of NSDate, timeIntervalSinceReferenceDate provides
the basis for all the other methods in the NSDate interface. NSDate converts all date and time representations
to and from NSTimeInterval values that are relative to the absolute reference date.
Cocoa implementstime according to the Network Time Protocol (NTP)standard, which is based on Coordinated
Universal Time.
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
8
DatesCreating Date Objects
If you want a date that represents the current time, you allocate an NSDate object and initialize it with init:
NSDate *now = [[NSDate alloc] init];
or use the NSDate class method date to create the date object. If you want some time other than the current
time, you can use one of NSDate’s initWithTimeInterval... or dateWithTimeInterval... methods;
typically, however, you use a more sophisticated approach employing a calendar and date components as
described in “Calendar Basics” (page 11).
The initWithTimeInterval... methods initialize date objects relative to a particular time, which the
method name describes. You specify (in seconds) how much more recent or how much more in the past you
want your date object to be. To specify a date that occurs earlier than the method’s reference date, use a
negative number of seconds.
Listing 1 defines two date objects. The tomorrow object is exactly 24 hours from the current date and time,
and yesterday is exactly 24 hours earlier than the current date and time.
Listing 1 Creating dates with time intervals
NSTimeInterval secondsPerDay = 24 * 60 * 60;
NSDate *tomorrow = [[NSDate alloc]
initWithTimeIntervalSinceNow:secondsPerDay];
NSDate *yesterday = [[NSDate alloc]
initWithTimeIntervalSinceNow:-secondsPerDay];
[tomorrow release];
[yesterday release];
Listing 2 shows how to get new date objects with date-and-time values adjusted from existing date objects
using dateByAddingTimeInterval:.
Listing 2 Creating dates by adding a time interval
NSTimeInterval secondsPerDay = 24 * 60 * 60;
NSDate *today = [[NSDate alloc] init];
NSDate *tomorrow, *yesterday;
tomorrow = [today dateByAddingTimeInterval: secondsPerDay];
Dates
Creating Date Objects
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
9yesterday = [today dateByAddingTimeInterval: -secondsPerDay];
[today release];
Basic Date Calculations
To compare dates, you can use the isEqualToDate:, compare:, laterDate:, and earlierDate: methods.
These methods perform exact comparisons, which means they detect sub-second differences between dates.
You may want to compare dates with a less fine granularity. For example, you may want to consider two dates
equal if they are within a minute of each other. If this is the case, use timeIntervalSinceDate: to compare
the two dates. The following code fragmentshows how to use timeIntervalSinceDate: to see if two dates
are within one minute (60 seconds) of each other.
if (fabs([date2 timeIntervalSinceDate:date1]) < 60) ...
To obtain the difference between a date object and another point in time, send a timeIntervalSince...
message to the date object. For example, timeIntervalSinceNow gives you the time, in seconds, between
the current time and the receiving date object.
To get the component elements of a date, such as the day of the week, use an NSDateComponents object in
conjunction with an NSCalendar object. This technique is described in “Calendar Basics” (page 11).
Dates
Basic Date Calculations
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
10Calendar objects encapsulate information about systems of reckoning time in which the beginning, length,
and divisions of a year are defined. You use calendar objects to convert between absolute times and date
components such as years, days, or minutes.
Calendar Basics
NSCalendar provides an implementation of various calendars. It provides data for several different calendars,
including Buddhist, Gregorian, Hebrew, Islamic, and Japanese (which calendars are supported depends on the
release of the operating system—check the NSLocale class to determine which are supported on a given
release). NSCalendar is closely associated with the NSDateComponents class, instances of which describe
the component elements of a date required for calendrical computations.
Calendars are specified by constants in NSLocale. You can get the calendar for the user's preferred locale
most easily using the NSCalendar method currentCalendar; you can get the default calendar from any
NSLocale object using the key NSLocaleCalendar. You can also create an arbitrary calendar object by
specifying an identifier for the calendar you want. Listing 3 shows how to create a calendar object for the
Japanese calendar and for the current user.
Listing 3 Creating calendar objects
NSCalendar *currentCalendar = [NSCalendar currentCalendar];
NSCalendar *japaneseCalendar = [[NSCalendar alloc]
initWithCalendarIdentifier:NSJapaneseCalendar];
NSCalendar *usersCalendar =
[[NSLocale currentLocale] objectForKey:NSLocaleCalendar];
Here, usersCalendar and currentCalendar are equal, although they are different objects.
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
11
Calendars, Date Components, and Calendar UnitsDate Components and Calendar Units
You represent the component elements of a date—such as the year, day, and hour—using an
NSDateComponents object. An NSDateComponents object can hold either absolute values or quantities of
units (see “Adding Components to a Date” (page 16) for an example of using NSDateComponents to specify
quantities of units). For date components objects to be meaningful, you need to know the associated calendar
and purpose.
iOS Note: In iOS 4.0 and later, NSDateComponents objects can contain a calendar, a timezone, and
a date object. This allows date components to be passed to or returned from a method and retain
their meaning.
Day, week, weekday, month, and year numbers are generally 1-based, but there may be calendar-specific
exceptions. Ordinal numbers, where they occur, are 1-based. Some calendars may have to map their basic unit
concepts into the year/month/week/day/… nomenclature. The particular values of the unit are defined by
each calendar and are not necessarily consistent with values for that unit in another calendar.
Listing 4 shows how you can create a date components object that you can use to create the date where the
year unit is 2004, the month unit is 5, and the day unit is 6 (in the Gregorian calendar this is May 6th, 2004).
You can also use it to add 2004 year units, 5 month units, and 6 day units to an existing date. The value of
weekday is undefined since it is not otherwise specified.
Listing 4 Creating a date components object
NSDateComponents *components = [[NSDateComponents alloc] init];
[components setDay:6];
[components setMonth:5];
[components setYear:2004];
NSInteger weekday = [components weekday]; // Undefined (== NSUndefinedDateComponent)
Converting between Dates and Date Components
To decompose a date into constituent components, you use the NSCalendar method
components:fromDate:. In addition to the date itself, you need to specify the components to be returned
in the NSDateComponents object. For this, the method takes a bit mask composed of Calendar Units
constants. There is no need to specify any more components than those in which you are interested. Listing
5 shows how to calculate today’s day and weekday.
Calendars, Date Components, and Calendar Units
Date Components and Calendar Units
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
12Listing 5 Getting a date’s components
NSDate *today = [NSDate date];
NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *weekdayComponents =
[gregorian components:(NSDayCalendarUnit | NSWeekdayCalendarUnit)
fromDate:today];
NSInteger day = [weekdayComponents day];
NSInteger weekday = [weekdayComponents weekday];
This gives you the absolute components for a date. For example, if you ask for the year and day components
for November 7, 2010, you get 2010 for the year and 7 for the day. If you instead want to know what number
day of the year it is you can use the ordinalityOfUnit:inUnit:forDate: method of the NSCalendar
class.
It is also possible to create a date from components. You can configure an instance of NSDateComponents
to specify the components of a date and then use the NSCalendar method dateFromComponents: to create
the corresponding date object. You can provide as many components as you need (or choose to). When there
is incomplete information to compute an absolute time, default values such as 0 and 1 are usually chosen by
a calendar, but this is a calendar-specific choice. If you provide inconsistent information, calendar-specific
disambiguation is performed (which may involve ignoring one or more of the parameters).
Listing 6 shows how to create a date object to represent (in the Gregorian calendar) the first Monday in May,
2008.
Listing 6 Creating a date from components
NSDateComponents *components = [[NSDateComponents alloc] init];
[components setWeekday:2]; // Monday
[components setWeekdayOrdinal:1]; // The first Monday in the month
[components setMonth:5]; // May
[components setYear:2008];
NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDate *date = [gregorian dateFromComponents:components];
Calendars, Date Components, and Calendar Units
Converting between Dates and Date Components
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
13To guarantee correct behavior you must make sure that the components used make sense for the calendar.
Specifying “out of bounds” components—such as a day value of -6 or February 30th in the Gregorian
calendar—produce undefined behavior.
You may want to create a date object without components such as years—to store your friend’s birthday, for
instance. While it is not technically possible to create a yearless date, you can use date components to create
a date object without a specified year, as in Listing 7.
Listing 7 Creating a yearless date
NSDateComponents *components = [[NSDateComponents alloc] init];
[components setMonth:11];
[components setDay:7];
NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDate *birthday = [gregorian dateFromComponents:components];
Note that birthday in this instance has the default value for the year, which in this case is 1 AD (though it is
not guaranteed to always default to 1 AD). If you later convert this date back to components, or use an
NSDateFormatter object to display it, make sure to not use the year value (as your friend may not appreciate
being listed asthat old). You can use the NSDateFormatter dateFormatFromTemplate:options:locale:
method to create a yearless date formatter that adjusts to the users locale. For more information on date
formatting see Data Formatting Guide .
Converting from One Calendar to Another
To convert components of a date from one calendar to another—for example, from the Gregorian calendar
to the Hebrew calendar—you first create a date object from the components using the first calendar, then you
decompose the date into components using the second calendar. Listing 8 shows how to convert date
components from one calendar to another.
Listing 8 Converting date components from one calendar to another
NSDateComponents *comps = [[NSDateComponents alloc] init];
[comps setDay:6];
[comps setMonth:5];
[comps setYear:2004];
Calendars, Date Components, and Calendar Units
Converting from One Calendar to Another
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
14NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDate *date = [gregorian dateFromComponents:comps];
[comps release];
[gregorian release];
NSCalendar *hebrew = [[NSCalendar alloc]
initWithCalendarIdentifier:NSHebrewCalendar];
NSUInteger unitFlags = NSDayCalendarUnit | NSMonthCalendarUnit |
NSYearCalendarUnit;
NSDateComponents *components = [hebrew components:unitFlags fromDate:date];
NSInteger day = [components day]; // 15
NSInteger month = [components month]; // 9
NSInteger year = [components year]; // 5764
Calendars, Date Components, and Calendar Units
Converting from One Calendar to Another
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
15NSDate providesthe absolute scale and epoch for dates and times, which can then be rendered into a particular
calendar for calendrical calculations or user display. To perform calendrical calculations, you typically need to
get the component elements of a date, such as the year, the month, and the day. You should use the provided
methods for dealing with calendrical calculations because they take into account corner cases like daylight
savings time starting or ending and leap years.
Adding Components to a Date
You use the dateByAddingComponents:toDate:options: method to add components of a date (such
as hours or months) to an existing date. You can provide as many components as you wish. Listing 9 shows
how to calculate a date an hour and a half in the future.
Listing 9 An hour and a half from now
NSDate *today = [[NSDate alloc] init];
NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *offsetComponents = [[NSDateComponents alloc] init];
[offsetComponents setHour:1];
[offsetComponents setMinute:30];
// Calculate when, according to Tom Lehrer, World War III will end
NSDate *endOfWorldWar3 = [gregorian dateByAddingComponents:offsetComponents
toDate:today options:0];
Components to add can be negative. Listing 10 shows how you can get the Sunday in the current week (using
a Gregorian calendar).
Listing 10 Getting the Sunday in the current week
NSDate *today = [[NSDate alloc] init];
NSCalendar *gregorian = [[NSCalendar alloc]
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
16
Calendrical CalculationsinitWithCalendarIdentifier:NSGregorianCalendar];
// Get the weekday component of the current date
NSDateComponents *weekdayComponents = [gregorian components:NSWeekdayCalendarUnit
fromDate:today];
/*
Create a date components to represent the number of days to subtract from the
current date.
The weekday value for Sunday in the Gregorian calendar is 1, so subtract 1 from
the number of days to subtract from the date in question. (If today is Sunday,
subtract 0 days.)
*/
NSDateComponents *componentsToSubtract = [[NSDateComponents alloc] init];
[componentsToSubtract setDay: 0 - ([weekdayComponents weekday] - 1)];
NSDate *beginningOfWeek = [gregorian dateByAddingComponents:componentsToSubtract
toDate:today options:0];
/*
Optional step:
beginningOfWeek now has the same hour, minute, and second as the original date
(today).
To normalize to midnight, extract the year, month, and day components and create
a new date from those components.
*/
NSDateComponents *components =
[gregorian components:(NSYearCalendarUnit | NSMonthCalendarUnit |
NSDayCalendarUnit) fromDate: beginningOfWeek];
beginningOfWeek = [gregorian dateFromComponents:components];
Sunday is not the beginning of the week in all locales. Listing 11 illustrates how you can calculate the first
moment of the week (as defined by the calendar's locale):
Listing 11 Getting the beginning of the week
NSDate *today = [[NSDate alloc] init];
Calendrical Calculations
Adding Components to a Date
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
17NSDate *beginningOfWeek = nil;
BOOL ok = [gregorian rangeOfUnit:NSWeekCalendarUnit startDate:&beginningOfWeek
interval:NULL forDate: today];
Determining Temporal Differences
There are a few ways to calculate the amount of time between dates. Depending on the context in which the
calculation is made, the user likely expects different behavior. Whichever calculation you use, it should be clear
to the user how the calculation is being performed. Since Cocoa implementstime according to the NTP standard,
these methods ignore leap seconds in the calculation. You use components:fromDate:toDate:options:
to determine the temporal difference between two dates in units other than seconds (which you can calculate
with the NSDate method timeIntervalSinceDate:). Listing 12 shows how to get the number of months
and days between two dates using a Gregorian calendar.
Listing 12 Getting the difference between two dates
NSDate *startDate = ...;
NSDate *endDate = ...;
NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSUInteger unitFlags = NSMonthCalendarUnit | NSDayCalendarUnit;
NSDateComponents *components = [gregorian components:unitFlags
fromDate:startDate
toDate:endDate options:0];
NSInteger months = [components month];
NSInteger days = [components day];
This method handles overflow as you may expect. If the fromDate: and toDate: parameters are a year and
3 days apart and you ask for only the days between, it returns an NSDateComponents object with a value of
368 (or 369 in a leap year) for the day component. However, this method truncatesthe results of the calculation
to the smallest unit supplied. For instance, if the fromDate: parameter corresponds to Jan 14, 2010 at 11:30
PM and the toDate: parameter corresponds to Jan 15, 2010 at 8:00 AM, there are only 8.5 hours between the
two dates. If you ask for the number of days, you get 0, because 8.5 hours is less than 1 day. There may be
Calendrical Calculations
Determining Temporal Differences
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
18situations where this should be 1 day. You have to decide which behavior your users expect in a particular
case. If you do need to have a calculation that returns the number of days, calculated by the number of
midnights between the two dates, you can use a category to NSCalendar similar to the one in Listing 13.
Listing 13 Days between two dates, as the number of midnights between
@implementation NSCalendar (MySpecialCalculations)
-(NSInteger)daysWithinEraFromDate:(NSDate *) startDate toDate:(NSDate *) endDate
{
NSInteger startDay=[self ordinalityOfUnit:NSDayCalendarUnit
inUnit: NSEraCalendarUnit forDate:startDate];
NSInteger endDay=[self ordinalityOfUnit:NSDayCalendarUnit
inUnit: NSEraCalendarUnit forDate:endDate];
return endDay-startDay;
}
@end
This approach works for other calendar units by specifying a different NSCalendarUnit value for the
ordinalityOfUnit: parameter. For example, you can calculate the number of years based on the number
of times Jan 1, 12:00 AM is present between.
Do not use this method for comparing second differences because it overflows NSInteger on 32-bit platforms.
This method is only valid if you stay within the same era (in the Gregorian Calendar this means that both dates
must be AD or both must be BC). If you do need to compare dates across an era boundary you can use something
similar to the category in Listing 14.
Listing 14 Days between two dates in different eras
@implementation NSCalendar (MyOtherMethod)
-(NSInteger) daysFromDate:(NSDate *) startDate toDate:(NSDate *) endDate
{
NSCalendarUnit units=NSEraCalendarUnit | NSYearCalendarUnit |
NSMonthCalendarUnit | NSDayCalendarUnit;
NSDateComponents *comp1=[self components:units fromDate:startDate];
NSDateComponents *comp2=[self components:units fromDate endDate];
[comp1 setHour:12];
[comp2 setHour:12];
NSDate *date1=[self dateFromComponents: comp1];
Calendrical Calculations
Determining Temporal Differences
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
19NSDate *date2=[self dateFromComponents: comp2];
return [[self components:NSDayCalendarUnit fromDate:date1 toDate:date2
options:0] day];
}
@end
This method creates components from the given dates, and then normalizes the time and compares the two
dates. This calculation is more expensive than comparing dates within an era. If you do not need to cross era
boundaries use the technique shown in Listing 13 (page 19) instead.
Checking When a Date Falls
If you need to determine if a date falls within the current week (or any unit for that matter) you can make use
of the NSCalendar method rangeOfUnit:startDate:interval:forDate:. Listing 15 shows a method
that determines if a given date falls within this week. The week in this case is defined as the period between
Sunday at midnight to the following Saturday just before midnight (in the Gregorian calendar).
Listing 15 Determining whether a date is this week
-(BOOL)isDateThisWeek:(NSDate *)date {
NSDate *start;
NSTimeInterval extends;
NSCalendar *cal=[NSCalendar autoupdatingCurrentCalendar];
NSDate *today=[NSDate date];
BOOL success= [cal rangeOfUnit:NSWeekCalendarUnit startDate:&start
interval: &extends forDate:today];
if(!success)return NO;
NSTimeInterval dateInSecs = [date timeIntervalSinceReferenceDate];
NSTimeInterval dayStartInSecs= [start timeIntervalSinceReferenceDate];
if(dateInSecs > dayStartInSecs && dateInSecs < (dayStartInSecs+extends)){
return YES;
}
else {
return NO;
}
Calendrical Calculations
Checking When a Date Falls
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
20}
This code uses NSTimeInterval values for the date to test and the start of the week and uses those to
determine whether the date is this week.
Week-Based Calendars
A week-based calendar is defined by the weeks of a year. However, this can be complicated when the first
week of the calendar overlapsthe last week of the previous year’s calendar. In this case there are two important
properties of the calendar:
1. What is the first day of the week?
2. How many days does a week near the beginning of the year have to have within the ordinary calendar
year for it to be considered the first week in the week-based calendar year?
A week-based calendar's first day of the year is on the first day of the week. The first week is preferred to be
the week containing Jan 1 if that week satisfies the defined answer for the second point above.
For example, suppose the first day of the week is defined as Monday, in a week-based calendar interpretation
of the Gregorian calendar. Consider the 2009/2010 transition shown in Table 1 and Table 2:
Table 1 December 2009 Calendar
Sunday Monday Tuesday Wednesday Thursday Friday Saturday
20 21 22 23 24 25 26
27 28 29 30 31
Table 2 January 2010 Calendar
Sunday Monday Tuesday Wednesday Thursday Friday Saturday
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
Since the first day of the week is Monday, the 2010 week-based calendar year can begin either December 28
or January 4. That is, December 30, 2009 (ordinary) could be December 30, 2010 (week-based).
Calendrical Calculations
Week-Based Calendars
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
21To choose between these two possibilities, there is the second criterion. Week Dec 28 - Jan 3 has 3 days in
2010. Week Jan 4-Jan 10 has 7 days in 2010.
If the minimum number of days in a first week is defined as 1 or 2 or 3, the week of Dec 28 satisfies the first
week criteria and would be week 1 of the week-based calendar year 2010. Otherwise, the week of Jan 4 is the
first week.
As another example,suppose you wanted to define your week-based calendarscheme such that the first week
of the week-based calendar year is the week beginning with the first occurrence of the first day of the week
in the ordinary calendar year. Another way to put that is that you always want the first week of the week-based
calendar year to be within the new ordinary calendar year, you never want your week-based calendar to start
back in December of the previous ordinary year as discussed in the previous example. Or, you always want
your week based calendar to start on Jan 1 or later.
In Table 2 (page 21) Monday January 4 is the first Monday of the ordinary year, so the week-based calendar
begins on that day. What you are requesting then is that the first week of your week-based calendar is entirely
within the new ordinary year or that the minimum number of days in first week is 7.
The NSYearForWeekOfYearCalendarUnit is the year number of a week-based calendar interpretation of
the calendar you're working with, where the two properties of the week-based calendar discussed in above
correspond to these two NSCalendar properties: firstWeekday and minimumDaysInFirstWeek.
Calendrical Calculations
Week-Based Calendars
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
22Time zones can create numerous problems for applications. Consider the following situation. You are in New
York and it is 12:30 AM. You have an application that displays all of the Major League Baseball games that
happen tomorrow. Because tomorrow is different depending on the time zone, situations like this must be
carefully accounted for. Fortunately, a little planning and the assistance of the NSTimeZone class ease this
task considerably.
NSTimeZone is an abstract class that defines the behavior of time zone objects. Time zone objects represent
geopolitical regions. Consequently, these objects have region names. Time zone objects also represent a
temporal offset, either plus or minus, from Greenwich Mean Time (GMT) and an abbreviation (such as PST).
Creating Time Zones
Time zones affect the values of date components that are calculated by calendar objects for a given NSDate
object. You can create an NSTimeZone object and use it to set the time zone of an NSCalendar object. By
default, NSCalendar uses the default time zone for the application—or process—when the calendar object
is created. Unless the default time zone has been otherwise set, it is the time zone set in System Preferences.
In most cases, the user’s default time zone should be used when creating date objects. There are cases when
it may be necessary to use arbitrary time zones. For example, the user may want to specify that an appointment
is in Greenwich Mean Time, because it is during her business trip to London next week. NSTimeZone provides
several class methods to make time zone objects: timeZoneWithName:, timeZoneWithAbbreviation:,
and timeZoneForSecondsFromGMT:. In most cases timeZoneWithName: provides the most accurate time
zone, as it adjusts for daylight saving time, the trade-off is that you must know more precisely the location you
are creating a time zone for.
For a complete list of time zone names known to the system, you can use the knownTimeZoneNames class
method:
NSArray *timeZoneNames = [NSTimeZone knownTimeZoneNames];
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
23
Using Time ZonesApplication Default Time Zone
You can set the default time zone within your application using setDefaultTimeZone:. You can access this
default time zone at any time with the defaultTimeZone class method. With the localTimeZone class
method you can get a time zone object that automatically updates itself to reflect changes to the default time
zone.
Creating Dates with Time Zones
Time zones play an important part in determining when datestake place. Consider a simple calendar application
that keeps track of appointments. For example, say you live in Chicago and you have a dentist appointment
coming up at 10:00 AM on Tuesday. You will be in New York for Sunday and Monday, however. When you
created that appointment it was done with the mindset of an absolute time. That time is 10:00 AM Central
Time; when you go to New York, the time should be presented as 11:00 AM because you are in a different time
zone, but it isthe same absolute time. On the other hand, if you create an appointment to wake up and exercise
every morning at 7:00 AM, you do not want your alarm to go off at 1:00 PM simply because you are on a
business trip to Dublin—or at 5:00 AM because you are in Los Angeles.
NSDate objects store dates in absolute time. For example, the date object created in Listing 16 represents
4:00 PM CDT, 5:00 EDT, and so on.
Listing 16 Creating a date from components using a specific time zone
NSCalendar *gregorian=[[NSCalendar alloc] initWithCalendarIdentifier:
NSGregorianCalendar];
[gregorian setTimeZone:[NSTimeZone timeZoneWithAbbreviation:@"CDT"]];
NSDateComponents *timeZoneComps=[[NSDateComponents alloc] init];
[timeZoneComps setHour:16];
//specify whatever day, month, and year is appropriate
NSDate *date=[gregorian dateFromComponents:timeZoneComps];
If you need to create a date that isindependent of timezone, you can store the date as an NSDateComponents
object—as long as you store some reference to the corresponding calendar.
In iOS, NSDateComponents objects can contain a calendar, a timezone, and a date object. You can therefore
store the calendar along with the components. If you use the date method of the NSDateComponents class
to access the date, make sure that the associated timezone is up-to-date.
Using Time Zones
Application Default Time Zone
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
24Time Zones and Daylight Saving Time
The NSTimeZone class also provides a number of instance methods to determine information about daylight
saving time:
● isDaylightSavingTime determines whether daylight saving time is currently in effect.
● daylightSavingTimeOffset determines the current daylight saving time offset. For most time zones
this is either zero or one.
● nextDaylightSavingTimeTransition determines when the next daylight saving time transition
occurs.
There are also similarly named methods for determining this information for specific dates. If you are keeping
track of events and appointments in your application, you can use this information to remind the user of
upcoming daylight saving time transitions.
Using Time Zones
Time Zones and Daylight Saving Time
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
25There are a number of issues that can arise when dealing with dates in the past that do not exist for
contemporary dates. These include dates that do not exist, previous eras where time flow moves from higher
year numbers to lower ones (such as BC dates in the Gregorian calendar), and calendar transitions (such as the
transition from the Julian calendar to the Gregorian calendar).
The Gregorian Calendar Has No Year 0
In the Julian and Gregorian calendars represented by the NSGregorianCalendar, there is no year 0. This
means that the day following December 31, 1 BC is January 1, 1 AD. All of the provided methods for calendrical
calculations take this into account, but you may need to account for it when you are creating dates from
components. If you do attempt to create a date with year 0, it is instead 1 BC. In addition, if you create a date
from components using a negative year value, it is created using astronomical year numbering in which 0
corresponds to 1 BC, -1 corresponds to 2 BC, and so on. For example, the two dates created in Listing
17equivalently represent May 7, 8 BC.
Listing 17 Using negative years to represent BC dates
NSCalendar *gregorian=[[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *bcDateComp=[[NSDateComponents alloc] init];
[bcDate setMonth: 5];
[bcDate setDay: 7];
[bcDate setYear: 8];
[bcDate setEra: 0];
NSDateComponents *astronDateComp=[[NSDateComponents alloc] init];
[bcDate setMonth: 5];
[bcDate setDay: 7];
[bcDate setYear: -7];
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
26
Historical DatesNSDate *bcDate=[gregorian dateFromComponents:bcDateComp];
NSDate *astronDate=[gregorian dateFromComponents:astronDateComp];
The Julian to Gregorian Transition
NSCalendar modelsthe transition from the Julian to Gregorian calendar in October 1582. During thistransition,
10 days were skipped. This means that October 15, 1582 follows October 4, 1582. All of the provided methods
for calendrical calculations take this into account, but you may need to account for it when you are creating
dates from components. Dates created in the gap are pushed forward by 10 days. For example October 8, 1582
is stored as October 18, 1582.
Some countries adopted the Gregorian calendar at variouslater times. Nevertheless, for consistency the change
is modeled at the same time regardless of locale. If you need absolute historical accuracy for a particular locale,
you can subtract the appropriate number of days from the date given by the Gregorian calendar. The number
of days to subtract corresponds to the number of extra leap days in the Julian calendar. Thus for every 100th
year, the Julian calendar falls behind a day if that year is not a multiple of 400. If you need to create a Julian
date, you must subtract the correct number of days from a Gregorian date (10 in the 1500s and 1600s, 11 in
the 1700s, 12 in the 1800s, 13 in the 1900s and 2000s, and so on). You must also take into account the existence
of leap days that aren’t in the Gregorian calendar.
Working with Eras with Backward Time Flow
In the Gregorian calendar, time is divided into two eras, the BC era and the AD era. In the BC era, time flows
in a direction seemingly backwards, that is from higher year numbers to lower. However, days and months
flow in the normal direction. For example February 1 follows January 31. This can be confusing if you ask what
day follows December 31, 7 BC. The correct answer is January 1, 6 BC. This example is illustrated in Listing 18.
Listing 18 Tomorrow in the BC era
NSCalendar *gregorian=[[NSCalendar alloc]
initWithCalendarIdentifier: NSGregorianCalendar];
NSDateComponents *dateBCComps=[[NSDateComponents alloc] init];
[dateBCComps setEra:0]; //Era 0 corresponds to BC
[dateBCComps setMonth:12];
[dateBCComps setDay:31];
[dateBCComps setYear:7];
Historical Dates
The Julian to Gregorian Transition
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
27NSDate *dateBC=[gregorian dateFromComponents:dateBCComps];
NSDateComponents *offsetDate=[[NSDateComponents alloc] init];
[offsetDate setDay:1];
NSDate *dateBC2=[gregorian dateByAddingComponents: offsetDate toDate:dateBC
options:0];
After this code executes dateBC2 corresponds to January 1, 6 BC.
Historical Dates
Working with Eras with Backward Time Flow
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
28This table describes the changes to Date and Time Programming Guide .
Date Notes
Expanded Calendrical Calculationssection. Added Historical Dates Section
and Week-Based Year Section.
2011-06-06
2010-02-24 Corrected code snippet.
2009-07-21 Added links to Cocoa Core Competencies.
Moved information about NSCalendarDate to an appendix, rewrote articles
to replace references to NSCalendarDate, and expanded content.
2008-07-03
Added a section about how to get date components using NSCalendar
and NSDateComponents and a section about how to convert from one
calendar to another.
Removed information about converting a date to a string. See
NSDateFormatter Class Reference for that information.
2007-09-04 Enhanced discussion of calendrical calculations using NSDateComponents.
2007-03-06 Added note regarding Julian and Gregorian calendars.
Corrected typographical errors. Added a note about the use of width
specifiers for calendar date format strings.
2006-05-23
Updated to include NSCalendar and NSDateFormatter changesintroduced
in OS X v10.4.
2006-02-07
2005-08-11 Changed title from "Dates and Times." Corrected minor typographic error.
Revision history was added to existing document. It will be used to record
changes to the content of the document.
2002-11-12
2011-06-06 | © 2002, 2011 Apple Inc. All Rights Reserved.
29
Document Revision HistoryApple Inc.
© 2002, 2011 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Chicago, Cocoa, Mac, New
York, Numbers, andOS X are trademarks of Apple
Inc., registered in the U.S. and other countries.
Times is a registered trademark of Heidelberger
Druckmaschinen AG, available from Linotype
Library GmbH.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Window Programming
GuideContents
Introduction 6
Organization of This Document 6
See Also 8
How Windows Work 9
How a Window is Displayed 11
How Modal Windows Work 12
How Panels Work 14
How Window Controllers Work 15
Window Closing Behavior 16
Opening and Closing Windows 17
Window Layering and Types of Windows 18
Window Layering 18
Key and Main Windows 19
The Key Window 20
The Main Window 20
Changing a Window’s Status 21
Window Layers and Levels 22
Window Levels 22
Setting Ordering and Level Programmatically 22
Setting Window Collection Behavior 24
Spaces Collection Behavior 24
Exposé Collection Behavior 24
Window Cycling Behavior 25
Sizing and Placing Windows 26
Setting a Window’s Size and Location 26
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
2Window Cascading 27
Window Zooming 27
Constraining a Window’s Size and Location 27
Saving a Window’s Position into the User’s Defaults 29
Minimizing Windows 30
Using the Window Menu 31
Setting a Window’s Appearance 32
Setting a Window’s Style 32
Setting a Window’s Color and Transparency 33
Setting a Window’s Color Space 33
Setting a Window’s Content Border Thickness 33
Setting a Window’s Title and Represented File 34
Setting Attributes for the Window’s Image 35
Specifying How To Store the Window’s Image 35
Specifying Where To Store the Window’s Image 36
Specifying When the Window’s Image Is Created 36
Specifying Whether the Window’s Image Persists When Offscreen 37
Specifying the Depth Limit for the Window’s Image 37
Specifying Whether the Depth Limit Changes to the Screen’s Capacity 37
Specifying Whether Window Content Can Be Read or Written by Another Process 37
Handling Events in Windows 38
Using Keyboard Interface Control in Windows 39
Using the Window’s Field Editor 40
Using Window Notifications and Delegate Methods 41
Dragging Images to and from Windows 42
Updating the Cursor Image in a Window 43
Caching Window Images 44
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
3Document Revision History 45
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
4Figures and Listings
Window Layering and Types of Windows 18
Figure 1 Main, key, and inactive windows 19
Saving a Window’s Position into the User’s Defaults 29
Listing 1 Saving a window’s frame automatically 29
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
5An application displays windows on the screen that must be managed and coordinated. A window object
corresponds to at most one on-screen window. The two principal functions of windows are to provide an area
in which views can be placed and to accept and distribute events the user sends through actions with the
mouse and keyboard. The term window sometimes refers to the Application Kit object and sometimes to the
window server’s window device; which meaning is intended is made clear in context. Panels are a special kind
of window, typically serving an auxiliary function in an application, such as utility windows.
This document is intended for Cocoa developers who need to work with windows and panels in their
applications.
Organization of This Document
This programming topic describes how to use windows and panels. These articles give you basic information
on the different types of windows and how they work:
●
“How Windows Work” (page 9) describes the classes that define objects that manage and coordinate
the windows an application displays.
●
“How a Window is Displayed” (page 11) describes how window drawing is accomplished.
●
“How Modal Windows Work” (page 12) describes the behavior of modal windows.
●
“How Panels Work” (page 14) describes the various uses of panels.
●
“How Window Controllers Work” (page 15) describesthe relationship between a window and its controller.
●
“Window Layering and Types of Windows” (page 18) describes window layering and the concepts of key
and main windows, and how a window can avoid becoming key or main.
●
“Window Layers and Levels” (page 22) describes window levels, and how to place a window in a specific
level, such as the level for document windows, palettes, or tear-off menus.
●
“Setting Window Collection Behavior” (page 24) describes how to set a window’s behavior with Spaces,
Exposé, and window cycles.
These articles describe how to use windows:
●
“Opening and Closing Windows” (page 17) describes how to open and close, or just show and hide, a
window.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
6
Introduction●
“Sizing and Placing Windows” (page 26) describes how to control a window’s size and position, including
how to set its minimum and maximum size, how to constrain it to the screen, how to cascade it so its title
bar remains visible, how to zoom it as though the user pressed the zoom button, and how to center it on
the screen.
●
“Saving a Window’s Position into the User’s Defaults” (page 29) describes how to store a window’s position
in the user defaults system, so that it appears in the same location the next time the user starts the
application.
●
“Minimizing Windows” (page 30) describes how to replace a window with a smaller counterpart in the
Dock.
●
“Using the Window Menu” (page 31) describes how to place a window’s name in the Windows menu that
appears in most Cocoa applications.
These articles describe how to change what a window looks like:
●
“Setting a Window’s Appearance” (page 32) describes how to choose whether to display a window’s
peripheral elements, including its title bar, close box, zoom box, or size box. It also describes how to set
a window’s background color and transparency,
●
“Setting a Window’s Title and Represented File” (page 34) describes how to set a window’s title with either
a string or the filename of the window’s represented file.
●
“Setting Attributes for the Window’s Image” (page 35) describes how to set attributes for the window’s
device, which stores the window’s image, including how the image is stored, when the image is created,
and the image’s color depth.
These articles describe how to handle a window’s events:
●
“Handling Events in Windows” (page 38) gives basic information on how a window handles events.
●
“Using Keyboard Interface Control in Windows” (page 39) describes how to navigate between a window’s
fields using the Tab key and how to use the Return and Escape keys to select default buttons.
●
“Using the Window’s Field Editor” (page 40) describes how to use the window’s text object, which is
shared for light editing tasks.
These articles describe some advanced features of windows:
●
“Using Window Notifications and Delegate Methods” (page 41) describes the notifications and delegate
methods used when a window gains or loses key or main window status, minimizes, moves or resizes,
becomes exposed, or closes.
●
“Dragging Images to and from Windows” (page 42) describes what happens when the user wants to drag
an object into or out of a window.
Introduction
Organization of This Document
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
7●
“Updating the Cursor Image in a Window” (page 43) directs you to information on how to change the
cursor image when the cursor is over a specified area in a view.
●
“Caching Window Images” (page 44) describes how to temporarily cache a portion of a window’s image
so that it can be restored later. Thisis useful when highly dynamic drawing must be done over an otherwise
static image of the window.
See Also
For additional information on specific types of windows and panels, you can also see the following programming
topics:
● Sheet Programming Topics describes a dialog attached to a specific window, ensuring that a user never
loses track of which window the dialog belongs to.
● Drawer Programming Topics describes a type of view that slides out from one side of a window.
● Toolbar Programming Topics for Cocoa describes a standard way to display a toolbar for a titled window
below its title bar and provide users with a way to customize toolbars and save those customizations.
● Dialogs and Special Panels describes alert panels and other specialized types of panels, such as Font, Save,
and Print panels.
● Document-Based App Programming Guide for Mac describes how to use the architecture supplied by
AppKit to create applications that can create, open, load, and save multiple document files.
● Cocoa Event Handling Guide discusses the variety of ways your application objects can handle the events
they receive.
Introduction
See Also
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
8The NSWindow class defines objects that manage and coordinate the windows an application displays on the
screen. A single NSWindow object corresponds to at most one onscreen window. The two principal functions
of an NSWindow object are to provide an area in which NSView objects can be placed and to accept and
distribute, to the appropriate views, events the user instigates through actions with the mouse and keyboard.
Note that the term window sometimes refers to the Application Kit object and sometimes to the window
server’s display device; which meaning is intended is made clear in context. AppKit also defines an abstract
subclass of NSWindow—NSPanel—that adds behavior more appropriate for auxiliary windows.
An NSWindow object is defined by a frame rectangle that encloses the entire window, including its title bar,
border, and other peripheral elements (such as the resize control), and by a content rectangle that encloses
just its content area. Both rectangles are specified in the screen coordinate system and are restricted to integer
values. The frame rectangle establishesthe window’s base coordinate system. This coordinate system is always
aligned with and measured in the same increments as the screen coordinate system (in other words, the base
coordinate system can’t be rotated or scaled). The origin of the base coordinate system is the bottom-left
corner of the window’s frame rectangle.
Typically, you create windows using Interface Builder, which allows you to position them, set many of their
attributes, and lay out their views. The programmatic work you do with windows more often involves bringing
them on and off the screen; changing dynamic attributes such as the window’s title; running modal windows
to restrict user input; and assigning a delegate that can monitor certain of the window’s actions,such as closing,
zooming, and resizing.
You can also create a window programmatically with one of itsinitializers by specifying, among other attributes,
the size and location of its content rectangle. The frame rectangle is derived from the dimensions of the content
rectangle.
When it’s created, a window automatically createstwo views: an opaque frame view that fillsthe frame rectangle
and draws the border, title bar, other peripheral elements, and background, and a transparent content view
that fills the content rectangle. The frame view and its peripheral elements are private objects that your
application can’t access directly. The content view is the “highest” accessible view in the window; you can
replace the default content view with a view of your own creation using the setContentView: method. The
window determines the placement of the content view; you can’t position it using the NSView methods that
begin with setFrame; you must use the NSWindow class’s placement methods, as described in “Opening and
Closing Windows” (page 17).
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
9
How Windows WorkYou add other views to the window as subviews of the content view or as subviews of any of the content
view’s subviews, and so on, via the addSubview: method of NSView. This tree of views is called the window’s
view hierarchy. When a window is told to display itself, it does so by sending display... messages to the
top-level view in its view hierarchy. Because displaying is carried out in a determined order, the content view
(which is drawn first) may be wholly or partially obscured by itssubviews, and these subviews may be obscured
by their subviews (and so on).
How Windows Work
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
10Displaying an NSWindow object begins with the drawing performed by its view objects, which accumulates
in the window’s display buffer or appears immediately on the screen. Windows, like NSView objects, can be
displayed unconditionally or merely marked as needing display, using the display and
setViewsNeedDisplay: methods, respectively. A displayIfNeeded message causes the window’s views
to display only if they’ve been marked as needing display. Normally, any time a view is marked as needing
display, the window makes note of this fact and automatically displays itself shortly thereafter. This automatic
display is typically performed on each pass through the event loop, but can be turned off using the
setAutodisplay: method. If you turn off autodisplay for a window, you’re then responsible for displaying
it whenever necessary.
A window’s views can be drawn concurrently. You can use the methods allowsConcurrentViewDrawing
and setAllowsConcurrentViewDrawing: to determine and set, respectively, whether or not a window
draws its views concurrently. By default, a window’s views are drawn concurrently.
On each passthrough the event loop, the application object invokesits updateWindows method, which sends
an update message to each window. Subclasses of NSWindow can override this method to examine the state
of the application and change their own state or appearance accordingly—enabling or disabling menus,
buttons, and other controls based on the object that’s selected, for example.
In addition to displaying itself on the screen, a window can print itself in its entirety, just as a view can. The
print: method runs the application’s Print panel and causes the window’s frame view to print itself.
dataWithEPSInsideRect: behaves similarly. For additional information see Printing Programming Guide
for OS X .
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
11
How a Window is DisplayedYou can make a whole window or panel run in application-modal fashion, using the application’s normal event
loop machinery but restricting input to the modal window or panel. Modal operation is useful for windows
and panels that require the user’s attention before an action can proceed. Examples include error messages
and warnings, as well as operations that require input, such as open dialogs, or dialogs that apply to multiple
windows.
There are two mechanisms for operating an application-modal window or panel. The first, and simpler, is to
invoke the runModalForWindow: method of NSApplication, which monopolizes events for the specified
window until one of stopModal, abortModal, or stopModalWithCode: is invoked, typically by a button’s
action method. The stopModal method ends the modal status of the window or panel from within the event
loop. It doesn’t work if invoked from a method invoked by a timer or by a distributed object because those
mechanisms operate outside of the event loop. To terminate the modal loop in these situations, you can use
abortModal. The stopModal method is typically invoked when the user clicks the OK button (or equivalent),
abortModal when the user clicks the Cancel button (or presses the Escape key). These two methods are
equivalent to stopModalWithCode: with the appropriate argument.
The second mechanism for operating a modal window or panel, called a modal session, allowsthe application
to perform a long operation while it still sends events to the window or panel. Modal sessions are particularly
useful for panels that allow the user to cancel or modify an operation. To begin a modal session, invoke
beginModalSessionForWindow: on the application, which sets the window up for the session and returns
an identifier used for other session-controlling methods. At this point, the application can run in a loop that
performsthe operation, invoking runModalSession: on the application object on each passso that pending
events can be dispatched to the modal window. This method returns a code indicating whether the operation
should continue, stop, or abort, which is typically established by the methods described above for
runModalForWindow:. After the loop concludes, you can remove the window from the screen and invoke
endModalSession: on the application to restore the normal event loop.
Note: You can write a modal event loop for a view object so that the object has access to all events
pertaining to a particular task, such as tracking the mouse in the view. For an example, see
“Responding to User Events and Actions” in “Creating a Custom View”.
The normal behavior of a modal window or session is to exclude all other windows and panels from receiving
events. For windows and panels that serve as general auxiliary controls, such as menus and the Font panel,
this behavior is overly restrictive. The user must be able to use menu key equivalents (such as those for Cut
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
12
How Modal Windows Workand for Paste) and change the font of text in the modal window, and this requires that non-modal panels be
able to receive events. To support this behavior, an NSWindow subclass overridesthe worksWhenModal method
to return YES. This allows the window to receive mouse and keyboard events even when a modal window is
present. If a subclass needs to work when a modal window is present, it should generally be a subclass of
NSPanel, not of NSWindow.
Modal windows and modal sessions provide different levels of control to the application and the user. Modal
windows restrict all action to the window itself and any methods invoked from the window. Modal sessions
allow the application to continue an operation while accepting input only through the modal session window.
Beyond this, you can use distributed objects to perform background operations in a separate thread, while
allowing the user to perform other actions with any part of the application. The background thread can
communicate with the main thread, allowing the application to display the status of the operation in a
non-modal panel, perhaps including controls to stop or affect the operation as it occurs. Note that because
AppKit isn’t thread-safe, the background thread should communicate with a designated object in the main
thread that in turn interacts with the AppKit.
Before OS X version 10.6, if a modal window was open, application termination would be prevented if the user
attempted to terminate that window’s application. Beginning in OS X version 10.6, you can call
setPreventsApplicationTerminationWhenModal: with a value of NO, and the window will not prevent
application termination when modal. The current value of this property may be accessed by calling
preventsApplicationTerminationWhenModal. The default value is NO.
How Modal Windows Work
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
13A panel is a special kind of window, typically serving an auxiliary function in an application. The NSPanel
subclass of NSWindow adds a few special behaviors to windows in support of the role panels play:
● By default panels are not released when they’re closed, because they’re usually lightweight and often
reused.
● Onscreen panels, except for alert dialogs, are removed from the screen when the application isn’t active
and are restored when the application again becomes active. This reduces screen clutter.
Specifically, the NSWindow implementation of the hidesOnDeactivate method returns NO, but the
NSPanel implementation of the same method returns YES.
● Panels can become the key window, but they cannot become the main window.
●
If a panel is the key window and has a close button, it closes itself when the user presses the Escape key.
In addition to these automatic behaviors, the NSPanel class allows you to configure certain other behaviors
common to some kinds of panels:
● You can prevent a panel from becoming the key window unless the user clicks in a view that responds to
typing. This prevents the key window from shifting to the panel unnecessarily. The
setBecomesKeyOnlyIfNeeded: method controls this behavior.
● Palettes and similar panels can be made to float above standard windows and other panels. This prevents
them from being covered and keepsthem readily available to the user. The setFloatingPanel: method
controls this behavior.
● A panel can be made to receive mouse and keyboard events even when another window or panel is being
run modally or in a modal session. This permits actions in the panel to affect the modal window or panel.
The setWorksWhenModal: method controls this behavior. See “How Modal Windows Work” (page 12)
for more information on modal windows and panels.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
14
How Panels WorkA controller object (in this case, an instance of the NSWindowController class) manages a window; this object
is usually stored in a nib file. This management entails the following:
● Loading and displaying the window
● Closing the window when appropriate
● Customizing the window’s title
● Storing the window’s frame (size and location) in the defaults database
● Cascading the window in relation to other document windows of the application
A window controller can manage a window by itself or as a participant in AppKit’s document-based architecture,
which also includes the NSDocument and NSDocumentController classes. In this architecture, a window
controller is created and managed by a document (an instance of an NSDocument subclass) and, in turn, keeps
a reference to the document. For a discussion of this architecture, see Document-Based App Programming
Guide for Mac .
The relationship between a window controller and a nib file is important. Although a window controller can
manage a programmatically created window, it usually manages a window in a nib file. The nib file can contain
other top-level objects, including other windows, but the window controller’s responsibility is this primary
window. The window controller is usually the owner of the nib file, even when it is part of a document-based
application.
For simple documents—that is, documents with only one nib file containing a window—you need do little
directly with NSWindowController objects. AppKit creates one for you. However, if the default window
controller is not sufficient, you can create a custom subclass of NSWindowController.
For documents with multiple windows or panels, your document must create separate instances of
NSWindowController (or of custom subclasses of NSWindowController), one for each window or panel.
An example is a CAD application that has different windows for side, top, and front views of drawn objects.
What you do in your NSDocument subclass determines whether the default NSWindowController object or
separately created and configured NSWindowController objects are used.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
15
How Window Controllers WorkWindow Closing Behavior
When a window is closed and it is part of a document-based application, the document removes the window’s
window controller from itslist of window controllers. Thisresultsin the system deallocating the window controller
and the window, and possibly the NSDocument object itself. When a window controller is not part of a
document-based application, closing the window does not by default result in the deallocation of the window
or window controller. This is the desired behavior for a window controller that manages something like an
inspector; you shouldn’t have to load the nib file again and re-create the objectsthe next time the user requests
the inspector.
If you want the closing of a window to make both window and window controller go away when it isn’t part
of a document, yoursubclass of NSWindowController can observe the NSWindowWillCloseNotification
notification or, as the window delegate, implement the windowWillClose: method.
How Window Controllers Work
Window Closing Behavior
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
16This article describes how to open and close a window.
Opening a window—that is, making a window visible—is normally accomplished by placing the window into
the application's window list by invoking one of the methods makeKeyAndOrderFront:, orderFront:, etc.,
in NSWindow, and so on. Also, with certain bits set in Interface Builder, the window is shown when the nib file
is loaded in some cases.
Closing a window involves explicit use of either the close method, which simply removes the window from
the screen, or performClose:, which highlights the close button as though the user clicked it. Closing a
window involves at least removing it from the screen but may include disposing of it altogether. The
setReleasedWhenClosed: method specifies whether a window releases itself when it receives a close
message. A window’s delegate is also notified when it’s about to close, as described in “Using Window
Notifications and Delegate Methods” (page 41).
These methods hide a window without closing it. The method orderOut: removes a window from the screen.
You can also set a window to be removed from the screen automatically when its application isn’t active using
setHidesOnDeactivate:. The isVisible method returns whether a window is on or off the screen.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
17
Opening and Closing WindowsEach window is placed on the screen by a particular application, and each application typically owns a variety
of windows. Windows have numerous characteristics. They can be located onscreen or offscreen. Onscreen
windows are placed on the screen in levels managed by the window server.
Windows onscreen are ordered from front to back. Like sheets of paper loosely stacked together, windows in
front can overlap, or even completely cover, those behind them. Each window has a unique position in the
order. When two windows are placed side-by-side, one is still technically in front of the other.
If any window could be in front of any other window, then small but important windows—like menus and
tool palettes—might get lost behind larger ones. Windows that require user action, like attention panels and
pop-up lists, might disappear behind another window and go unnoticed. To prevent this, all the windows
onscreen are organized into levels.
When two windows belong to the same level, either one can be in front. When two windows belong to different
levels, however, the one in the higher level will always be above the other.
Onscreen windows can also carry a status: main or key . Offscreen windows are hidden or minimized on Dock,
and do not carry either status. Onscreen windows that are neither main nor key are inactive.
Window Layering
Each application and document window exists in its own layer, so documents from different applications can
be interleaved. Clicking a window to bring it to the front doesn’t disturb the layering order of any other window.
A window’s depth in the layers is determined by when the window was last accessed. When a user clicks an
inactive document or chooses it from the Window menu, only that document, and any open utility windows,
should be brought to the front. Users can bring all windows of an application forward by clicking its icon in
the Dock or by choosing Bring All to Front in the application’s Window menu. These actions should bring
forward all of the application’s open windows, maintaining their onscreen location, size, and layering order
within the application. For more information, see “UI Element Guidelines: Menus” in OS X Human Interface
Guidelines.
Utility windows are alwaysin the same layer: the top layer. They are visible only when their application is active.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
18
Window Layering and Types of WindowsKey and Main Windows
Windows have different looks based on how the user is interacting with them. The foremost document or
application window that is the focus of the user’s attention is referred to as the main window. Each application
also has only one main window at a given time. This main window often has key status, as well. The main
window is the principal focus of user actions for an application. Often, user actions in a modal key window
(typically a panel such as the Font window or an Info window) have a direct effect on the main window.
Main and key windows are both active windows. Active windows are visually distinct from inactive windows
in that their controls have color, while the controls in inactive windows do not have color. Inactive windows
are windows the user has open but that are not in the foreground. Main and key windows are always in the
foreground and their controls always have color. If the main and key window are different windows, they are
distinguished from one another by the look of their title bars. Note the visual distinctions between main, key,
and inactive windows in Figure 1.
Figure 1 Main, key, and inactive windows
Inactive window
Main window
Key window
A good example of the difference between key and main windows can be seen in most well-behaved Mac
apps. Selecting “Save As...” in a text document, for example, displays a panel with a field to type the document’s
name and a pull-down menu of locations to save it. The panel represents the key window. It will accept your
Window Layering and Types of Windows
Key and Main Windows
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
19keyboard input (the file name), but will directly affect the main window under it (by saving it to the location
you specified). Once you save the document, the save panel disappears, the main window becomes key again,
and will accept keyboard input once more.
The Key Window
The key window responds to user input, whether from the keyboard, mouse, or alternative input devices, for
an application and is the primary recipient of messages from menus and panels. Usually, a window is made
key when the user clicks it. Each application can have only one key window at a given time.
Users expect to see their actions on the keyboard and mouse take effect not only in a particular application,
but also in a particular window of that application. Each user action is associated with a window by the window
server and AppKit. Before acting, the user needs to know which window will be affected; there should be no
surprises.
Since the mouse controls the pointer, it's quite easy for the user to determine which window a mouse action
is associated with. It's whatever window the pointer is over. But the keyboard doesn’t have a pointer, so there’s
no natural way to determine where typed characters will appear.
To mark the key window for users, AppKit highlights its title bar. You can think of the highlighting as a kind
of pointer for the keyboard. It shifts from window to window as the key window changes. Key-window status
also moves from application to application as the active application changes. Only one window on the screen
is marked at a time, and it is in the active application. There’s just one key window on the Desktop. Even a
system that has two screens, but only one keyboard, has at most one key window.
Note: A window doesn’t have to become the key window to receive, and act on, keyboard shortcuts.
It does, however, have to be a window in the active application.
Since the key window belongs to the active application, its highlighted title bar has the secondary effect of
helping to show which application is currently active. The key window isthe most prominently marked window
in the active application, making it “key” in a second sense: it’s the main focus of the user’s attention on the
screen.
The Main Window
The main window is the standard window where the user is currently working. The main window is not always
the key window. There are times when a window other than the main window takes the focus of the input
device, while the main window still remains the focus of the user’s attention and of user actions carried out in
panels and menus. For example, when a person is using an inspector, a Find dialog, or the Fonts or Colors
windows, the document is the main window and the other window is the key window. The Find panel requires
Window Layering and Types of Windows
Key and Main Windows
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
20the user to supply information by typing it. Since the panel is the destination of the user’s keystrokes, it’s
marked as the key window. But the panel is just an instrument through which users can do work in another
window—the main window. In a document-based application, the main window isthe window for the current
document.
Whenever a standard window becomesthe key window, it also becomesthe main window. When key-window
status shifts from a standard window to a panel, main-window status remains with the standard window.
So that users can pick out the main window when it’s not the key window, the Application Kit highlights its
title bar and colorsthe window buttons. If the main window is also the key window, it has only the highlighting
of the key window. A menu command might affect either the key window or the main window, depending
on the command. For example, the Paste command can be used to enter text in a Find panel. But the Save
command saves the document displayed in the main window, and the Bold command turns the current
selection in the main window bold. For this reason, user actions in a panel or menu are associated with both
the key window and the main window:
● An action is first associated with the key window.
●
If the key window is a panel and it can’t handle the action, the action is next associated with the main
window.
Note that this order of precedence is reflected in the way windows are highlighted: The key window is always
marked, but the main window is marked only when it’s not the key window. The main window is always in the
same application as the key window, the active application.
Changing a Window’s Status
Windows that are already onscreen automatically change their status as the key or main window based on the
user’s actions with the mouse and on how clicked views handle those mouse events. You can also set the key
and main windows programmatically by sending the relevant windows a makeKeyWindow or makeMainWindow
message. Setting the key and main windows programmatically is particularly useful when creating a new
window. Because making a window key is often combined with ordering the window to the front of the screen,
the NSWindow class defines a convenience method, makeKeyAndOrderFront:, that performs both operations.
Not all windows are suitable as key or main windows. For example, a window that merely displays information
and contains no objectsthat need to respond to events or action messages can completely forgo ever becoming
the key window. Similarly, a window that acts as a floating palette of itemsthat are only dragged out by mouse
actions never needs to be the key window. Such a window can be defined as a subclass of NSWindow that
overridesthe methods canBecomeKeyWindow and canBecomeMainWindow to return NO instead of the default
of YES. Defining a window this way prevents it from ever becoming the key or main window. Although the
NSWindow class defines these methods, only subclasses of NSPanel typically refuse to accept key or main
window status.
Window Layering and Types of Windows
Key and Main Windows
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
21Windows can be placed on the screen in three dimensions. Besides horizontal and vertical placement, windows
are layered back-to-front within distinct levels. Each application and document window exists in its own layer,
so documents from different applications can be interleaved. Clicking a window to bring it to the front doesn’t
disturb the layering order of any other window. A window’s depth in the layers is determined by when the
window was last accessed. When a user clicks an inactive document or chooses it from the Window menu,
only that document and any open utility windows should be brought to the front.
Window Levels
Windows are ordered within several distinct levels. Window levels group windows ofsimilar type and purpose
so that the more “important” ones(such as alert panels) appear in front of those lesser importance. A window’s
level serves as a high-order bit to determine its position with regard to other windows. Windows can be
reordered with respect to each other within a given level; a given window, however, cannot be layered above
other windows in a higher level.
There are a number of predefined window levels, specified by constants defined by the NSWindow class. The
levels you typically use are: NSNormalWindowLevel, which specifies the default level;
NSFloatingWindowLevel, which specifiesthe level for floating palettes; and NSScreenSaverWindowLevel,
which specifies the level for a screen saver window. You might also use NSStatusWindowLevel for a status
window, or NSModalPanelWindowLevel for a modal panel. If you need to implement your own popup menus
you use NSPopUpMenuWindowLevel. The remaining two levels, NSTornOffMenuWindowLevel and
NSMainMenuWindowLevel, are reserved for system use.
Setting Ordering and Level Programmatically
You can use the orderWindow:relativeTo: method to order a window within its level in front of or in back
of another window. You more typically use convenience methods to specify ordering, such as
makeKeyAndOrderFront: (which also affectsstatus), orderFront:, and orderBack:, as well as orderOut:,
which removes a window from the screen. You use the isVisible method to determine whether a window
is on or off the screen. You can also set a window to be removed from the screen automatically when its
application isn’t active using setHidesOnDeactivate:.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
22
Window Layers and LevelsTypically you should have no need to programmatically set the level of a window, since Cocoa automatically
determines the appropriate level for a window based on its characteristics. A utility panel, for example, is
automatically assigned to NSFloatingWindowLevel. You can nevertheless set a window’s level using the
setLevel: method; for example, you can set the level of a standard window to NSFloatingWindowLevel
if you want a utility window that looks like a standard window (for example to act as an inspector). This has
two disadvantages, however: firstly, it may violate the human interface guidelines; secondly, if you assign a
window to a floating level, you must ensure that you also set it to hide on deactivation of your application or
reset its level when your application is hidden. Cocoa automatically takes care of the latter aspect for you if
you use default window configurations.
There is currently no level specified to allow you to place a window above a screen saver window. If you need
to do this (for example, to show an alert while a screen saver is running), you can set the window’s level to be
greater than that of the screen saver, as shown in the following example.
[aWindow setLevel:NSScreenSaverWindowLevel + 1];
Other than this specific case, you are discouraged from setting windows in custom levels since this may lead
to unexpected behavior.
Window Layers and Levels
Setting Ordering and Level Programmatically
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
23The are a number of different options that can be set regarding the window collection behavior of a window.
They include a window’s behavior when using Spaces, Exposé, and the “Cycle Through Windows” command.
These options can be set using the setCollectionBehavior: method of NSWindow, by passing in at most
one constant from each group, combined using bitwise or operators. The current options may be accessed via
the collectionBehavior method.
Spaces Collection Behavior
There are three options that can be set for a window’s Spaces collection behavior. The default is
NSWindowCollectionBehaviorDefault, which allows the window to be associated with one space at a
time. The second option is NSWindowCollectionBehaviorCanJoinAllSpaces. This option causes the
window to appear on all spaces, like the menu bar. The third option is
NSWindowCollectionBehaviorMoveToActiveSpace. This causesthe window to switch to the active space
when it is made active. Only one of these options may be used at a time.
If a window is currently associated with the active space, isOnActiveSpace returns YES. Otherwise, it returns
NO. Additionally, you can get an array of the window numbers of windows on one or all spaces using the
method windowNumbersWithOptions: and specified your desired options. The possible options are specified
by NSWindowNumberListOptions.
Exposé Collection Behavior
There are also three options that can be set for a window’s Exposé collection behavior. If a window has a
window level of NSNormalWindowLevel, the default behavior is NSWindowCollectionBehaviorManaged,
which causes the window to participate in both Spaces and Exposé.
NSWindowCollectionBehaviorTransient causes the window to float in Spaces and be hidden in Exposé.
This is the default behavior if the window level is not NSNormalWindowLevel. The final option is
NSWindowCollectionBehaviorStationary, which causes the window to be unaffected by Exposé; i.e. it
stays visible and does not move, like the desktop window. Only one of these options may be used at a time.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
24
Setting Window Collection BehaviorWindow Cycling Behavior
There are two options: NSWindowCollectionBehaviorParticipatesInCycle and
NSWindowCollectionBehaviorIgnoresCycle. These options cause the window to participate in the
window cycle for the “Cycle Through Windows” menu option or not participate in it, respectively.
Setting Window Collection Behavior
Window Cycling Behavior
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
25This article describes how to control a window’s size and position, including how to set a window’s minimum
and maximum size, how to constrain a window to the screen, how to cascade windowsso their title barsremain
visible, how to zoom a window as though the user pressed the zoom button, and how to center a window on
the screen.
Setting a Window’s Size and Location
The center method places a window in the most prominent location on the screen, one suitable for important
messages and alert dialogs.
You can resize or reposition a window using setFrame:display: or setFrame:display:animate:—the
former is equivalent to the latter with the animate flag NO. You might use these methodsin particular to expand
or contract a window to show or hide a subview (such as a control that may be exposed by clicking a disclosure
triangle). If the animate argument in setFrame:display:animate: is YES, the method performs a smooth
resize of the window, where the total time for the resize can be obtained by calling animationResizeTime:.
The user can resize windows by clicking and dragging on the bottom right corner of the window. While the
user is resizing the window, inLiveResize will return YES. Otherwise, it returns NO. The user can generally
reposition windows by dragging only the title bar. If you want usersto be able to drag your window by clicking
elsewhere, you should override mouseDownCanMoveWindow so that it returns YES in any views that you want
to be draggable window regions. The methods isMovable and setMovable: determine whether the user
can move the window by clicking in its title bar or background.
To keep the window’s top-left hand corner fixed when resizing, you must typically also reposition the origin,
as illustrated in the following example.
- (IBAction)showAdditionalControls:sender
{
NSRect frame = [myWindow frame];
if (frame.size.width <= MIN_WIDTH_WITH_ADDITIONS)
frame.size.width = MIN_WIDTH_WITH_ADDITIONS;
frame.size.height += ADDITIONS_HEIGHT;
frame.origin.y -= ADDITIONS_HEIGHT;
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
26
Sizing and Placing Windows[myWindow setFrame:frame display:YES animate:YES];
// implementation continues...
Note that the window’s delegate does not receive windowWillResize:toSize: messages when the window
is resized in this way. It is your responsibility to ensure that the window’s new size is acceptable.
The window’s delegate doesreceive windowDidResize: messages. You can implement windowDidResize:
to add or remove subviews at suitable junctures. There are no additional flags to denote that the window is
performing an animated resize operation (as distinct from a user-initiated resize). It is therefore up to you to
capture relevant state information so that you can update the window contents appropriately in
windowDidResize:.
Window Cascading
If you use the Cocoa document architecture, you can use the setShouldCascadeWindows: method of
NSWindowController to set whether the window, when it is displayed, should cascade in relation to other
document windows(that is, have a slightly offset location so that the title bars of previously displayed windows
are still visible). The default is true, so typically you have no additional work to perform.
If you are not using the document architecture, you can use the cascadeTopLeftFromPoint: method of
NSWindow to cascade windows yourself. The method returns a point shifted from the top-left corner of the
window that can be passed to a subsequent invocation of cascadeTopLeftFromPoint: to position the next
window so the title bars of both windows are fully visible.
Window Zooming
You use the zoom: method to toggle the size and location of a window between its standard state, as
determined by the application, and its user state: a new size and location the user may have set by moving or
resizing the window.
Constraining a Window’s Size and Location
You can use setContentMinSize: and setContentMaxSize: to limit the user’s ability to resize the
window—note that you can still set it to any size programmatically. Similarly, you can use
setContentAspectRatio: to keep a window’s width and height at the same proportions as the user resizes
it, and setContentResizeIncrements: to make the window resize in discrete amountslarger than a single
pixel. (Aspect ratio and resize increments are mutually exclusive attributes.) In general, you should use the
Sizing and Placing Windows
Constraining a Window’s Size and Location
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
27setContent... methodsinstead of those that affect the window’sframe (setAspectRatio:, setMaxSize:,
and so on). These are preferred because they avoid confusion for windows with toolbars, and also are typically
a better model since you control the content of the window but not the frame.
You can use the constrainFrameRect:toScreen: method to adjust a proposed frame rectangle so that
it lies on the screen in such a way that the user can move and resize a window. However, you should make
sure your window fits onscreen before display. Note that any NSWindow with a title bar automatically constrains
itself to the screen. The cascadeTopLeftFromPoint: method shifts the top left point by an amount that
allows one window to be placed relative to another so that both their title bars are visible.
Additionally, when a window is about to be resized, the window’s delegate will be sent a
windowWillResize:toSize: message. You can implement that method in your delegate to easily control
your window’s size.
Sizing and Placing Windows
Constraining a Window’s Size and Location
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
28A window can store its placement in the user defaults system, so that it appears in the same location the next
time the user starts the application. The saveFrameUsingName: method stores the frame rectangle, and
setFrameUsingName: setsit from the value in user defaults. You can also use the setFrameAutosaveName:
method to have a window save the frame rectangle any time it changes. However, for the correct frame to be
saved, you must ensure that the window controller for the window in question doesn’t cascade the windows
under its charge. You accomplish this task by sending setShouldCascadeWindows:NO to the controller, as
shown in Listing 1.
Listing 1 Saving a window’s frame automatically
NSWindow *window = // the window in question
[[window windowController] setShouldCascadeWindows:NO]; // Tell the controller
to not cascade its windows.
[window setFrameAutosaveName:[window representedFilename]]; // Specify the autosave
name for the window.
To expunge a frame rectangle from the defaults system, use the class method removeFrameUsingName:.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
29
Saving a Window’s Position into the User’s DefaultsWhen a user minimizes a window, it’s removed from the screen and replaced with a smaller counterpart in the
Dock.
The miniaturize: and deminiaturize: methods reduce and reconstitute a window, and
performMiniaturize: simulatesthe user clicking the window’s minimize button. You can also set the image
and title displayed in a freestanding mini-window by sending setMiniwindowImage: and
setMiniwindowTitle: messages to the NSWindow object.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
30
Minimizing WindowsMost Cocoa applications include the Window menu, which displays the titles of various of the application’s
windows. When you change a window’s title, this change is automatically reflected in the Window menu. This
menu automatically lists windowsthat have a title bar and are resizable and that can become the main window
(as described in “Window Layering and Types of Windows” (page 18)). Typically you can rely on the automatic
updating provided by Cocoa. In rare circumstances, however, you might want to modify the default behavior.
You can exclude a window that would otherwise be listed in the Window menu by sending it a
setExcludedFromWindowsMenu:YES message. Since they cannot become main, NSPanel objects are
excluded from the Windows menu. Instances of subclasses of NSPanel can be included in the menu by
returning NO from its isExcludedFromWindowsMenu method and YES from its canBecomeMainWindow
method. If you change a window’s configuration such that it should be added to or removed from the Window
menu, you can update the Window menu by sending the shared application instance
addWindowsItem:title:filename: or removeWindowsItem:.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
31
Using the Window MenuYou usually configure most aspects of a window’s appearance in Interface Builder. Sometimes, however, you
may need to create a window programmatically, or alter its appearance after it has been created.
Setting a Window’s Style
The peripheral elements that a window displays define its style. Though you can’t access and manipulate them
directly, you can determine at initialization whether a window has them by providing a style mask to the
initializer. There are four possible style elements,specifiable by combining their mask values using the C bitwise
OR operator:
Element Mask Value
A title bar NSTitledWindowMask
A close button NSClosableWindowMask
A minimize button NSMiniaturizableWindowMask
A resize bar, border, or box NSResizableWindowMask
You can also specify NSBorderlessWindowMask, in which case none of these style elements is used.
Typically, you set a window’s appearance once, when it is first created. Sometimes, however, you want to
enable or disable a button in the title bar to reflect changed context. To do this, you first retrieve the button
from the window using the standardWindowButton: of NSWindow method and then set its enabled state,
as in the following example.
NSButton *closeButton = [window standardWindowButton:NSWindowCloseButton];
[closeButton setEnabled:NO];
The constants required to access standard title bar widgets are defined in the API reference for NSWindow.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
32
Setting a Window’s AppearanceSetting a Window’s Color and Transparency
You can set a window’s background color and transparency using the methods setBackgroundColor: and
setAlphaValue:, respectively.
You can set a window’s background color to a non-opaque color. This does not affect the window’s title bar;
it only makes the background itself transparent if the window is not opaque, as illustrated in the following
example.
[myWindow setOpaque:NO]; // YES by default
NSColor *semiTransparentBlue =
[NSColor colorWithDeviceRed:0.0 green:0.0 blue:1.0 alpha:0.5];
[myWindow setBackgroundColor:semiTransparentBlue];
Views placed on a non-opaque window with a transparent background color retain their own opacity. If you
want to make the entire window (including the title bar and views placed on the window) transparent, you
should use setAlphaValue:.
Setting a Window’s Color Space
You can set a window’s colorspace using setColorSpace: and can retrieve the window’s current colorspace
using colorSpace. NSColorSpace objects for use with setColorSpace: may be obtained using the class
methods documented in NSColorSpace Class Reference .
Setting a Window’s Content Border Thickness
Beginning in OS X version 10.5, windows automatically have a textured gradient applied to their backgrounds.
The area on which the gradient is drawn is determined automatically. At times, however, this may not work
correctly. If your window does not look correct with automatic gradient calculation, disable it by calling
setAutorecalculatesContentBorderThickness:forEdge: with a value of NO and the edge to disable
automatic calculation for. The value of this property may be accessed using the method
autorecalculatesContentBorderThicknessForEdge:.
You can also set and access the content border thickness manually using
setContentBorderThickness:forEdge: and contentBorderThicknessForEdge:, respectively.
Setting a Window’s Appearance
Setting a Window’s Color and Transparency
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
33A titled window can display an arbitrary title or one derived from a filename. The setTitle: method puts an
arbitrary string on the title bar. The setTitleWithRepresentedFilename: method formats a filename in
the title bar in a readable format and associates the window with that file. You can set the associated file
without changing the title using setRepresentedFilename:. You can use the association between the
window and the file in any way you see fit. One convenience offered by the NSWindow class is marking the
file as having been changed, so that the user is prompted to save it on closing the window. The method for
marking the document as having been changed is setDocumentEdited:. When the window closes, its
delegate can check if the files has been changed using isDocumentEdited to see whether the document
needs to be saved.
Additionally, starting in OS X version 10.5, you can set a window’s represented document by URL using the
setRepresentedURL: method. You can get the URL of the document currently represented by a window
using the representedURL method. The window will automatically use the known icon for the file type of
the specified file, if one exists. To customize the document icon, you can use the following code segment:
[[NSWindow standardWindowButton:NSWindowDocumentIconButton] setImage:customImage].
By default, a Command-click or Control-click on the rectangle containing a window’s document icon button
and title will show a path popup. To customize this behavior, you can implement
window:shouldPopUpDocumentPathMenu: in your window’s delegate. You can return NO from this method
to stop the window from showing the path popup.
You can also customize the document icon’s default drag behavior by implementing the
window:shouldDragDocumentWithEvent:from:withPasteboard: in the window’s delegate. You can
return NO to prohibit dragging the document icon.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
34
Setting a Window’s Title and Represented FileNearly every window has a corresponding display window device in the window server. The window device
holdsthe window’s drawn image, and hastwo attributes determined by the window server and many attributes
that the window controls. The window server assigns the window device a unique identifier (within an
application). This is the window number, and it can be accessed using the windowNumber method. Each
window also has a graphics state that most of its views share for drawing (views can create their own as well).
The gState method returns its identifier. The attributes under direct window control are the following:
● Backing store type, described in “Specifying How To Store the Window’s Image” (page 35)
● Backing location, described in “Specifying Where To Store the Window’s Image” (page 36)
● Window device creation, described in “Specifying When the Window’s Image Is Created” (page 36)
● One shot, described in “Specifying Whether the Window’s Image Persists When Offscreen” (page 37)
● Depth limit, described in “Specifying the Depth Limit for the Window’s Image” (page 37)
● Dynamic depth limit, described in “Specifying Whether the Depth Limit Changes to the Screen’s
Capacity” (page 37)
● Content sharing, described in “Specifying Whether Window Content Can Be Read or Written by Another
Process” (page 37).
Specifying How To Store the Window’s Image
A window device’s backing store type determines how the window’simage isstored. It’sset when the window
is initialized and can be one of three types.
A buffered window device renders all drawing into a display buffer and then flushes it to the screen. Always
drawing to the buffer produces very smooth display, but can require significant amounts of memory. Buffered
windows are best for displaying material that must be redrawn often, such as text. You must also use buffered
windows if you want your windows to support transparency.
A retained window device also uses a buffer, but draws directly to the screen where possible and to the buffer
for any portions that are obscured.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
35
Setting Attributes for the Window’s ImageA nonretained window device has no buffer at all, and must redraw portions as they’re exposed. Further, this
redrawing is suspended when the window’s display mechanism is preempted. For example, if the user drags
a window across a nonretained window, the nonretained window is “erased” and isn’t redrawn until the user
releases the mouse.
Both retained and nonretained windows are also subject to a flashing effect as individual drawing operations
are performed, but their results do get to the screen more quickly than those of buffered windows.
You can change the backing store type between buffered and retained after initialization using the
setBackingType: method.
Specifying Where To Store the Window’s Image
The window server chooses whether to place the backing store for a buffered window in main memory or
video memory. It will choose the location that providesthe best overall performance. You can query the window
server to determine where your window’s backing store is located using the preferredBackingLocation
method.
You may choose to set a preferred location for a Window’s backing store using the
setPreferredBackingLocation: method. While the window server is not required to respect this preferred
backing location, it will attempt to do so. You should not change the preferred backing location without testing
how it affects the performance of your application.
Specifying When the Window’s Image Is Created
The defer argument to the initializer specifies whether the window creates its window device immediately
or only when it’s moved on screen. Deferring creation of the window device can offer some performance gain
for windows that aren’t displayed immediately because it reduces the amount of work that needs to be
performed up front. Deferring creation of the window device is particularly useful when creation of the window
itself can’t be deferred or when an window is needed for purposes other than displaying content. Submenus
with key equivalents, for example, must exist for the key equivalents to work, but may never actually be
displayed.
Setting Attributes for the Window’s Image
Specifying Where To Store the Window’s Image
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
36Specifying Whether the Window’s Image Persists When Offscreen
Memory can also be saved by destroying the window device when the window is removed from the screen.
The setOneShot: method controls this behavior. One-shot window devices exist only when their windows
are onscreen.
Specifying the Depth Limit for the Window’s Image
Like the display hardware, a window device’s buffer has a depth, or a limit to the memory allotted each pixel.
Buffered and retained windows start out with the same depth as the main display or 16 bits, whichever is
deeper. These settings stay in effect unless changed using the setDepthLimit: method, which takes as an
argument a window depth limit created using the NSBestDepth function.
SpecifyingWhether the Depth Limit Changesto the Screen’s Capacity
Keeping a window’s depth at its richest preserves the displayed image, but may incur unnecessary memory
overhead when the window buffer depth is deeper than the screen depth. You can use the
setDynamicDepthLimit: method to tell a window to match the depth of the screen it’s on. When it’s moved
to a new screen, a window with a dynamic depth limit adjusts its buffer to the new depth before redrawing.
Making a window’s depth limit dynamic overrides the limit set using setDepthLimit:, and removing the
dynamic limit reverts the window to the default limit.
Specifying Whether Window Content Can Be Read or Written by
Another Process
The contents of your window can be made available to other processes. By default, the contents of your window
can be read but not written to by other processes. This allows system services to work with your window’s
contents and also allows other applications to capture a snapshot of your windows contents.
You can override the default behavior using the setSharingType: method. Changing the sharing type to
NSWindowSharingNone prevents other systems from capturing your window’s image data. If you do this,
however, your window will not be able to participate in a number of system services; therefore, this setting
should be used with caution. If you set your window’s sharing type to NSWindowSharingReadWrite, other
processes can both read and modify the window’s content.
Setting Attributes for the Window’s Image
Specifying Whether the Window’s Image Persists When Offscreen
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
37As described in NSResponder Class Reference , most events coming into an application make their way to a
window in a sendEvent: message. A key event is directed at the key window, while a mouse event is directed
at whatever window lies under the pointer. If an event affects the window directly—resizing or moving it, for
example—it performs the appropriate operation itself and sends messages to its delegate informing it of its
intentions, thus allowing your application to intercede. The window sends other events up its responder chain
from the appropriate starting point: the first responder for a key event, the view under the pointer for a mouse
event. These events are then typically handled by some view object in the window. See Cocoa Event Handling
Guide for more information on how to intercept and handle events.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
38
Handling Events in WindowsA window’s first responder is often a view object selected by the user clicking it. For text fields and other view
objects (mainly subclasses of NSControl), the user can select the first responder with the keyboard using the
Tab and Shift keys. The NSView class defines the methods for setting up and examining the loop of objects
that the user can select in this manner. A view that’s the first responder is called the key view, and the views
that can become the key view in a window are linked together in the window’s key view loop. You normally
set up the key view loop using Interface Builder, establishing connections between the nextKeyView outlets
of views in the window and setting the window’s initialFirstResponder outlet to the view that you want
selected when the window is first placed onscreen. If you do not set this outlet, the window sets a key loop
(not necessarily the same as the one you would have specified!) and picks a default initial first responder for
you.
In addition to the key view loop, a window can have a default button cell, which uses the Return (or Enter)
key as its key equivalent. The setDefaultButtonCell: method establishes this button cell; you can also
set it in Interface Builder by setting a button cell’s key equivalent to '\r'. The default button cell draws itself
as a focal element for keyboard interface control unless another button cell is focused on. In this case, it
temporarily draws itself as normal and disables its key equivalent. Another default key established by the
NSWindow class is the Escape key, which immediately aborts a modal loop (described in “How Modal Windows
Work” (page 12)).
See NSResponder Class Reference for more information on keyboard interface control.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
39
Using Keyboard Interface Control in WindowsEach window has a text object that is shared for light editing tasks. This object, the window’s field editor, is
inserted in the view hierarchy when an object needsto editsome text and removed when the object isfinished.
The field editor is used by NSTextField objects and other controls, for example, to edit the text that they
display. The fieldEditor:forObject: method returns a window’s field editor, after asking the delegate
for a substitute using windowWillReturnFieldEditor:toObject:. You can override the
fieldEditor:forObject: method of NSWindow in subclasses or provide a delegate to substitute a class
of text object different from the NSTextView default, thereby customizing text editing in your application.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
40
Using the Window’s Field EditorThe NSWindow class offers observers a rich set of notifications, which it broadcasts on such occurrences as
gaining or losing key or main window status, minimizing, moving or resizing, becoming exposed, and closing.
Each notification is matched to a delegate method, so a window’s delegate is automatically registered for all
notifications that it has methods for. The NSWindow class also offers its delegate a few other methods, such
as windowShouldClose:, which requests approval to close, windowWillResize:toSize:, which allows
the delegate to constrain the window’ssize, windowWillUseStandardFrame:defaultFrame:, which allows
the delegate to set the window frame for zooming, and windowWillReturnFieldEditor:toObject:,
which gives the delegate a chance to modify the field editor or substitute a different editor. See the individual
notification and delegate method descriptions for more information.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
41
Using Window Notifications and Delegate MethodsThe NSWindow class defines some methods for image dragging, in case the user wants to drag an object into
or out of a window. Although most dragging operations are initiated by and occur between view objects, the
NSWindow class also defines an image-dragging method,
dragImage:at:offset:event:pasteboard:source:slideBack:. A window can also serve as the
destination for dragging operations, registering the types it accepts with registerForDraggedTypes: and
unregisterDraggedTypes.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
42
Dragging Images to and from WindowsYou can change the cursor image when the cursor is within a specified area of a view in a window. To do this,
use the NSTrackingArea class, along with the cursorUpdate: method of the NSResponder class. For
specifics, read “Using Tracking-Area Objects” in Cocoa Event Handling Guide .
For details on the NSTrackingArea class itself, refer to NSTrackingArea Class Reference .
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
43
Updating the Cursor Image in a WindowTo support transitory drawing by views, the NSWindow class defines methods that temporarily cache a portion
of its raster image so that it can be restored later. This feature is useful for situations where highly dynamic
drawing must be done over the otherwise static image of the window. For example, in a drawing program
where the user drags lines and other shapes directly onto a canvas, it’s more efficient to restore the window’s
cached image and draw anew over that than to have all the views send display instructions to the window
server. For more information,see the method descriptionsfor cacheImageInRect:, restoreCachedImage,
and discardCachedImage.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
44
Caching Window ImagesThis table describes the changes to Window Programming Guide .
Date Notes
Revised the article “Updating the Cursor Image in a Window” (page 43),
previously titled “Setting Pointer Rectangles for Windows.”
2009-11-27
2009-05-15 Updated for OS X v10.6.
Added information on the use of backing locations to improve
performance.
2009-02-04
2008-10-15 Provided links to delegate methods.
Clarified the behavior of the setFrameAutosaveName: method in
conjunction with a window's window controller.
2006-10-03
Added window-controller requirement for the NSWindow
setFrameAutosaveName: method to “Saving a Window’s Position into
the User’s Defaults” (page 29).
Made correction to "Using the Windows Menu" article. Changed title from
"Windows and Panels."
2005-09-08
Updated “Setting a Window’s Appearance” (page 32) to cover enabling
and disabling buttons in the title bar, and to discuss setting a window’s
background color and transparency.
2004-08-31
“Setting a Window’s Level” renamed “Window Layers and Levels” (page
22) and augmented.
“Changing the Key and Main Windows” renamed to “Window Layering
and Types of Windows” (page 18) and augmented.
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
45
Document Revision HistoryDate Notes
Augmented “Sizing and Placing Windows” (page 26) to discuss animated
resizing, window cascading, and constraining window size and position.
Minor changes to “Using the Window Menu” (page 31).
Clarified the concepts of key and main windowsin “Window Layering and
Types of Windows” (page 18)“.
2003-06-05
2002-11-12 Revision history was added to existing topic.
Document Revision History
2009-11-27 | © 2002, 2009 Apple Inc. All Rights Reserved.
46Apple Inc.
© 2002, 2009 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, Exposé, Mac,
Numbers, OS X, and Spaces are trademarks of
Apple Inc., registered in the U.S. and other
countries.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
AV Foundation
Programming GuideContents
About the AV Foundation Framework 4
At a Glance 5
Representing and Using Media with AV Foundation 5
Concurrent Programming with AV Foundation 7
Prerequisites 8
Using Assets 9
Creating an Asset Object 9
Options for Initializing an Asset 9
Accessing the User’s Assets 10
Preparing an Asset for Use 11
Getting Still Images From a Video 12
Generating a Single Image 13
Generating a Sequence of Images 14
Trimming and Transcoding a Movie 15
Reading and Writing Assets 17
Playback 18
Playing Assets 18
Handling Different Types of Asset 20
Playing an Item 21
Changing the Playback Rate 21
Seeking—Repositioning the Playhead 22
Playing Multiple Items 23
Monitoring Playback 23
Responding to a Change in Status 24
Tracking Readiness for Visual Display 25
Tracking Time 25
Reaching the End of an Item 26
Putting it all Together: Playing a Video File Using AVPlayerLayer 26
The Player View 27
A Simple View Controller 27
Creating the Asset 28
Responding to the Player Item’s Status Change 30
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
2Playing the Item 31
Media Capture 32
Use a Capture Session to Coordinate Data Flow 33
Configuring a Session 34
Monitoring Capture Session State 35
An AVCaptureDevice Object Represents an Input Device 35
Device Characteristics 36
Device Capture Settings 36
Configuring a Device 40
Switching Between Devices 41
Use Capture Inputs to Add a Capture Device to a Session 41
Use Capture Outputs to Get Output from a Session 42
Saving to a Movie File 43
Processing Frames of Video 46
Capturing Still Images 47
Showing the User What’s Being Recorded 49
Video Preview 49
Showing Audio Levels 50
Putting it all Together: Capturing Video Frames as UIImage Objects 50
Create and Configure a Capture Session 51
Create and Configure the Device and Device Input 51
Create and Configure the Data Output 52
Implement the Sample Buffer Delegate Method 52
Starting and Stopping Recording 53
Time and Media Representations 54
Representation of Assets 54
Representations of Time 55
CMTime Represents a Length of Time 55
CMTimeRange Represents a Time Range 57
Representations of Media 58
Converting a CMSampleBuffer to a UIImage 59
Document Revision History 62
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
3
ContentsAV Foundation is one of several frameworks that you can use to play and create time-based audiovisual media.
It provides an Objective-C interface you use to work on a detailed level with time-based audiovisual data. For
example, you can use it to examine, create, edit, or reencode media files. You can also get input streams from
devices and manipulate video during realtime capture and playback.
Core Audio
UIKit
Media Player
AV Foundation
iOS 3 Audio
classes
Core Media Core Animation
You should typically use the highest-level abstraction available that allows you to perform the tasks you want.
For example, in iOS:
●
If you simply want to play movies, you can use the Media Player Framework (MPMoviePlayerController
or MPMoviePlayerViewController), or for web-based media you could use a UIWebView object.
● To record video when you need only minimal control over format, use the UIKit framework
(UIImagePickerController).
Note, however, thatsome of the primitive data structuresthat you use in AV Foundation—including time-related
data structures and opaque objectsto carry and describemedia data—are declared in the Core Media framework.
AV Foundation is available in iOS 4 and later, and OS X 10.7 and later. This document describes AV Foundation
as introduced in iOS 4.0. To learn about changes and additions to the framework in subsequent versions, you
should also read the appropriate release notes:
● AV Foundation Release Notes describe changes made for iOS 5.
● AV Foundation Release Notes (iOS 4.3) describe changes made for iOS 4.3 and included in OS X 10.7.
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
4
About the AV Foundation FrameworkRelevant Chapters: “Time and Media Representations” (page 54)
At a Glance
There are two facets to the AV Foundation framework—API related just to audio, which was available prior to
iOS 4; and API introduced in iOS 4 and later. The older audio-related classes provide easy ways to deal with
audio. They are described in Multimedia Programming Guide , not in this document.
● To play sound files, you can use AVAudioPlayer.
● To record audio, you can use AVAudioRecorder.
You can also configure the audio behavior of your application using AVAudioSession; this is described in
Audio Session Programming Guide .
Representing and Using Media with AV Foundation
The primary class that the AV Foundation framework uses to represent media is AVAsset. The design of the
framework is largely guided by this representation. Understanding its structure will help you to understand
how the framework works. An AVAsset instance is an aggregated representation of a collection of one or
more pieces of media data (audio and video tracks). It provides information about the collection as a whole,
such as its title, duration, natural presentation size, and so on. AVAsset is not tied to particular data format.
AVAsset is the superclass of other classes used to create asset instances from media at a URL (see “Using
Assets” (page 9)) and to create new compositions (see “Editing” (page 7)).
Each of the individual pieces of media data in the asset is of a uniform type and called a track. In a typical
simple case, one track represents the audio component, and another represents the video component; in a
complex composition, however, there may be multiple overlapping tracks of audio and video. Assets may also
have metadata.
A vital concept in AV Foundation is that initializing an asset or a track does not necessarily mean that it is ready
for use. It may require some time to calculate even the duration of an item (an MP3 file, for example, may not
contain summary information). Rather than blocking the current thread while a value is being calculated, you
ask for values and get an answer back asynchronously through a callback that you define using a block.
About the AV Foundation Framework
At a Glance
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
5Relevant Chapters: “Using Assets” (page 9)
“Time and Media Representations” (page 54)
Playback
AVFoundation allows you to manage the playback of asset in sophisticated ways. To support this, it separates
the presentation state of an asset from the asset itself. This allows you to, for example, play two different
segments of the same asset at the same time rendered at different resolutions. The presentation state for an
asset is managed by a player item object; the presentation state for each tracks within an asset is managed
by a player item track objects. Using the player item and player item tracks you can, for example, set the size
at which the visual portion of the item is presented by the player, set the audio mix parameters and video
composition settings to be applied during playback, or disable components of the asset during playback.
You play player items using a player object, and direct the output of a player to Core Animation layer. On
iOS 4.1 and later, you can use a player queue to schedule playback of a collection of player items in sequence.
Relevant Chapters: “Playback” (page 18)
Reading, Writing, and Reencoding Assets
AV Foundation allows you to create new representations of an asset in several ways. You can simply reencode
an existing asset, or—on iOS 4.1 and later—you can perform operations on the contents of an asset and save
the result as a new asset.
You use an export session to reencode an existing asset into a format defined by one of a small number of
commonly-used presets. If you need more control over the transformation, on iOS 4.1 and later you can use
an asset reader and asset writer object in tandem to convert an asset from one representation to another.
Using these objects you can, for example, choose which of the tracks you want to be represented in the output
file, specify your own output format, or modify the asset during the conversion process.
To produce a visual representation of the waveform, you use an asset reader to read the audio track of an
asset.
About the AV Foundation Framework
At a Glance
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
6Relevant Chapters: “Using Assets” (page 9)
Thumbnails
To create thumbnail images of video presentations, you initialize an instance of AVAssetImageGenerator
using the asset from which you want to generate thumbnails. AVAssetImageGenerator uses the default
enabled video track(s) to generate images.
Relevant Chapters: “Using Assets” (page 9)
Editing
AV Foundation uses compositions to create new assets from existing pieces of media (typically, one or more
video and audio tracks). You use a mutable composition to add and remove tracks, and adjust their temporal
orderings. You can also set the relative volumes and ramping of audio tracks; and set the opacity, and opacity
ramps, of video tracks. A composition is an assemblage of pieces of media held in memory. When you export
a composition using an export session, it's collapsed to a file.
On iOS 4.1 and later, you can also create an asset from media such as sample buffers or still images using an
asset writer.
Media Capture and Access to Camera
Recording input from cameras and microphonesis managed by a capture session. A capture session coordinates
the flow of data from input devices to outputs such as a movie file. You can configure multiple inputs and
outputs for a single session, even when the session is running. You send messages to the session to start and
stop data flow.
In addition, you can use an instance of preview layer to show the user what a camera is recording.
Relevant Chapters: “Media Capture” (page 32)
Concurrent Programming with AV Foundation
Callouts from AV Foundation—invocations of blocks, key-value observers, or notification handlers—are not
guaranteed to be made on any particular thread or queue. Instead, AV Foundation invokes these handlers on
threads or queues on which it performs its internal tasks. You are responsible for testing whether the thread
or queue on which a handler isinvoked is appropriate for the tasks you want to perform. If it’s not (for example,
if you want to update the user interface and the callout is not on the main thread), you must redirect the
execution of your tasks to a safe thread or queue that you recognize, or that you create for the purpose.
About the AV Foundation Framework
At a Glance
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
7If you’re writing amultithreaded application, you can use the NSThreadmethod isMainThread or [[NSThread
currentThread] isEqual:<#A stored thread reference#>] to test whether the invocation thread
is a thread you expect to perform your work on. You can redirect messages to appropriate threads using
methods such as performSelectorOnMainThread:withObject:waitUntilDone: and
performSelector:onThread:withObject:waitUntilDone:modes:. You could also use
dispatch_async(3) OS X Developer Tools Manual Page to “bounce”to your blocks on an appropriate
queue, either the main queue for UI tasks or a queue you have up for concurrent operations. For more about
concurrent operations, see Concurrency Programming Guide ; for more about blocks, see Blocks Programming
Topics.
Prerequisites
AV Foundation is an advanced Cocoa framework. To use it effectively, you must have:
● A solid understanding of fundamental Cocoa development tools and techniques
● A basic grasp of blocks
● A basic understanding of key-value coding and key-value observing
● For playback, a basic understanding of Core Animation (see Core Animation Programming Guide )
About the AV Foundation Framework
Prerequisites
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
8Asset can come from a file or from media in the user’s iPod Library or Photo library. Simply creating an asset
object, though, does not necessarily mean that all the information that you might want to retrieve for that
item is immediately available. Once you have a movie asset, you can extract still images from it, transcode it
to another format, or trim the contents.
Creating an Asset Object
To create an asset to represent any resource that you can identify using a URL, you use AVURLAsset. The
simplest case is creating an asset from a file:
NSURL *url = <#A URL that identifies an audiovisual asset such as a movie file#>;
AVURLAsset *anAsset = [[AVURLAsset alloc] initWithURL:url options:nil];
Options for Initializing an Asset
AVURLAsset’s initialization methods take as their second argument an options dictionary. The only key used
in the dictionary is AVURLAssetPreferPreciseDurationAndTimingKey. The corresponding value is a
boolean (contained in an NSValue object) that indicates whether the asset should be prepared to indicate a
precise duration and provide precise random access by time.
Getting the exact duration of an asset may require significant processing overhead. Using an approximate
duration is typically a cheaper operation and sufficient for playback. Thus:
●
If you only intend to play the asset, either pass nil instead of a dictionary, or pass a dictionary that contains
the AVURLAssetPreferPreciseDurationAndTimingKey key and a corresponding value of NO
(contained in an NSValue object).
●
If you want to add the asset to a composition (AVMutableComposition), you typically need precise
randomaccess. Pass a dictionary that containsthe AVURLAssetPreferPreciseDurationAndTimingKey
key and a corresponding value of YES (contained in an NSValue object—recall that NSNumber inherits
from NSValue):
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
9
Using AssetsNSURL *url = <#A URL that identifies an audiovisual asset such as a movie
file#>;
NSDictionary *options = @{ AVURLAssetPreferPreciseDurationAndTimingKey :
@YES };
AVURLAsset *anAssetToUseInAComposition = [[AVURLAsset alloc]
initWithURL:url options:options];
Accessing the User’s Assets
To access the assets managed the iPod Library or by the Photos application, you need to get a URL of the asset
you want.
● To access the iPod Library, you create an MPMediaQuery instance to find the item you want, then get its
URL using MPMediaItemPropertyAssetURL.
For more about the Media Library, see Multimedia Programming Guide .
● To access the assets managed by the Photos application, you use ALAssetsLibrary.
The following example shows how you can get an asset to represent the first video in the Saved Photos Album.
ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
// Enumerate just the photos and videos group by using ALAssetsGroupSavedPhotos.
[library enumerateGroupsWithTypes:ALAssetsGroupSavedPhotos usingBlock:^(ALAssetsGroup
*group, BOOL *stop) {
// Within the group enumeration block, filter to enumerate just videos.
[group setAssetsFilter:[ALAssetsFilter allVideos]];
// For this example, we're only interested in the first item.
[group enumerateAssetsAtIndexes:[NSIndexSet indexSetWithIndex:0]
options:0
usingBlock:^(ALAsset *alAsset, NSUInteger index, BOOL
*innerStop) {
// The end of the enumeration is signaled by asset ==
nil.
if (alAsset) {
Using Assets
Creating an Asset Object
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
10ALAssetRepresentation *representation = [alAsset
defaultRepresentation];
NSURL *url = [representation url];
AVAsset *avAsset = [AVURLAsset URLAssetWithURL:url
options:nil];
// Do something interesting with the AV asset.
}
}];
}
failureBlock: ^(NSError *error) {
// Typically you should handle an error more gracefully than
this.
NSLog(@"No groups");
}];
Preparing an Asset for Use
Initializing an asset (or track) does not necessarily mean that all the information that you might want to retrieve
for that item is immediately available. It may require some time to calculate even the duration of an item (an
MP3 file, for example, may not contain summary information). Rather than blocking the current thread while
a value is being calculated, you should use the AVAsynchronousKeyValueLoading protocol to ask for values
and get an answer back later through a completion handler you define using a block. (AVAsset and
AVAssetTrack conform to the AVAsynchronousKeyValueLoading protocol.)
You test whether a value is loaded for a property using statusOfValueForKey:error:. When an asset is
first loaded, the value of most or all of its properties is AVKeyValueStatusUnknown. To load a value for one
or more properties, you invoke loadValuesAsynchronouslyForKeys:completionHandler:. In the
completion handler, you take whatever action is appropriate depending on the property’s status. You should
always be prepared for loading to not complete successfully, either because it failed for some reason such as
a network-based URL being inaccessible, or because the load was canceled. .
NSURL *url = <#A URL that identifies an audiovisual asset such as a movie file#>;
AVURLAsset *anAsset = [[AVURLAsset alloc] initWithURL:url options:nil];
NSArray *keys = @[@"duration"];
[asset loadValuesAsynchronouslyForKeys:keys completionHandler:^() {
Using Assets
Preparing an Asset for Use
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
11NSError *error = nil;
AVKeyValueStatus tracksStatus = [asset statusOfValueForKey:@"duration"
error:&error];
switch (tracksStatus) {
case AVKeyValueStatusLoaded:
[self updateUserInterfaceForDuration];
break;
case AVKeyValueStatusFailed:
[self reportError:error forAsset:asset];
break;
case AVKeyValueStatusCancelled:
// Do whatever is appropriate for cancelation.
break;
}
}];
If you want to prepare an asset for playback, you should load its tracks property. For more about playing
assets, see “Playback” (page 18).
Getting Still Images From a Video
To get still images such as thumbnails from an asset for playback, you use an AVAssetImageGenerator
object. You initialize an image generator with your asset. Initialization may succeed, though, even if the asset
possesses no visual tracks at the time of initialization, so if necessary you should test whether the asset has
any tracks with the visual characteristic using tracksWithMediaCharacteristic:.
AVAsset anAsset = <#Get an asset#>;
if ([anAsset tracksWithMediaCharacteristic:AVMediaTypeVideo]) {
AVAssetImageGenerator *imageGenerator =
[AVAssetImageGenerator assetImageGeneratorWithAsset:anAsset];
// Implementation continues...
Using Assets
Getting Still Images From a Video
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
12You can configure several aspects of the image generator, for example, you can specify the maximum dimensions
for the images it generates and the aperture mode using maximumSize and apertureMode respectively.You
can then generate a single image at a given time, or a series of images. You must ensure that you keep a strong
reference to the image generator until it has generated all the images.
Generating a Single Image
You use copyCGImageAtTime:actualTime:error: to generate a single image at a specific time. AV
Foundation may not be able to produce an image at exactly the time you request, so you can pass as the
second argument a pointer to a CMTime that upon return contains the time at which the image was actually
generated.
AVAsset *myAsset = <#An asset#>];
AVAssetImageGenerator *imageGenerator = [[AVAssetImageGenerator alloc]
initWithAsset:myAsset];
Float64 durationSeconds = CMTimeGetSeconds([myAsset duration]);
CMTime midpoint = CMTimeMakeWithSeconds(durationSeconds/2.0, 600);
NSError *error;
CMTime actualTime;
CGImageRef halfWayImage = [imageGenerator copyCGImageAtTime:midpoint
actualTime:&actualTime error:&error];
if (halfWayImage != NULL) {
NSString *actualTimeString = (NSString *)CMTimeCopyDescription(NULL, actualTime);
NSString *requestedTimeString = (NSString *)CMTimeCopyDescription(NULL,
midpoint);
NSLog(@"Got halfWayImage: Asked for %@, got %@", requestedTimeString,
actualTimeString);
// Do something interesting with the image.
CGImageRelease(halfWayImage);
}
Using Assets
Getting Still Images From a Video
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
13Generating a Sequence of Images
To generate a series of images, you send the image generator a
generateCGImagesAsynchronouslyForTimes:completionHandler:message. The first argument is an
array of NSValue objects, each containing a CMTime, specifying the asset times for which you want images
to be generated. The second argument is a block that serves as a callback invoked for each image that is
generated. The block arguments provide a result constant that tells you whether the image was created
successfully or if the operation was canceled, and, as appropriate:
● The image.
● The time for which you requested the image and the actual time for which the image was generated.
● An error object that describes the reason generation failed.
In your implementation of the block, you should check the result constant to determine whether the image
was created. In addition, you must ensure that you keep a strong reference to the image generator until it has
finished creating the images.
AVAsset *myAsset = <#An asset#>];
// Assume: @property (strong) AVAssetImageGenerator *imageGenerator;
self.imageGenerator = [AVAssetImageGenerator assetImageGeneratorWithAsset:myAsset];
Float64 durationSeconds = CMTimeGetSeconds([myAsset duration]);
CMTime firstThird = CMTimeMakeWithSeconds(durationSeconds/3.0, 600);
CMTime secondThird = CMTimeMakeWithSeconds(durationSeconds*2.0/3.0, 600);
CMTime end = CMTimeMakeWithSeconds(durationSeconds, 600);
NSArray *times = @[NSValue valueWithCMTime:kCMTimeZero],
[NSValue valueWithCMTime:firstThird], [NSValue
valueWithCMTime:secondThird],
[NSValue valueWithCMTime:end]];
[imageGenerator generateCGImagesAsynchronouslyForTimes:times
completionHandler:^(CMTime requestedTime, CGImageRef image, CMTime
actualTime,
AVAssetImageGeneratorResult result, NSError
*error) {
NSString *requestedTimeString = (NSString *)
CFBridgingRelease(CMTimeCopyDescription(NULL, requestedTime));
Using Assets
Getting Still Images From a Video
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
14NSString *actualTimeString = (NSString *)
CFBridgingRelease(CMTimeCopyDescription(NULL, actualTime));
NSLog(@"Requested: %@; actual %@", requestedTimeString,
actualTimeString);
if (result == AVAssetImageGeneratorSucceeded) {
// Do something interesting with the image.
}
if (result == AVAssetImageGeneratorFailed) {
NSLog(@"Failed with error: %@", [error localizedDescription]);
}
if (result == AVAssetImageGeneratorCancelled) {
NSLog(@"Canceled");
}
}];
You can cancel the generation of the image sequence by sending the image generator a
cancelAllCGImageGeneration message.
Trimming and Transcoding a Movie
You can transcode a movie from one format to another, and trim a movie, using an AVAssetExportSession
object. An export session is a controller object that manages asynchronous export of an asset. You initialize
the session using the asset you want to export and the name of a export preset that indicates the export
options you want to apply (see allExportPresets). You then configure the export session to specify the
output URL and file type, and optionally other settings such as the metadata and whether the output should
be optimized for network use.
Asset
Export preset
AVAssetExportSession
URL
You can check whether you can export a given asset using a given preset using
exportPresetsCompatibleWithAsset: as illustrated in this example:
Using Assets
Trimming and Transcoding a Movie
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
15AVAsset *anAsset = <#Get an asset#>;
NSArray *compatiblePresets = [AVAssetExportSession
exportPresetsCompatibleWithAsset:anAsset];
if ([compatiblePresets containsObject:AVAssetExportPresetLowQuality]) {
AVAssetExportSession *exportSession = [[AVAssetExportSession alloc]
initWithAsset:anAsset presetName:AVAssetExportPresetLowQuality];
// Implementation continues.
}
You complete configuration of the session by providing the output URL (The URL must be a file URL.)
AVAssetExportSession can infer the output file type from the URL’s path extension; typically, however,
you set it directly using outputFileType. You can also specify additional properties such as the time range,
a limit for the output file length, whether the exported file should be optimized for network use, and a video
composition. The following example illustrates how to use the timeRange property to trim the movie:
exportSession.outputURL = <#A file URL#>;
exportSession.outputFileType = AVFileTypeQuickTimeMovie;
CMTime start = CMTimeMakeWithSeconds(1.0, 600);
CMTime duration = CMTimeMakeWithSeconds(3.0, 600);
CMTimeRange range = CMTimeRangeMake(start, duration);
exportSession.timeRange = range;
To create the new file you invoke exportAsynchronouslyWithCompletionHandler:. The completion
handler block is called when the export operation finishes; in your implementation of the handler, you should
check the session’s status to determine whether the export was successful, failed, or was canceled:
[exportSession exportAsynchronouslyWithCompletionHandler:^{
switch ([exportSession status]) {
case AVAssetExportSessionStatusFailed:
NSLog(@"Export failed: %@", [[exportSession error]
localizedDescription]);
break;
case AVAssetExportSessionStatusCancelled:
NSLog(@"Export canceled");
Using Assets
Trimming and Transcoding a Movie
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
16break;
default:
break;
}
}];
You can cancel the export by sending the session a cancelExport message.
The export will fail if you try to overwrite an existing file, or write a file outside of the application’s sandbox. It
may also fail if:
● There is an incoming phone call
● Your application is in the background and another application starts playback
In these situations, you should typically inform the user that the export failed, then allow the user to restart
the export.
Reading and Writing Assets
You use an AVAssetReader when you want to perform an operation on the contents of an asset. For example,
you might read the audio track of an asset to produce a visual representation of the waveform. To produce an
asset from media such as sample buffers or still images, you use an AVAssetWriter object.
You can use an asset reader and asset writer object in tandem to convert an asset from one representation to
another. Using these objects you have more control over the conversion than you do with AVExportSession.
For example of you want to choose which of the tracks you want to be represented in the output file, specify
your own output format, or modify the asset during the conversion process.
Using Assets
Reading and Writing Assets
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
17To control the playback of assets, you use an AVPlayer object. During playback, you can use an AVPlayerItem
object to manage the presentation state of an asset as a whole, and an AVPlayerItemTrack to manage the
presentation state of an individual track. To display video, you use an AVPlayerLayer object.
Playing Assets
A player is a controller object that you use to manage playback of an asset, for example starting and stopping
playback, and seeking to a particular time. You use an instance of AVPlayer to play a single asset. On iOS 4.1
and later, you can use an AVQueuePlayer object to play a number of items in sequence (AVQueuePlayer is
a subclass of AVPlayer).
A player provides you with information about the state of the playback so, if you need to, you can synchronize
your user interface with the player’s state. You typically direct the output of a player to specialized Core
Animation Layer (an instance of AVPlayerLayer or AVSynchronizedLayer). To learn more about layers,
see Core Animation Programming Guide .
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
18
PlaybackMultiple player layers: You can create arbitrarily many AVPlayerLayer objects from a single
AVPlayer instance, but only the most-recently-created such layer will display any video content
on-screen.
Although ultimately you want to play an asset, you don’t provide assets directly to an AVPlayer object. Instead,
you provide an instance of AVPlayerItem. A player item manages the presentation state of an asset with
which it is associated. A player item contains player item tracks—instances of AVPlayerItemTrack—that
correspond to the tracks in the asset.
AVAsset
AVAssetTrack
AVAssetTrack
AVPlayerItem
AVPlayerItemTrack AVPlayer AVPlayerLayer
AVPlayerItemTrack
This abstraction means that you can play a given asset using different players simultaneously, but rendered
in different ways by each player. Using the item tracks, you can, for example, disable a particular track during
playback (you might not want to play the sound component).
AVAsset
AVPlayer 1 AVPlayer 2
• Video
• Audio R
• Audio L
AVPlayerItem 1 AVPlayerItem 2
AVPlayerItemTracks
time = 4:15 time = 2:10
Video
Audio R
Audio L
Off
Off
Playback
Playing Assets
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
19You can initialize a player item with an existing asset, or you can initialize a player item directly from a URL so
that you can play a resource at a particular location (AVPlayerItem will then create and configure an asset
for the resource). As with AVAsset, though, simply initializing a player item doesn’t necessarily mean it’s ready
for immediate playback. You can observe (using key-value observing) an item’s status property to determine
if and when it’s ready to play.
Handling Different Types of Asset
The way you configure an asset for playback may depend on the sort of asset you want to play. Broadly speaking,
there are two main types: file-based assets, to which you have random access (such as from a local file, the
camera roll, or the Media Library), and stream-based (HTTP Live Stream format).
To load and play a file-based asset. There are several steps to playing a file-based asset:
● Create an asset using AVURLAsset and load its tracks using
loadValuesAsynchronouslyForKeys:completionHandler:.
● When the asset has loaded its tracks, create an instance of AVPlayerItem using the asset.
● Associate the item with an instance of AVPlayer.
● Wait until the item’s status indicatesthat it’sready to play (typically you use key-value observing to receive
a notification when the status changes).
This approach is illustrated in “Putting it all Together: Playing a Video File Using AVPlayerLayer” (page 26).
To create and prepare an HTTP live stream for playback. Initialize an instance of AVPlayerItem using the
URL. (You cannot directly create an AVAsset instance to represent the media in an HTTP Live Stream.)
NSURL *url = [NSURL URLWithString:@"<#Live stream URL#>];
// You may find a test stream at
.
self.playerItem = [AVPlayerItem playerItemWithURL:url];
[playerItem addObserver:self forKeyPath:@"status" options:0
context:&ItemStatusContext];
self.player = [AVPlayer playerWithPlayerItem:playerItem];
When you associate the player item with a player, it starts to become ready to play. When it is ready to play,
the player item createsthe AVAsset and AVAssetTrack instances, which you can use to inspect the contents
of the live stream.
Playback
Handling Different Types of Asset
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
20If you simply want to play a live stream, you can take a shortcut and create a player directly using the URL:
self.player = [AVPlayer playerWithURL:<#Live stream URL#>];
[player addObserver:self forKeyPath:@"status" options:0
context:&PlayerStatusContext];
As with assets and items, initializing the player does not mean it’s ready for playback. You should observe the
player’s status property, which changes to AVPlayerStatusReadyToPlay when it is ready to play. You
can also observe the currentItem property to access the player item created for the stream.
If you don’t know what kind of URL you have. Follow these steps:
1. Try to initialize an AVURLAsset using the URL, then load its tracks key.
If the tracks load successfully, then you create a player item for the asset.
2. If 1 fails, create an AVPlayerItem directly from the URL.
Observe the player’s status property to determine whether it becomes playable.
If either route succeeds, you end up with a player item that you can then associate with a player.
Playing an Item
To start playback, you send a play message to the player.
- (IBAction)play:sender {
[player play];
}
In addition to simply playing, you can manage various aspects of the playback,such asthe rate and the location
of the playhead. You can also monitor the play state of the player; this is useful if you want to, for example,
synchronize the user interface to the presentation state of the asset—see “Monitoring Playback” (page 23).
Changing the Playback Rate
You change the rate of playback by setting the player’s rate property.
aPlayer.rate = 0.5;
aPlayer.rate = 2.0;
Playback
Playing an Item
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
21A value of 1.0 means “play at the natural rate of the current item”. Setting the rate to 0.0 is the same as pausing
playback—you can also use pause.
Seeking—Repositioning the Playhead
To move the playhead to a particular time, you generally use seekToTime:.
CMTime fiveSecondsIn = CMTimeMake(5, 1);
[player seekToTime:fiveSecondsIn];
The seekToTime: method, however, is tuned for performance rather than precision. If you need to move the
playhead precisely, instead you use seekToTime:toleranceBefore:toleranceAfter:.
CMTime fiveSecondsIn = CMTimeMake(5, 1);
[player seekToTime:fiveSecondsIn toleranceBefore:kCMTimeZero
toleranceAfter:kCMTimeZero];
Using a tolerance of zero may require the framework to decode a large amount of data. You should only use
zero if you are, for example, writing a sophisticated media editing application that requires precise control.
After playback, the player’s head is set to the end of the item, and further invocations of play have no effect.
To position the play head back at the beginning of the item, you can register to receive an
AVPlayerItemDidPlayToEndTimeNotification from the item. In the notification’s callback method, you
invoke seekToTime: with the argument kCMTimeZero.
// Register with the notification center after creating the player item.
[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(playerItemDidReachEnd:)
name:AVPlayerItemDidPlayToEndTimeNotification
object:<#The player item#>];
- (void)playerItemDidReachEnd:(NSNotification *)notification {
[player seekToTime:kCMTimeZero];
}
Playback
Playing an Item
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
22Playing Multiple Items
On iOS 4.1 and later, you can use an AVQueuePlayer object to play a number of items in sequence.
AVQueuePlayer is a subclass of AVPlayer. You initialize a queue player with an array of player items:
NSArray *items = <#An array of player items#>;
AVQueuePlayer *queuePlayer = [[AVQueuePlayer alloc] initWithItems:items];
You can then play the queue using play, just as you would an AVPlayer object. The queue player plays each
item in turn. If you want to skip to the next item, you send the queue player an advanceToNextItem message.
You can modify the queue using insertItem:afterItem:, removeItem:, and removeAllItems. When
adding a new item, you should typically check whether it can be inserted into the queue, using
canInsertItem:afterItem:. You pass nil as the second argument to test whether the new item can be
appended to the queue:
AVPlayerItem *anItem = <#Get a player item#>;
if ([queuePlayer canInsertItem:anItem afterItem:nil]) {
[queuePlayer insertItem:anItem afterItem:nil];
}
Monitoring Playback
You can monitor a number of aspects of the presentation state of a player and the player item being played.
This is particularly useful for state changes that are not under your direct control, for example:
●
If the user uses multitasking to switch to a different application, a player’s rate property will drop to 0.0.
●
If you are playing remotemedia, a playeritem’s loadedTimeRanges and seekableTimeRanges properties
will change as more data becomes available.
These properties tell you what portions of the player item’s timeline are available.
● A player’s currentItem property changes as a player item is created for an HTTP live stream.
● A player item’s tracks property may change while playing an HTTP live stream.
This may happen if the stream offers different encodings for the content; the tracks change if the player
switches to a different encoding.
● A player or player item’s status may change if playback fails for some reason.
You can use key-value observing to monitor changes to values of these properties.
Playback
Playing Multiple Items
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
23Important: You should register for KVO change notifications and unregister from KVO change notifications
on the main thread. This avoids the possibility of receiving a partial notification if a change is being made
on another thread. AV Foundation invokes observeValueForKeyPath:ofObject:change:context:
on the main thread, even if the change operation is made on another thread.
Responding to a Change in Status
When a player or player item’s status changes, it emits a key-value observing change notification. If an object
is unable to play for some reason (for example, if the media services are reset), the status changes to
AVPlayerStatusFailed or AVPlayerItemStatusFailed as appropriate. In thissituation, the value of the
object’s error property is changed to an error object that describes why the object is no longer be able to
play.
AV Foundation does not specify what thread that the notification is sent on. If you want to update the user
interface, you must make sure that any relevant code is invoked on the main thread. This example uses
dispatch_async(3) OS X Developer Tools Manual Page to execute code on the main thread.
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
change:(NSDictionary *)change context:(void *)context {
if (context == <#Player status context#>) {
AVPlayer *thePlayer = (AVPlayer *)object;
if ([thePlayer status] == AVPlayerStatusFailed) {
NSError *error = [<#The AVPlayer object#> error];
// Respond to error: for example, display an alert sheet.
return;
}
// Deal with other status change if appropriate.
}
// Deal with other change notifications if appropriate.
[super observeValueForKeyPath:keyPath ofObject:object
change:change context:context];
return;
}
Playback
Monitoring Playback
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
24Tracking Readiness for Visual Display
You can observe an AVPlayerLayer object’s readyForDisplay property to be notified when the layer has
user-visible content. In particular, you might insert the player layer into the layer tree only when there is
something for the user to look at, and perform a transition from
Tracking Time
To track changes in the position of the playhead in an AVPlayer object, you can use
addPeriodicTimeObserverForInterval:queue:usingBlock: or
addBoundaryTimeObserverForTimes:queue:usingBlock:. You might do this to, for example, update
your user interface with information about time elapsed or time remaining, or perform some other user interface
synchronization.
● With addPeriodicTimeObserverForInterval:queue:usingBlock:,the block you provide isinvoked
at the interval you specify, and if time jumps, and when playback starts or stops.
● With addBoundaryTimeObserverForTimes:queue:usingBlock:, you pass an array of CMTimes
contained in NSValue objects. The block you provide is invoked whenever any of those times is traversed.
Both of the methods return an opaque object that serves as an observer. You must keep a strong reference to
the returned object as long as you want the time observation block to be invoked by the player. You must also
balance each invocation of these methods with a corresponding call to removeTimeObserver:.
With both of these methods, AV Foundation does not guarantee to invoke your block for every interval or
boundary passed. AV Foundation does not invoke a block if execution of a previously-invoked block has not
completed. You must make sure, therefore, that the work you perform in the block does not overly tax the
system.
// Assume a property: @property (strong) id playerObserver;
Float64 durationSeconds = CMTimeGetSeconds([<#An asset#> duration]);
CMTime firstThird = CMTimeMakeWithSeconds(durationSeconds/3.0, 1);
CMTime secondThird = CMTimeMakeWithSeconds(durationSeconds*2.0/3.0, 1);
NSArray *times = @[[NSValue valueWithCMTime:firstThird], [NSValue
valueWithCMTime:secondThird]];
self.playerObserver = [<#A player#> addBoundaryTimeObserverForTimes:times queue:NULL
usingBlock:^{
NSString *timeDescription = (NSString *)
Playback
Monitoring Playback
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
25CFBridgingRelease(CMTimeCopyDescription(NULL, [self.player currentTime]));
NSLog(@"Passed a boundary at %@", timeDescription);
}];
Reaching the End of an Item
You can register to receive an AVPlayerItemDidPlayToEndTimeNotification notification when a player
item has completed playback:
[[NSNotificationCenter defaultCenter] addObserver:<#The observer, typically self#>
selector:@selector(<#The selector name#>)
name:AVPlayerItemDidPlayToEndTimeNotification
object:<#A player item#>];
Putting it all Together: Playing a Video File Using AVPlayerLayer
This brief code example to illustrates how you can use an AVPlayer object to play a video file. It shows how
to:
● Configure a view to use an AVPlayerLayer layer
● Create an AVPlayer object
● Create an AVPlayerItem object for a file-based asset, and use key-value observing to observe its status
● Respond to the item becoming ready to play by enabling a button
● Play the item, then restore the player’s head to the beginning.
Note: To focus on the most relevant code, this example omits several aspects of a complete
application,such as memory management, and unregistering as an observer (for key-value observing
or for the notification center). To use AV Foundation, you are expected to have enough experience
with Cocoa to be able to infer the missing pieces.
For a conceptual introduction to playback, skip to “Playing Assets” (page 18).
Playback
Putting it all Together: Playing a Video File Using AVPlayerLayer
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
26The Player View
To play the visual component of an asset, you need a view containing an AVPlayerLayer layer to which the
output of an AVPlayer object can be directed. You can create a simple subclass of UIView to accommodate
this:
#import
#import
@interface PlayerView : UIView
@property (nonatomic) AVPlayer *player;
@end
@implementation PlayerView
+ (Class)layerClass {
return [AVPlayerLayer class];
}
- (AVPlayer*)player {
return [(AVPlayerLayer *)[self layer] player];
}
- (void)setPlayer:(AVPlayer *)player {
[(AVPlayerLayer *)[self layer] setPlayer:player];
}
@end
A Simple View Controller
Assume you have a simple view controller, declared as follows:
@class PlayerView;
@interface PlayerViewController : UIViewController
@property (nonatomic) AVPlayer *player;
@property (nonatomic) AVPlayerItem *playerItem;
@property (nonatomic, weak) IBOutlet PlayerView *playerView;
@property (nonatomic, weak) IBOutlet UIButton *playButton;
- (IBAction)loadAssetFromFile:sender;
Playback
Putting it all Together: Playing a Video File Using AVPlayerLayer
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
27- (IBAction)play:sender;
- (void)syncUI;
@end
The syncUI method synchronizes the button’s state with the player’s state:
- (void)syncUI {
if ((self.player.currentItem != nil) &&
([self.player.currentItem status] == AVPlayerItemStatusReadyToPlay)) {
self.playButton.enabled = YES;
}
else {
self.playButton.enabled = NO;
}
}
You can invoke syncUI in the view controller’s viewDidLoad method to ensure a consistent user interface
when the view is first displayed.
- (void)viewDidLoad {
[super viewDidLoad];
[self syncUI];
}
The other properties and methods are described in the remaining sections.
Creating the Asset
You create an asset from a URL using AVURLAsset. Creating the asset, however, does not necessarily mean
that it’s ready for use. To be used, an asset must have loaded its tracks. To avoid blocking the current thread,
you load the asset’s tracks asynchronously using
loadValuesAsynchronouslyForKeys:completionHandler:. (The following example assumes your
project contains a suitable video resource.)
- (IBAction)loadAssetFromFile:sender {
Playback
Putting it all Together: Playing a Video File Using AVPlayerLayer
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
28NSURL *fileURL = [[NSBundle mainBundle]
URLForResource:<#@"VideoFileName"#> withExtension:<#@"extension"#>];
AVURLAsset *asset = [AVURLAsset URLAssetWithURL:fileURL options:nil];
NSString *tracksKey = @"tracks";
[asset loadValuesAsynchronouslyForKeys:@[tracksKey] completionHandler:
^{
// The completion block goes here.
}];
}
In the completion block, you create an instance of AVPlayerItem for the asset, and set it as the player for
the player view. As with creating the asset, simply creating the player item does not mean it’s ready to use. To
determine when it’s ready to play, you can observe the item’s status. You trigger its preparation to play when
you associate it with the player.
// Define this constant for the key-value observation context.
static const NSString *ItemStatusContext;
// Completion handler block.
dispatch_async(dispatch_get_main_queue(),
^{
NSError *error;
AVKeyValueStatus status = [asset statusOfValueForKey:tracksKey
error:&error];
if (status == AVKeyValueStatusLoaded) {
self.playerItem = [AVPlayerItem playerItemWithAsset:asset];
[self.playerItem addObserver:self forKeyPath:@"status"
options:0 context:&ItemStatusContext];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(playerItemDidReachEnd:)
name:AVPlayerItemDidPlayToEndTimeNotification
Playback
Putting it all Together: Playing a Video File Using AVPlayerLayer
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
29object:self.playerItem];
self.player = [AVPlayer playerWithPlayerItem:self.playerItem];
[self.playerView setPlayer:self.player];
}
else {
// You should deal with the error appropriately.
NSLog(@"The asset's tracks were not loaded:\n%@", [error
localizedDescription]);
}
});
Responding to the Player Item’s Status Change
When the player item’s status changes, the view controller receives a key-value observing change notification.
AV Foundation does not specify what thread that the notification is sent on. If you want to update the user
interface, you must make sure that any relevant code is invoked on the main thread. This example uses
dispatch_async(3) OS X Developer Tools Manual Page to queue a message on the main thread
to synchronize the user interface.
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
change:(NSDictionary *)change context:(void *)context {
if (context == &ItemStatusContext) {
dispatch_async(dispatch_get_main_queue(),
^{
[self syncUI];
});
return;
}
[super observeValueForKeyPath:keyPath ofObject:object
change:change context:context];
return;
}
Playback
Putting it all Together: Playing a Video File Using AVPlayerLayer
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
30Playing the Item
Playing the item is trivial: you send a play message to the player.
- (IBAction)play:sender {
[player play];
}
This only playsthe item once, though. After playback, the player’s head isset to the end of the item, and further
invocations of play will have no effect. To position the play head back at the beginning of the item, you can
register to receive an AVPlayerItemDidPlayToEndTimeNotification from the item. In the notification’s
callback method, invoke seekToTime: with the argument kCMTimeZero.
// Register with the notification center after creating the player item.
[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(playerItemDidReachEnd:)
name:AVPlayerItemDidPlayToEndTimeNotification
object:[self.player currentItem]];
- (void)playerItemDidReachEnd:(NSNotification *)notification {
[self.player seekToTime:kCMTimeZero];
}
Playback
Putting it all Together: Playing a Video File Using AVPlayerLayer
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
31To manage the capture from a device such as a camera or microphone, you assemble objects to represent
inputs and outputs, and use an instance of AVCaptureSession to coordinate the data flow between them.
Minimally you need:
● An instance of AVCaptureDevice to represent the input device, such as a camera or microphone
● An instance of a concrete subclass of AVCaptureInput to configure the ports from the input device
● An instance of a concrete subclass of AVCaptureOutput to manage the output to a movie file or still
image
● An instance of AVCaptureSession to coordinate the data flow from the input to the output
To show the user what a camera is recording, you can use an instance of AVCaptureVideoPreviewLayer
(a subclass of CALayer).
You can configure multiple inputs and outputs, coordinated by a single session:
AVCapture Device Input AVCapture Device Input
AVCaptureMovieFileOutput AVCaptureStillImageOutput
AVCaptureVideoPreviewLayer
AVCapture Session Capture Session
For many applications, thisis as much detail as you need. Forsome operations, however, (if you want to monitor
the power levels in an audio channel, for example) you need to consider how the various ports of an input
device are represented, how those ports are connected to the output.
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
32
Media CaptureA connection between a capture input and a capture output in a capture session is represented by an
AVCaptureConnection object. Capture inputs(instances of AVCaptureInput) have one or more input ports
(instances of AVCaptureInputPort). Capture outputs (instances of AVCaptureOutput) can accept data
from one or more sources (for example, an AVCaptureMovieFileOutput object accepts both video and
audio data).
When you add an input or an output to a session, the session “greedily” forms connections between all the
compatible capture inputs’ ports and capture outputs. A connection between a capture input and a capture
output is represented by an AVCaptureConnection object.
Capture Device Input
Capture connection Capture connection
Capture input port
(Video)
Capture input port
(Audio)
Capture Device Input
Capture input port
(Audio)
Connections
AVCaptureMovieFileOutput AVCaptureStillImageOutput
Connections
Capture Session
Capture connection
You can use a capture connection to enable or disable the flow of data from a given input or to a given output.
You can also use a connection to monitor the average and peak power levels in an audio channel.
Use a Capture Session to Coordinate Data Flow
AVCaptureSession object is the central coordinating object you use to manage data capture. You use an
instance to coordinate the flow of data from AV input devices to outputs. You add the capture devices and
outputs you want to the session, then start data flow by sending the session a startRunning message, and
stop recording by sending a stopRunning message.
AVCaptureSession *session = [[AVCaptureSession alloc] init];
// Add inputs and outputs.
[session startRunning];
Media Capture
Use a Capture Session to Coordinate Data Flow
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
33Configuring a Session
You use a preset on the session to specify the image quality and resolution you want. A preset is a constant
that identifies one of a number of possible configurations; in some cases the actual configuration is
device-specific:
Symbol Resolution Comments
Highest recording quality.
This varies per device.
AVCaptureSessionPresetHigh High
Suitable for WiFi sharing.
The actual values may change.
AVCaptureSessionPresetMedium Medium
Suitable for 3G sharing.
The actual values may change.
AVCaptureSessionPresetLow Low
AVCaptureSessionPreset640x480 640x480 VGA.
AVCaptureSessionPreset1280x720 1280x720 720p HD.
Full photo resolution.
This is not supported for video output.
AVCaptureSessionPresetPhoto Photo
For examples of the actual valuesthese presetsrepresent for various devices,see “Saving to a Movie File” (page
43) and “Capturing Still Images” (page 47).
If you want to set a size-specific configuration, you should check whether it is supported before setting it:
if ([session canSetSessionPreset:AVCaptureSessionPreset1280x720]) {
session.sessionPreset = AVCaptureSessionPreset1280x720;
}
else {
// Handle the failure.
}
In many situations, you create a session and the various inputs and outputs all at once. Sometimes, however,
you may want to reconfigure a running session, perhaps as different input devices become available, or in
response to user request. This can present a challenge, since, if you change them one at a time, a new setting
may be incompatible with an existing setting. To deal with this, you use beginConfiguration and
commitConfiguration to batch multiple configuration operations into an atomic update. After calling
Media Capture
Use a Capture Session to Coordinate Data Flow
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
34beginConfiguration, you can for example add or remove outputs, alter the sessionPreset, or configure
individual capture input or output properties. No changes are actually made until you invoke
commitConfiguration, at which time they are applied together.
[session beginConfiguration];
// Remove an existing capture device.
// Add a new capture device.
// Reset the preset.
[session commitConfiguration];
Monitoring Capture Session State
A capture session posts notifications that you can observe to be notified, for example, when it starts or stops
running, or when it is interrupted. You can also register to receive an
AVCaptureSessionRuntimeErrorNotification if a runtime error occurs. You can also interrogate the
session’s running property to find out if it is running, and its interrupted property to find out if it is
interrupted.
An AVCaptureDevice Object Represents an Input Device
An AVCaptureDevice object abstracts a physical capture device that provides input data (such as audio or
video) to an AVCaptureSession object. There is one object for each input device, so for example on an
iPhone 3GS there is one video input for the camera and one audio input for the microphone; on an iPhone 4
there are two video inputs—one for front-facing the camera, one for the back-facing camera—and one audio
input for the microphone.
You can find out what capture devices are currently available using the AVCaptureDevice class methods
devices and devicesWithMediaType:, and if necessary find out what featuresthe devices offer (see “Device
Capture Settings” (page 36)). The list of available devices may change, though. Current devices may become
unavailable (if they’re used by another application), and new devices may become available, (if they’re
relinquished by another application). You should register to receive
AVCaptureDeviceWasConnectedNotification and
AVCaptureDeviceWasDisconnectedNotificationnotifications to be alerted when the list of available
devices changes.
You add a device to a capture session using a capture input (see “Use Capture Inputs to Add a Capture Device
to a Session” (page 41)).
Media Capture
An AVCaptureDevice Object Represents an Input Device
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
35Device Characteristics
You can ask a device about several different characteristics. You can test whether it provides a particular media
type or supports a given capture session preset using hasMediaType: and
supportsAVCaptureSessionPreset: respectively. To provide information to the user, you can find out
the position of the capture device (whether it is on the front or the back of the unit they’re using), and its
localized name. This may be useful if you want to present a list of capture devices to allow the user to choose
one.
The following code example iterates over all the available devices and logs their name, and for video devices
their position on the unit.
NSArray *devices = [AVCaptureDevice devices];
for (AVCaptureDevice *device in devices) {
NSLog(@"Device name: %@", [device localizedName]);
if ([device hasMediaType:AVMediaTypeVideo]) {
if ([device position] == AVCaptureDevicePositionBack) {
NSLog(@"Device position : back");
}
else {
NSLog(@"Device position : front");
}
}
}
In addition, you can find out the device’s model ID and its unique ID.
Device Capture Settings
Different devices have different capabilities; for example, some may support different focus or flash modes;
some may support focus on a point of interest.
Feature iPhone 3G iPhone 3GS iPhone 4 (Back) iPhone 4 (Front)
Focus mode NO YES YES NO
Media Capture
An AVCaptureDevice Object Represents an Input Device
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
36Feature iPhone 3G iPhone 3GS iPhone 4 (Back) iPhone 4 (Front)
Focus point of interest NO YES YES NO
Exposure mode YES YES YES YES
Exposure point of interest NO YES YES YES
White balance mode YES YES YES YES
Flash mode NO NO YES NO
Torch mode NO NO YES NO
The following code fragment shows how you can find video input devices that have a torch mode and support
a given capture session preset:
NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
NSMutableArray *torchDevices = [[NSMutableArray alloc] init];
for (AVCaptureDevice *device in devices) {
[if ([device hasTorch] &&
[device supportsAVCaptureSessionPreset:AVCaptureSessionPreset640x480]) {
[torchDevices addObject:device];
}
}
If you find multiple devices that meet your criteria, you might let the user choose which one they want to use.
To display a description of a device to the user, you can use its localizedName property.
You use the various different features in similar ways. There are constants to specify a particular mode, and
you can ask a device whether it supports a particular mode. In several cases you can observe a property to be
notified when a feature is changing. In all cases, you should lock the device before changing the mode of a
particular feature, as described in “Configuring a Device” (page 40).
Note: Focus point of interest and exposure point of interest are mutually exclusive, as are focus
mode and exposure mode.
Focus modes
There are three focus modes:
Media Capture
An AVCaptureDevice Object Represents an Input Device
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
37● AVCaptureFocusModeLocked: the focal length is fixed.
This is useful when you want to allow the user to compose a scene then lock the focus.
● AVCaptureFocusModeAutoFocus: the camera does a single scan focus then reverts to locked.
This is suitable for a situation where you want to select a particular item on which to focus and then
maintain focus on that item even if it is not the center of the scene.
● AVCaptureFocusModeContinuousAutoFocus: the camera continuously auto-focuses as needed.
You use the isFocusModeSupported: method to determine whether a device supports a given focus mode,
then set the mode using the focusMode property.
In addition, a device may support a focus point of interest. You test for support using
focusPointOfInterestSupported. If it’ssupported, you set the focal point using focusPointOfInterest.
You pass a CGPoint where {0,0} representsthe top left of the picture area, and {1,1} representsthe bottom
right in landscape mode with the home button on the right—this applies even if the device is in portrait mode.
You can use the adjustingFocus property to determine whether a device is currently focusing. You can
observe the property using key-value observing to be notified when a device starts and stops focusing.
If you change the focus mode settings, you can return them to the default configuration as follows:
if ([currentDevice isFocusModeSupported:AVCaptureFocusModeContinuousAutoFocus]) {
CGPoint autofocusPoint = CGPointMake(0.5f, 0.5f);
[currentDevice setFocusPointOfInterest:autofocusPoint];
[currentDevice setFocusMode:AVCaptureFocusModeContinuousAutoFocus];
}
Exposure modes
There are two exposure modes:
● AVCaptureExposureModeLocked: the exposure mode is fixed.
● AVCaptureExposureModeAutoExpose: the camera continuously changesthe exposure level as needed.
You use the isExposureModeSupported: method to determine whether a device supports a given exposure
mode, then set the mode using the exposureMode property.
Media Capture
An AVCaptureDevice Object Represents an Input Device
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
38In addition, a device may support an exposure point of interest. You test for support using
exposurePointOfInterestSupported. If it’s supported, you set the exposure point using
exposurePointOfInterest. You pass a CGPoint where {0,0} represents the top left of the picture area,
and {1,1} represents the bottom right in landscape mode with the home button on the right—this applies
even if the device is in portrait mode.
You can use the adjustingExposure property to determine whether a device is currently changing its
exposure setting. You can observe the property using key-value observing to be notified when a device starts
and stops changing its exposure setting.
If you change the exposure settings, you can return them to the default configuration as follows:
if ([currentDevice
isExposureModeSupported:AVCaptureExposureModeContinuousAutoExposure]) {
CGPoint exposurePoint = CGPointMake(0.5f, 0.5f);
[currentDevice setExposurePointOfInterest:exposurePoint];
[currentDevice setExposureMode:AVCaptureExposureModeContinuousAutoExposure];
}
Flash modes
There are three flash modes:
● AVCaptureFlashModeOff: the flash will never fire.
● AVCaptureFlashModeOn: the flash will always fire.
● AVCaptureFlashModeAuto: the flash will fire if needed.
You use hasFlash to determine whether a device has a flash. You use the isFlashModeSupported: method
to determine whether a device supports a given flash mode, then set the mode using the flashMode property.
Torch mode
Torch mode is where a camera uses the flash continuously at a low power to illuminate a video capture. There
are three torch modes:
● AVCaptureTorchModeOff: the torch is always off.
● AVCaptureTorchModeOn: the torch is always on.
● AVCaptureTorchModeAuto: the torch is switched on and off as needed.
Media Capture
An AVCaptureDevice Object Represents an Input Device
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
39You use hasTorch to determine whether a device has a flash. You use the isTorchModeSupported: method
to determine whether a device supports a given flash mode, then set the mode using the torchMode property.
For devices with a torch, the torch only turns on if the device is associated with a running capture session.
White balance
There are two white balance modes:
● AVCaptureWhiteBalanceModeLocked: the white balance mode is fixed.
● AVCaptureWhiteBalanceModeContinuousAutoWhiteBalance: the camera continuously changes
the white balance as needed.
You use the isWhiteBalanceModeSupported: method to determine whether a device supports a given
white balance mode, then set the mode using the whiteBalanceMode property.
You can use the adjustingWhiteBalance property to determine whether a device is currently changing its
white balance setting. You can observe the property using key-value observing to be notified when a device
starts and stops changing its white balance setting.
Configuring a Device
To set capture properties on a device, you must first acquire a lock on the device using
lockForConfiguration:. This avoids making changes that may be incompatible with settings in other
applications. The following code fragment illustrates how to approach changing the focus mode on a device
by first determining whether the mode is supported, then attempting to lock the device for reconfiguration.
The focus mode is changed only if the lock is obtained, and the lock is released immediately afterward.
if ([device isFocusModeSupported:AVCaptureFocusModeLocked]) {
NSError *error = nil;
if ([device lockForConfiguration:&error]) {
device.focusMode = AVCaptureFocusModeLocked;
[device unlockForConfiguration];
}
else {
// Respond to the failure as appropriate.
You should only hold the device lock if you need settable device properties to remain unchanged. Holding
the device lock unnecessarily may degrade capture quality in other applications sharing the device.
Media Capture
An AVCaptureDevice Object Represents an Input Device
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
40Switching Between Devices
Sometimes you may want to allow the user to switch between input devices—for example, on an iPhone 4
they could switch from using the front to the back camera. To avoid pauses or stuttering, you can reconfigure
a session while it is running, however you should use beginConfiguration and commitConfiguration
to bracket your configuration changes:
AVCaptureSession *session = <#A capture session#>;
[session beginConfiguration];
[session removeInput:frontFacingCameraDeviceInput];
[session addInput:backFacingCameraDeviceInput];
[session commitConfiguration];
When the outermost commitConfiguration is invoked, all the changes are made together. This ensures a
smooth transition.
Use Capture Inputs to Add a Capture Device to a Session
To add a capture device to a capture session, you use an instance of AVCaptureDeviceInput (a concrete
subclass of the abstract AVCaptureInput class). The capture device input manages the device’s ports.
NSError *error;
AVCaptureDeviceInput *input =
[AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
if (!input) {
// Handle the error appropriately.
}
You add inputs to a session using addInput:. If appropriate, you can check whether a capture input is
compatible with an existing session using canAddInput:.
AVCaptureSession *captureSession = <#Get a capture session#>;
AVCaptureDeviceInput *captureDeviceInput = <#Get a capture device input#>;
if ([captureSession canAddInput:captureDeviceInput]) {
[captureSession addInput:captureDeviceInput];
Media Capture
Use Capture Inputs to Add a Capture Device to a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
41}
else {
// Handle the failure.
}
See “Configuring a Session” (page 34) for more details on how you might reconfigure a running session.
An AVCaptureInput vends one or more streams of media data. For example, input devices can provide both
audio and video data. Each media stream provided by an input is represented by an AVCaptureInputPort
object. A capture session uses an AVCaptureConnection object to define the mapping between a set of
AVCaptureInputPort objects and a single AVCaptureOutput.
Use Capture Outputs to Get Output from a Session
To get output from a capture session, you add one or more outputs. An output is an instance of a concrete
subclass of AVCaptureOutput; you use:
● AVCaptureMovieFileOutput to output to a movie file
● AVCaptureVideoDataOutput if you want to process frames from the video being captured
● AVCaptureAudioDataOutput if you want to process the audio data being captured
● AVCaptureStillImageOutput if you want to capture still images with accompanying metadata
You add outputs to a capture session using addOutput:. You check whether a capture output is compatible
with an existing session using canAddOutput:. You can add and remove outputs as you want while the
session is running.
AVCaptureSession *captureSession = <#Get a capture session#>;
AVCaptureMovieFileOutput *movieInput = <#Create and configure a movie output#>;
if ([captureSession canAddOutput:movieInput]) {
[captureSession addOutput:movieInput];
}
else {
// Handle the failure.
}
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
42Saving to a Movie File
You save movie data to a file using an AVCaptureMovieFileOutput object. (AVCaptureMovieFileOutput
is a concrete subclass of AVCaptureFileOutput, which defines much of the basic behavior.) You can configure
various aspects of the movie file output, such as the maximum duration of the recording, or the maximum file
size. You can also prohibit recording if there is less than a given amount of disk space left.
AVCaptureMovieFileOutput *aMovieFileOutput = [[AVCaptureMovieFileOutput alloc]
init];
CMTime maxDuration = <#Create a CMTime to represent the maximum duration#>;
aMovieFileOutput.maxRecordedDuration = maxDuration;
aMovieFileOutput.minFreeDiskSpaceLimit = <#An appropriate minimum given the quality
of the movie format and the duration#>;
The resolution and bit rate for the output depend on the capture session’s sessionPreset. The video encoding
is typically H.264 and audio encoding AAC. The actual values vary by device, as illustrated in the following
table.
Preset iPhone 3G iPhone 3GS iPhone 4 (Back) iPhone 4 (Front)
640x480
3.5 mbps
1280x720
10.5 mbps
640x480
3.5 mbps
No video
Apple Lossless
High
480x360
700 kbps
480x360
700 kbps
480x360
700 kbps
No video
Apple Lossless
Medium
192x144
128 kbps
192x144
128 kbps
192x144
128 kbps
No video
Apple Lossless
Low
640x480
3.5 mbps
640x480
3.5 mbps
640x480
3.5 mbps
No video
Apple Lossless
640x480
No video
64 kbps AAC
No video
64 kbps AAC
No video
64 kbps AAC
No video
Apple Lossless
1280x720
Notsupported for
video output
Notsupported for
video output
Not supported
for video output
Not supported for
video output
Photo
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
43Starting a Recording
You start recording a QuickTime movie using startRecordingToOutputFileURL:recordingDelegate:.
You need to supply a file-based URL and a delegate. The URL must not identify an existing file, as the movie
file output does not overwrite existing resources. You must also have permission to write to the specified
location. The delegate must conform to the AVCaptureFileOutputRecordingDelegate protocol, and
must implement the
captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error: method.
AVCaptureMovieFileOutput *aMovieFileOutput = <#Get a movie file output#>;
NSURL *fileURL = <#A file URL that identifies the output location#>;
[aMovieFileOutput startRecordingToOutputFileURL:fileURL recordingDelegate:<#The
delegate#>];
In the implementation of
captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error:, the delegate
might write the resulting movie to the camera roll. Itshould also check for any errorsthat might have occurred.
Ensuring the File Was Written Successfully
To determine whether the file was saved successfully, in the implementation of
captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error: you check
not only the error, but also the value of the AVErrorRecordingSuccessfullyFinishedKey in the error’s
user info dictionary:
- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL
fromConnections:(NSArray *)connections
error:(NSError *)error {
BOOL recordedSuccessfully = YES;
if ([error code] != noErr) {
// A problem occurred: Find out if the recording was successful.
id value = [[error userInfo]
objectForKey:AVErrorRecordingSuccessfullyFinishedKey];
if (value) {
recordedSuccessfully = [value boolValue];
}
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
44}
// Continue as appropriate...
You should check the value of the AVErrorRecordingSuccessfullyFinishedKey in the error’s user info
dictionary because the file might have been saved successfully, even though you got an error. The error might
indicate that one of your recording constraints wasreached, for example AVErrorMaximumDurationReached
or AVErrorMaximumFileSizeReached. Other reasons the recording might stop are:
● The disk is full—AVErrorDiskFull.
● The recording device was disconnected (for example, the microphone was removed from an iPod
touch)—AVErrorDeviceWasDisconnected.
● The session wasinterrupted (for example, a phone call wasreceived)—AVErrorSessionWasInterrupted.
Adding Metadata to a File
You can set metadata for the movie file at any time, even while recording. This is useful for situations where
the information is not available when the recording starts, as may be the case with location information.
Metadata for a file output is represented by an array of AVMetadataItem objects; you use an instance of its
mutable subclass, AVMutableMetadataItem, to create metadata of your own.
AVCaptureMovieFileOutput *aMovieFileOutput = <#Get a movie file output#>;
NSArray *existingMetadataArray = aMovieFileOutput.metadata;
NSMutableArray *newMetadataArray = nil;
if (existingMetadataArray) {
newMetadataArray = [existingMetadataArray mutableCopy];
}
else {
newMetadataArray = [[NSMutableArray alloc] init];
}
AVMutableMetadataItem *item = [[AVMutableMetadataItem alloc] init];
item.keySpace = AVMetadataKeySpaceCommon;
item.key = AVMetadataCommonKeyLocation;
CLLocation *location - <#The location to set#>;
item.value = [NSString stringWithFormat:@"%+08.4lf%+09.4lf/"
location.coordinate.latitude, location.coordinate.longitude];
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
45[newMetadataArray addObject:item];
aMovieFileOutput.metadata = newMetadataArray;
Processing Frames of Video
An AVCaptureVideoDataOutput object uses delegation to vend video frames. You set the delegate using
setSampleBufferDelegate:queue:. In addition to the delegate, you specify a serial queue on which they
delegate methods are invoked. You must use a serial queue to ensure that frames are delivered to the delegate
in the proper order. You should not pass the queue returned by dispatch_get_current_queue since there
is no guarantee as to which thread the current queue is running on. You can use the queue to modify the
priority given to delivering and processing the video frames.
The frames are presented in the delegate method,
captureOutput:didOutputSampleBuffer:fromConnection:, as instances of the CMSampleBuffer
opaque type (see “Representations of Media” (page 58)). By default, the buffers are emitted in the camera’s
most efficient format. You can use the videoSettings property to specify a custom output format. The video
settings property is a dictionary; currently, the only supported key is kCVPixelBufferPixelFormatTypeKey.
The recommended pixel format choices for iPhone 4 are
kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange or kCVPixelFormatType_32BGRA; for iPhone
3G the recommended pixel format choices are kCVPixelFormatType_422YpCbCr8 or
kCVPixelFormatType_32BGRA. Both Core Graphics and OpenGL work well with the BGRA format:
AVCaptureSession *captureSession = <#Get a capture session#>;
NSDictionary *newSettings =
@{ (NSString *)kCVPixelBufferPixelFormatTypeKey :
@(kCVPixelFormatType_32BGRA) };
captureSession.videoSettings = newSettings;
Performance Considerations for Processing Video
You should set the session output to the lowest practical resolution for your application. Setting the output
to a higher resolution than necessary wastes processing cycles and needlessly consumes power.
You must ensure that your implementation of
captureOutput:didOutputSampleBuffer:fromConnection: is able to process a sample buffer within
the amount of time allotted to a frame. If it takes too long, and you hold onto the video frames, AV Foundation
will stop delivering frames, not only to your delegate but also other outputs such as a preview layer.
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
46You can use the capture video data output’s minFrameDuration property to ensure you have enough time
to process a frame—at the cost of having a lower frame rate than would otherwise be the case. You might
also ensure that the alwaysDiscardsLateVideoFrames property is set to YES (the default). This ensures
that any late video frames are dropped rather than handed to you for processing. Alternatively, if you are
recording and it doesn’t matter if the output fames are a little late, you would prefer to get all of them, you
can set the property value to NO. This does not mean that frames will not be dropped (that is, frames may still
be dropped), but they may not be dropped as early, or as efficiently.
Capturing Still Images
You use an AVCaptureStillImageOutput output if you want to capture still images with accompanying
metadata. The resolution of the image depends on the preset for the session, as illustrated in this table:
Preset iPhone 3G iPhone 3GS iPhone 4 (Back) iPhone 4 (Front)
High 400x304 640x480 1280x720 640x480
Medium 400x304 480x360 480x360 480x360
Low 400x304 192x144 192x144 192x144
640x480 N/A 640x480 640x480 640x480
1280x720 N/A N/A 1280x720 N/A
Photo 1600x1200 2048x1536 2592x1936 640x480
Pixel and Encoding Formats
Different devices support different image formats:
iPhone 3G iPhone 3GS iPhone 4
yuvs, 2vuy, BGRA, jpeg 420f, 420v, BGRA, jpeg 420f, 420v, BGRA, jpeg
You can find out what pixel and codec types are supported using availableImageDataCVPixelFormatTypes
and availableImageDataCodecTypes respectively. You set the outputSettings dictionary to specify
the image format you want, for example:
AVCaptureStillImageOutput *stillImageOutput = [[AVCaptureStillImageOutput alloc]
init];
NSDictionary *outputSettings = @{ AVVideoCodecKey : AVVideoCodecJPEG};
[stillImageOutput setOutputSettings:outputSettings];
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
47If you want to capture a JPEG image, you should typically not specify your own compression format. Instead,
you should let the still image output do the compression for you,since its compression is hardware-accelerated.
If you need a data representation of the image, you can use jpegStillImageNSDataRepresentation: to
get an NSData object without re-compressing the data, even if you modify the image’s metadata.
Capturing an Image
When you want to capture an image, you send the output a
captureStillImageAsynchronouslyFromConnection:completionHandler: message. The first
argument is the connection you want to use for the capture. You need to look for the connection whose input
port is collecting video:
AVCaptureConnection *videoConnection = nil;
for (AVCaptureConnection *connection in stillImageOutput.connections) {
for (AVCaptureInputPort *port in [connection inputPorts]) {
if ([[port mediaType] isEqual:AVMediaTypeVideo] ) {
videoConnection = connection;
break;
}
}
if (videoConnection) { break; }
}
The second argument to captureStillImageAsynchronouslyFromConnection:completionHandler:
is a block that takes two arguments: a CMSampleBuffer containing the image data, and an error. The sample
buffer itself may contain metadata,such as an Exif dictionary, as an attachment. You can modify the attachments
should you want, but note the optimization for JPEG images discussed in “Pixel and Encoding Formats” (page
47).
[stillImageOutput captureStillImageAsynchronouslyFromConnection:videoConnection
completionHandler:
^(CMSampleBufferRef imageSampleBuffer, NSError *error) {
CFDictionaryRef exifAttachments =
CMGetAttachment(imageSampleBuffer, kCGImagePropertyExifDictionary,
NULL);
if (exifAttachments) {
// Do something with the attachments.
}
Media Capture
Use Capture Outputs to Get Output from a Session
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
48// Continue as appropriate.
}];
Showing the User What’s Being Recorded
You can provide the user with a preview of what’s being recorded by the camera using a preview layer, or by
the microphone by monitoring the audio channel.
Video Preview
You can provide the user with a preview of what’s being recorded using an AVCaptureVideoPreviewLayer
object. AVCaptureVideoPreviewLayer is a subclass ofCALayer (see Core Animation Programming Guide .
You don’t need any outputs to show the preview.
Unlike a capture output, a video preview layer maintains a strong reference to the session with which it is
associated. This is to ensure that the session is not deallocated while the layer is attempting to display video.
This is reflected in the way you initialize a preview layer:
AVCaptureSession *captureSession = <#Get a capture session#>;
CALayer *viewLayer = <#Get a layer from the view in which you want to present the
preview#>;
AVCaptureVideoPreviewLayer *captureVideoPreviewLayer = [[AVCaptureVideoPreviewLayer
alloc] initWithSession:captureSession];
[viewLayer addSublayer:captureVideoPreviewLayer];
In general, the preview layer behaves like any other CALayer object in the render tree (see Core Animation
Programming Guide ). You can scale the image and perform transformations, rotations and so on just as you
would any layer. One difference is that you may need to set the layer’s orientation property to specify how
itshould rotate images coming from the camera. In addition, on iPhone 4 the preview layersupports mirroring
(this is the default when previewing the front-facing camera).
Video Gravity Modes
The preview layer supports three gravity modes that you set using videoGravity:
● AVLayerVideoGravityResizeAspect: This preserves the aspect ratio, leaving black bars where the
video does not fill the available screen area.
Media Capture
Showing the User What’s Being Recorded
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
49● AVLayerVideoGravityResizeAspectFill: This preservesthe aspect ratio, but fillsthe available screen
area, cropping the video when necessary.
● AVLayerVideoGravityResize: This simply stretches the video to fill the available screen area, even if
doing so distorts the image.
Using “Tap to Focus” With a Preview
You need to take care when implementing tap-to-focus in conjunction with a preview layer. You must account
for the preview orientation and gravity of the layer, and the possibility that the preview may be mirrored.
Showing Audio Levels
To monitor the average and peak power levels in an audio channel in a capture connection, you use an
AVCaptureAudioChannel object. Audio levels are not key-value observable, so you must poll for updated
levels as often as you want to update your user interface (for example, 10 times a second).
AVCaptureAudioDataOutput *audioDataOutput = <#Get the audio data output#>;
NSArray *connections = audioDataOutput.connections;
if ([connections count] > 0) {
// There should be only one connection to an AVCaptureAudioDataOutput.
AVCaptureConnection *connection = [connections objectAtIndex:0];
NSArray *audioChannels = connection.audioChannels;
for (AVCaptureAudioChannel *channel in audioChannels) {
float avg = channel.averagePowerLevel;
float peak = channel.peakHoldLevel;
// Update the level meter user interface.
}
}
Putting it all Together: Capturing Video Frames as UIImage Objects
This brief code example to illustrates how you can capture video and convert the frames you get to UIImage
objects. It shows you how to:
● Create an AVCaptureSession object to coordinate the flow of data from an AV input device to an output
Media Capture
Putting it all Together: Capturing Video Frames as UIImage Objects
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
50● Find the AVCaptureDevice object for the input type you want
● Create an AVCaptureDeviceInput object for the device
● Create an AVCaptureVideoDataOutput object to produce video frames
●
Implement a delegate for the AVCaptureVideoDataOutput object to process video frames
●
Implement a function to convert the CMSampleBuffer received by the delegate into a UIImage object
Note: To focus on the most relevant code, this example omits several aspects of a complete
application, including memory management. To use AV Foundation, you are expected to have
enough experience with Cocoa to be able to infer the missing pieces.
Create and Configure a Capture Session
You use an AVCaptureSession object to coordinate the flow of data from an AV input device to an output.
Create a session, and configure it to produce medium resolution video frames.
AVCaptureSession *session = [[AVCaptureSession alloc] init];
session.sessionPreset = AVCaptureSessionPresetMedium;
Create and Configure the Device and Device Input
Capture devices are represented by AVCaptureDevice objects; the class provides methods to retrieve an
object for the input type you want. A device has one or more ports, configured using an AVCaptureInput
object. Typically, you use the capture input in its default configuration.
Find a video capture device, then create a device input with the device and add it to the session.
AVCaptureDevice *device =
[AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
NSError *error = nil;
AVCaptureDeviceInput *input =
[AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
if (!input) {
// Handle the error appropriately.
}
[session addInput:input];
Media Capture
Putting it all Together: Capturing Video Frames as UIImage Objects
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
51Create and Configure the Data Output
You use an AVCaptureVideoDataOutput object to process uncompressed frames from the video being
captured. You typically configure several aspects of an output. For video, for example, you can specify the pixel
format using the videoSettings property, and cap the frame rate by setting the minFrameDuration
property.
Create and configure an output for video data and add it to the session; cap the frame rate to 15 fps by setting
the minFrameDuration property to 1/15 second:
AVCaptureVideoDataOutput *output = [[AVCaptureVideoDataOutput alloc] init];
[session addOutput:output];
output.videoSettings =
@{ (NSString *)kCVPixelBufferPixelFormatTypeKey :
@(kCVPixelFormatType_32BGRA) };
output.minFrameDuration = CMTimeMake(1, 15);
The data output object uses delegation to vend the video frames. The delegate must adopt the
AVCaptureVideoDataOutputSampleBufferDelegate protocol. When you set the data output’s delegate,
you must also provide a queue on which callbacks should be invoked.
dispatch_queue_t queue = dispatch_queue_create("MyQueue", NULL);
[output setSampleBufferDelegate:self queue:queue];
dispatch_release(queue);
You use the queue to modify the priority given to delivering and processing the video frames.
Implement the Sample Buffer Delegate Method
In the delegate class, implement the method
(captureOutput:didOutputSampleBuffer:fromConnection:) that is called when a sample buffer is
written. The video data output object delivers frames as CMSampleBuffers, so you need to convert from the
CMSampleBuffer to a UIImage object. The function for this operation isshown in “Converting a CMSampleBuffer
to a UIImage” (page 59).
- (void)captureOutput:(AVCaptureOutput *)captureOutput
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
fromConnection:(AVCaptureConnection *)connection {
Media Capture
Putting it all Together: Capturing Video Frames as UIImage Objects
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
52UIImage *image = imageFromSampleBuffer(sampleBuffer);
// Add your code here that uses the image.
}
Remember that the delegate method is invoked on the queue you specified in
setSampleBufferDelegate:queue:; if you want to update the user interface, you must invoke any relevant
code on the main thread.
Starting and Stopping Recording
After configuring the capture session, you send it a startRunning message to start the recording.
[session startRunning];
To stop recording, you send the session a stopRunning message.
Media Capture
Putting it all Together: Capturing Video Frames as UIImage Objects
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
53Time-based audio-visual data such as a movie file or a video stream is represented in the AV Foundation
framework by AVAsset. Its structure dictates much of the framework works. Several low-level data structures
that AV Foundation uses to represent time and media such as sample buffers come from the Core Media
framework.
Representation of Assets
AVAsset is the core class in the AV Foundation framework. It provides a format-independent abstraction of
time-based audiovisual data, such as a movie file or a video stream. In many cases, you work with one of its
subclasses: you use the composition subclasses when you create new assets (see “Editing” (page 7)), and you
use AVURLAsset to create a new asset instance from media at a given URL (including assetsfrom the MPMedia
framework or the Asset Library framework—see “Using Assets” (page 9)).
AVURLAsset
AVMutableComposition
AVComposition
AVAsset
NSObject
An asset contains a collection of tracks that are intended to be presented or processed together, each of a
uniform media type, including (but not limited to) audio, video, text, closed captions, and subtitles. The asset
object providesinformation about whole resource,such asits duration or title, as well as hintsfor presentation,
such as its natural size. Assets may also have metadata, represented by instances of AVMetadataItem.
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
54
Time and Media RepresentationsA track is represented by an instance of AVAssetTrack. In a typical simple case, one track represents the
audio component and another represents the video component; in a complex composition, there may be
multiple overlapping tracks of audio and video.
AVAsset
AVMetadataItem
AVMetadataItem
AVAssetTrack
AVAssetTrack AVAssetTrack AVAssetTrack
A track has a number of properties, such as its type (video or audio), visual and/or audible characteristics (as
appropriate), metadata, and timeline (expressed in terms of its parent asset). A track also has an array of format
descriptions. The array contains CMFormatDescriptions (see CMFormatDescriptionRef), each of which
describes the format of media samples referenced by the track. A track that contains uniform media (for
example, all encoded using to the same settings) will provide an array with a count of 1.
A track may itself be divided into segments, represented by instances of AVAssetTrackSegment. A segment
is a time mapping from the source to the asset track timeline.
Representations of Time
Time in AV Foundation is represented by primitive structures from the Core Media framework.
CMTime Represents a Length of Time
CMTime is a C structure that represents time as a rational number, with a numerator (an int64_t value), and
a denominator (an int32_t timescale).Conceptually, the timescale specifies the fraction of a second each unit
in the numerator occupies. Thusif the timescale is 4, each unit represents a quarter of a second; if the timescale
is 10, each unit represents a tenth of a second, and so on. You frequently use a timescale of 600, since this is
a common multiple of several commonly-used frame-rates: 24 frames per second (fps) for film, 30 fps for NTSC
(used for TV in North America and Japan), and 25 fps for PAL (used for TV in Europe). Using a timescale of 600,
you can exactly represent any number of frames in these systems.
In addition to a simple time value, a CMTime can represent non-numeric values: +infinity, -infinity, and indefinite.
It can also indicate whether the time been rounded at some point, and it maintains an epoch number.
Time and Media Representations
Representations of Time
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
55Using CMTime
You create a time using CMTimeMake, or one of the related functions such as CMTimeMakeWithSeconds
(which allows you to create a time using a float value and specify a preferred time scale). There are several
functions for time-based arithmetic and to compare times, as illustrated in the following example.
CMTime time1 = CMTimeMake(200, 2); // 200 half-seconds
CMTime time2 = CMTimeMake(400, 4); // 400 quarter-seconds
// time1 and time2 both represent 100 seconds, but using different timescales.
if (CMTimeCompare(time1, time2) == 0) {
NSLog(@"time1 and time2 are the same");
}
Float64 float64Seconds = 200.0 / 3;
CMTime time3 = CMTimeMakeWithSeconds(float64Seconds , 3); // 66.66... third-seconds
time3 = CMTimeMultiply(time3, 3);
// time3 now represents 200 seconds; next subtract time1 (100 seconds).
time3 = CMTimeSubtract(time3, time1);
CMTimeShow(time3);
if (CMTIME_COMPARE_INLINE(time2, ==, time3)) {
NSLog(@"time2 and time3 are the same");
}
For a list of all the available functions, see CMTime Reference .
Special Values of CMTime
Core Media provides constants for special values: kCMTimeZero, kCMTimeInvalid,
kCMTimePositiveInfinity, and kCMTimeNegativeInfinity. There are many ways, though in which a
CMTime can, for example, represent a time that is invalid. If you need to test whether a CMTime is valid, or a
non-numeric value, you should use an appropriate macro, such as CMTIME_IS_INVALID,
CMTIME_IS_POSITIVE_INFINITY, or CMTIME_IS_INDEFINITE.
CMTime myTime = <#Get a CMTime#>;
if (CMTIME_IS_INVALID(myTime)) {
Time and Media Representations
Representations of Time
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
56// Perhaps treat this as an error; display a suitable alert to the user.
}
You should not compare the value of an arbitrary CMTime with kCMTimeInvalid.
Representing a CMTime as an Object
If you need to use CMTimes in annotations or Core Foundation containers, you can convert a CMTime to and
from a CFDictionary (see CFDictionaryRef) using CMTimeCopyAsDictionary and
CMTimeMakeFromDictionary respectively. You can also get a string representation of a CMTime using
CMTimeCopyDescription.
Epochs
The epoch number of a CMTime is usually set to 0, but you can use it to distinguish unrelated timelines. For
example, the epoch could be incremented each cycle through a presentation loop, to differentiate between
time N in loop 0 from time N in loop 1.
CMTimeRange Represents a Time Range
CMTimeRange is a C structure that has a start time and duration, both expressed as CMTimes. A time range
does not include the time that is the start time plus the duration.
You create a time range using CMTimeRangeMake or CMTimeRangeFromTimeToTime. There are constraints
on the value of the CMTimes’ epochs:
● CMTimeRanges cannot span different epochs.
● The epoch in a CMTime that represents a timestamp may be non-zero, but you can only perform range
operations (such as CMTimeRangeGetUnion) on ranges whose start fields have the same epoch.
● The epoch in a CMTime that represents a duration should always be 0, and the value must be non-negative.
Working with Time Ranges
Core Media provides functions you can use to determine whether a time range contains a given time or other
time range, or whether two time ranges are equal, and to calculate unions and intersections of time ranges,
such as CMTimeRangeContainsTime, CMTimeRangeEqual, CMTimeRangeContainsTimeRange, and
CMTimeRangeGetUnion.
Given that a time range does not include the time that is the start time plus the duration, the following
expression always evaluates to false:
Time and Media Representations
Representations of Time
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
57CMTimeRangeContainsTime(range, CMTimeRangeGetEnd(range))
For a list of all the available functions, see CMTimeRange Reference .
Special Values of CMTimeRange
Core Media provides constants for a zero-length range and an invalid range, kCMTimeRangeZero and
kCMTimeRangeInvalid respectively. There are many ways, though in which a CMTimeRange can be invalid,
or zero—or indefinite (if one of the CMTimes is indefinite. If you need to test whether a CMTimeRange is valid,
zero, or indefinite, you should use an appropriate macro: CMTIMERANGE_IS_VALID,
CMTIMERANGE_IS_INVALID, CMTIMERANGE_IS_EMPTY, or CMTIMERANGE_IS_EMPTY.
CMTimeRange myTimeRange = <#Get a CMTimeRange#>;
if (CMTIMERANGE_IS_EMPTY(myTimeRange)) {
// The time range is zero.
}
You should not compare the value of an arbitrary CMTimeRange with kCMTimeRangeInvalid.
Representing a CMTimeRange as an Object
If you need to use CMTimeRangesin annotations or Core Foundation containers, you can convert a CMTimeRange
to and from a CFDictionary (see CFDictionaryRef) using CMTimeRangeCopyAsDictionary and
CMTimeRangeMakeFromDictionary respectively. You can also get a string representation of a CMTime using
CMTimeRangeCopyDescription.
Representations of Media
Video data and its associated metadata is represented in AV Foundation by opaque objects from the Core
Media framework. Core Media represents video data using CMSampleBuffer (see CMSampleBufferRef).
CMSampleBuffer is a Core Foundation-style opaque type; an instance contains the sample buffer for a frame
of video data as a Core Video pixel buffer (see CVPixelBufferRef). You access the pixel buffer from a sample
buffer using CMSampleBufferGetImageBuffer:
CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(<#A CMSampleBuffer#>);
Time and Media Representations
Representations of Media
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
58From the pixel buffer, you can accessthe actual video data. For an example,see “Converting a CMSampleBuffer
to a UIImage” (page 59).
In addition to the video data, you can retrieve a number of other aspects of the video frame:
● Timing information You get accurate timestamps for both the original presentation time and the decode
timeusingCMSampleBufferGetPresentationTimeStampandCMSampleBufferGetDecodeTimeStamp
respectively.
● Format information The format information is encapsulated in a CMFormatDescription object (see
CMFormatDescriptionRef). From the format description, you can get for example the pixel type and
video dimensions using CMVideoFormatDescriptionGetCodecType and
CMVideoFormatDescriptionGetDimensions respectively.
● Metadata Metadata are stored in a dictionary as an attachment. You use CMGetAttachment to retrieve
the dictionary:
CMSampleBufferRef sampleBuffer = <#Get a sample buffer#>;
CFDictionaryRef metadataDictionary =
CMGetAttachment(sampleBuffer, CFSTR("MetadataDictionary", NULL);
if (metadataDictionary) {
// Do something with the metadata.
}
Converting a CMSampleBuffer to a UIImage
The following function shows how you can convert a CMSampleBuffer to a UIImage object. You should consider
your requirements carefully before using it. Performing the conversion is a comparatively expensive operation.
It is appropriate to, for example, create a still image from a frame of video data taken every second or so. You
should not use this as a means to manipulate every frame of video coming from a capture device in real time.
UIImage *imageFromSampleBuffer(CMSampleBufferRef sampleBuffer) {
CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
// Lock the base address of the pixel buffer.
CVPixelBufferLockBaseAddress(imageBuffer,0);
// Get the number of bytes per row for the pixel buffer.
Time and Media Representations
Converting a CMSampleBuffer to a UIImage
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
59size_t bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer);
// Get the pixel buffer width and height.
size_t width = CVPixelBufferGetWidth(imageBuffer);
size_t height = CVPixelBufferGetHeight(imageBuffer);
// Create a device-dependent RGB color space.
static CGColorSpaceRef colorSpace = NULL;
if (colorSpace == NULL) {
colorSpace = CGColorSpaceCreateDeviceRGB();
if (colorSpace == NULL) {
// Handle the error appropriately.
return nil;
}
}
// Get the base address of the pixel buffer.
void *baseAddress = CVPixelBufferGetBaseAddress(imageBuffer);
// Get the data size for contiguous planes of the pixel buffer.
size_t bufferSize = CVPixelBufferGetDataSize(imageBuffer);
// Create a Quartz direct-access data provider that uses data we supply.
CGDataProviderRef dataProvider =
CGDataProviderCreateWithData(NULL, baseAddress, bufferSize, NULL);
// Create a bitmap image from data supplied by the data provider.
CGImageRef cgImage =
CGImageCreate(width, height, 8, 32, bytesPerRow,
colorSpace, kCGImageAlphaNoneSkipFirst |
kCGBitmapByteOrder32Little,
dataProvider, NULL, true, kCGRenderingIntentDefault);
CGDataProviderRelease(dataProvider);
// Create and return an image object to represent the Quartz image.
UIImage *image = [UIImage imageWithCGImage:cgImage];
CGImageRelease(cgImage);
Time and Media Representations
Converting a CMSampleBuffer to a UIImage
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
60CVPixelBufferUnlockBaseAddress(imageBuffer, 0);
return image;
}
Time and Media Representations
Converting a CMSampleBuffer to a UIImage
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
61This table describes the changes to AV Foundation Programming Guide .
Date Notes
2011-10-12 Updated for iOS5 to include references to release notes.
2011-04-28 First release for OS X v10.7.
2010-09-08 TBD
First version of a document that describes a low-level framework you use
to play, inspect, create, edit, capture, and transcode media assets.
2010-08-16
2011-10-12 | © 2011 Apple Inc. All Rights Reserved.
62
Document Revision HistoryApple Inc.
© 2011 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, iPhone, iPod, iPod
touch, Mac, Objective-C, OS X, Quartz, and
QuickTime are trademarks of Apple Inc.,
registered in the U.S. and other countries.
OpenGL is a registered trademark of Silicon
Graphics, Inc.
Times is a registered trademark of Heidelberger
Druckmaschinen AG, available from Linotype
Library GmbH.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Preferences and Settings
Programming GuideContents
About Preferences and Settings 5
At a Glance 5
You Decide What Preferences You Want to Expose 5
Apps Provide Their Own Preferences Interface 5
Apps Access Preferences Using the User Defaults Object 6
iCloud Stores Shared Preference and Configuration Data 6
Defaults Are Grouped into Domains in OS X 6
A Settings Bundle Manages Preferences for iOS Apps 6
See Also 7
About the User Defaults System 8
What Makes a Good Preference? 8
Providing a Preference Interface 8
The Organization of Preferences 9
The Argument Domain 10
The Application Domain 10
The Global Domain 11
The Languages Domains 11
The Registration Domain 11
Viewing Preferences Using the Defaults Tool 12
Accessing Preference Values 13
Registering Your App’s Default Preferences 13
Getting and Setting Preference Values 14
Synchronizing and Detecting Preference Changes 15
Managing Preferences Using Cocoa Bindings 16
Managing Preferences Using Core Foundation 16
Setting a Preference Value Using Core Foundation 16
Getting a Preference Value Using Core Foundation 17
Storing Preferences in iCloud 19
Strategies for Using the iCloud Key-Value Store 19
Configuring Your App to Use the Key-Value Store 20
Accessing Values in the Key-Value Store 21
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
2Defining the Scope of Key-Value Store Changes 22
Implementing an iOS Settings Bundle 24
The Settings App Interface 24
The Settings Bundle 26
The Settings Page File Format 27
Hierarchical Preferences 27
Localized Resources 28
Creating and Modifying the Settings Bundle 29
Adding the Settings Bundle 29
Preparing the Settings Page for Editing 29
Configuring a Settings Page: A Tutorial 31
Creating Additional Settings Page Files 33
Debugging Preferences for Simulated Apps 34
Document Revision History 35
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
3
ContentsFigures, Tables, and Listings
About the User Defaults System 8
Table 1-1 Options for displaying preferences to the user 8
Table 1-2 Search order for domains 10
Accessing Preference Values 13
Listing 2-1 Registering default preference values 14
Listing 2-2 Writing a simple default 17
Listing 2-3 Reading a simple default 17
Storing Preferences in iCloud 19
Listing 3-1 Updating local preference values using iCloud 21
Implementing an iOS Settings Bundle 24
Figure 4-1 Organizing preferences using child panes 28
Figure 4-2 Formatted contents of the Root.plist file 30
Figure 4-3 A root Settings page 31
Table 4-1 Preference control types 25
Table 4-2 Contents of the Settings.bundle directory 26
Table 4-3 Root-level keys of a preferences Settings page file 27
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
4Preferences are pieces of information that you store persistently and use to configure your app. Apps often
expose preferences to users so that they can customize the appearance and behavior of the app. Most
preferences are stored locally using the Cocoa preferences system—known as the user defaults system. Apps
can also store preferences in a user’s iCloud account using the key-value store.
The user defaultssystem and key-value store are both designed forstoring simple data types—strings, numbers,
dates, Boolean values, URLs, data objects, and so forth—in a property list. The use of a property list also means
you can organize your preference data using array and dictionary types. It is also possible to store other objects
in a property list by encoding them into an NSData object first.
At a Glance
Apps integrate preferences in several ways, including programmatically at various points throughout your
code and as part of the user interface. Preferences are supported in both iOS and Mac apps.
You Decide What Preferences You Want to Expose
Preferences are different for each app, and it is up to you to decide what parts of your app you want to make
configurable. Configuration involves checking the value of a stored preference from your code and taking
action based on that value. Thus, the preference value itself should always be simple and have a specific
meaning that is then implemented by your app.
Relevant section: “What Makes a Good Preference?” (page 8)
Apps Provide Their Own Preferences Interface
Because each app’s preferences are different, the app itself is responsible for deciding how best to present
those preferences to the user, if at all. Both iOS and OS X provide some standard places for you to incorporate
a preferences interface, but you are still responsible for designing that interface and displaying it at the
appropriate time.
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
5
About Preferences and SettingsRelevant section: “Providing a Preference Interface” (page 8)
Apps Access Preferences Using the User Defaults Object
Apps accesslocally stored preferences using a user defaults object, which is either an NSUserDefaults object
(iOS and OS X) or an NSUserDefaultsController object (OS X only). In addition to retrieving preference
values, apps can use this object to register default values for preferences and manage other aspects of the
preferences system.
Relevant chapter: “Accessing Preference Values” (page 13)
iCloud Stores Shared Preference and Configuration Data
Apps that support iCloud can put some of their preference data in the user’s iCloud account and make it
available to instances of the app running on the user’s other devices. You use this capability to supplement
(not replace) your app’s existing preferences data and provide a more coherent experience across the user’s
devices. For example, a magazine app might store information about the page number and issue last read by
the user so that the app running on a different device can show that same page.
Relevant chapter: “Storing Preferences in iCloud” (page 19)
Defaults Are Grouped into Domains in OS X
OS X preferences are grouped by domainsso thatsystem preferences can be differentiated from app preferences.
Splitting preferences in this manner lets the user specify some preferences globally and then override one or
more of those preferences inside an app.
Relevant section: “The Organization of Preferences” (page 9)
A Settings Bundle Manages Preferences for iOS Apps
An iOS, apps can display preferences from the Settings app, which is a good place to put preferences that the
user does not need to configure frequently. To display preferences in the Settings app, an app’s bundle must
include a special resource called a Settings bundle that defines the preferences to display, the proper way to
display them, and the information needed to record the user’s selections.
About Preferences and Settings
At a Glance
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
6Note: Apps are not required to use a Settings bundle to manage all preferences. For preferences
that the user islikely to change frequently, the app can display its own custom interface for managing
those preferences.
Relevant chapter: “Implementing an iOS Settings Bundle” (page 24)
See Also
For information about property lists, see Property List Programming Guide .
For more advanced information about using Core Foundation to manage preferences, see Preferences
Programming Topics for Core Foundation .
About Preferences and Settings
See Also
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
7The user defaults system manages the storage of preferences for each user. Most preferences are stored
persistently and therefore do not change between subsequent launch cycles of your app. Apps use preferences
to track user-initiated and program-initiated configuration changes.
What Makes a Good Preference?
When defining your app’s preferences, it is better to use simple values and data types whenever possible. The
preferences system is built around property-list data types such as strings, numbers, and dates. Although you
can use an NSData object to store arbitrary objects in preferences, doing so is not recommended in most
cases.
Storing objects persistently means that your app has to decode that object at some point. In the case of
preferences, a stored object means decoding the object every time you access the preference. It also means
that a newer version of your app has to ensure that it is able to decode objects created and written to disk
using an earlier version of your app, which is potentially error prone.
A better approach for preferences is to store simple strings and values and use them to create the objects your
app needs. Storing simple values meansthat your app can always accessthe value. The only thing that changes
from release to release is the interpretation of the simple value and the objects your app creates in response.
Providing a Preference Interface
For user-facing preferences, Table 1-1 lists the options for displaying those preferences to the user. As you can
see from this table, most options involve the creation of a custom user interface for managing and presenting
preferences. If you are creating an iOS app, you can use a Settings bundle to present preferences, but you
should do so only for settings the user changes infrequently.
Table 1-1 Options for displaying preferences to the user
Preference iOS OS X
Frequently changed preferences Custom UI Custom UI
Infrequently changed preferences Settings bundle Custom UI
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
8
About the User Defaults SystemNote: An example of preferencesthat might change frequently include thingslike the volume levels
or control options of a game. An example of preferences that might change infrequently are the
email address and server settings in the Mail app. For iOS apps, it is ultimately up to you to decide
whether it is appropriate to expose preferences from the Settings app or from inside your app.
Preferences in Mac apps should be accessible from a Preferences menu item in the app menu. Cocoa apps
created using the Xcode templates provide such a menu item for you automatically. It is your responsibility to
present an appropriate user interface when the user choosesthis menu item. You can provide that user interface
by defining an action method in your app delegate that displays a custom preferences window and connecting
that action method to the menu item in Interface Builder.
There is no standard way to display custom preferences from inside an iOS app. You can integrate preferences
in many ways, including using a separate tab in a tab-bar interface or using a custom button from one of your
app’s screens. Preferences should generally be presented using a distinct view controller so that changes in
preferences can be recorded when that view controller is dismissed by the user.
The Organization of Preferences
Preferences are grouped into domains, each of which has a name and a specific usage. For example, there’s a
domain for app-specific preferences and another for systemwide preferences that apply to all apps. All
preferences are stored and accessed on a per-user basis. There is no support for sharing preferences between
users.
Each preference has three components:
● The domain in which it is stored
●
Its name (specified as an NSString object)
●
Its value, which can be any property-list object (NSData, NSString, NSNumber, NSDate, NSArray, or
NSDictionary)
The lifetime of a preference depends on which domain you store it in. Some domains store preferences
persistently by writing them to the user’s defaults database. Such preferences continue to exist from one app
launch to the next. Other domains store preferences in a more volatile way, preserving preference values only
for the life of the corresponding user defaults object.
About the User Defaults System
The Organization of Preferences
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
9A search for the value of a given preference proceeds through the domains in an NSUserDefaults object’s
search list. Only domains in the search list are searched and they are searched in the order shown in Table 1-2,
starting with the NSArgumentDomain domain. A search ends when a preference with the specified name is
found. If multiple domains contain the same preference, the value is taken from the domain nearest the
beginning of the search list.
Table 1-2 Search order for domains
Domain State
NSArgumentDomain volatile
Application (Identified by the app’s identifier) persistent
NSGlobalDomain persistent
Languages (Identified by the language names) volatile
NSRegistrationDomain volatile
The Argument Domain
The argument domain comprises values set from command- line arguments (if you started the app from the
command line) and is identified by the NSArgumentDomain constant. Values set from the command line are
automatically placed into this domain by the system. To add a value to this domain, specify the preference
name on the command line (preceded with a hyphen) and follow it with the corresponding value. For example,
the following command launches Xcode and sets the value of its IndexOnOpen preference to NO:
localhost> Xcode.app/Contents/MacOS/Xcode -IndexOnOpen NO
Preferencesset from the command line temporarily override the established valuesstored in the user’s defaults
database. In the preceding example,setting the IndexOnOpen preference to NO prevents Xcode from indexing
projects automatically, even if the preference is set to YES in the user defaults database.
The Application Domain
The application domain contains app-specific preferences that are stored in the user defaults database of the
current user. When you use the shared NSUserDefaults object (or a NSUserDefaultsController object
in OS X) to write preferences, those preferences are automatically placed in this domain.
About the User Defaults System
The Organization of Preferences
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
10Because this domain is app-specific, the contents of the domain are tied to your app’s bundle identifier. The
contents of this domain are stored in a file that is managed by the system. Currently, this file is located in the
$HOME/Library/Preferences/ directory, where $HOME is either the app’s home directory or the user’s
home directory (depending on the platform and whether your app is in a sandbox). The name of the user
defaults database file is .plist, where is your
app’s bundle identifier. You should not modify this file directly but can inspect it during debugging to make
sure preference values are being written by your app.
The Global Domain
The global domain contains preferencesthat are applicable to all apps and isidentified by the NSGlobalDomain
constant. This domain is typically used by system frameworks to store system-wide values and should not be
used by your app to store app-specific values. If you want to change the value of a preference in the global
domain, write that same preference to the application domain with the new value.
Examples of how the system frameworks use this domain:
●
Instances of the NSRuleView class store the user’s preferred measurement units in the
AppleMeasurementUnits key. Using this storage location causes ruler views in all apps to use the same
units.
● The system uses the AppleLanguages key to store the user’s preferred languages as an array of strings.
For example, a user could specify English as the preferred language, followed by Spanish, French, German,
Italian, and Swedish.
The Languages Domains
For each language in the AppleLanguages preference, the system recordslanguage-specific preference values
in a domain whose name is based on the language name. Each language-specific domain contains preferences
for the corresponding locale. Many classes in the Foundation framework (such as the NSDate,
NSDateFormatter, NSTimeZone, NSString, and NSScanner classes) use this locale information to modify
their behavior. For example, when you request a string representation of an NSCalendarDate object, the
NSCalendarDate object uses the locale information to find the names of months and the days of the week
for the user’s preferred language.
The Registration Domain
The registration domain defines the set of default values to use if a given preference is not set explicitly in one
of the other domains. At launch time, an app can call the registerDefaults: method of NSUserDefaults
to specify a default set of values for important preferences. When an app launches for the first time, most
preferences have no values,so retrieving them would yield undefined results. Registering a set of default values
ensures that your app always has a known good set of values to operate on.
About the User Defaults System
The Organization of Preferences
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
11The contents of the registration domain can be set only by using the registerDefaults: method.
Viewing Preferences Using the Defaults Tool
In OS X, the defaults command-line tool provides a way for you to examine the contents of the user defaults
database. During app development, you might use this tool to validate the preferences your app is writing to
disk. To do that, you would use a command of the following form from the Terminal app:
defaults read
To read the contents of the global domain, you would use the following command:
defaults read NSGlobalDomain
For more information about using the defaults tool to read and write preference values, see defaults man
page.
About the User Defaults System
Viewing Preferences Using the Defaults Tool
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
12You use the NSUserDefaults class to gain access to your app’s preferences. Each app is provided with a
single instance of this class, accessible from the standardUserDefaults class method. You use the shared
user defaults object to:
● Specify any default values for your app’s preferences at launch time.
● Get and set individual preference values stored in the app domain.
● Remove preference values.
● Examine the contents of the volatile preference domains.
Mac appsthat use Cocoa bindings can use an NSUserDefaultsController object to set and get preferences
automatically. You typically add such an object to the same nib file you use for displaying user-facing preferences.
You bind your user interface controls to items in the user defaults controller, which handles the process of
getting and setting values in the user defaults database.
Preference values must be one of the standard property list object types: NSData, NSString, NSNumber,
NSDate, NSArray, or NSDictionary. The NSUserDefaults class also provides built-in manipulations for
storing NSURL objects as preference values. For more information about property lists and their contents, see
Property List Programming Guide .
Registering Your App’s Default Preferences
At launch time, an app should register default values for any preferences that it expects to be present and
valid. When you request the value of a preference that has never been set, the methods of the NSUserDefaults
class return default values that are appropriate for the data type. For numerical scalar values, this typically
means returning 0, but for strings and other objects it means returning nil. If these standard default values
are not appropriate for your app, you can register your own default values using the registerDefaults:
method. This method places your custom default values in the NSRegistrationDomain domain, which
causes them to be returned when a preference is not explicitly set.
When calling the registerDefaults: method, you must provide a dictionary of all the default values you
need to register. Listing 2-1 shows an example where an iOS app registers its default values early in the launch
cycle. You can register default values at any time, of course, butshould alwaysregister them before attempting
to retrieve any preference values.
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
13
Accessing Preference ValuesListing 2-1 Registering default preference values
- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
// Register the preference defaults early.
NSDictionary *appDefaults = [NSDictionary
dictionaryWithObject:[NSNumber numberWithBool:YES]
forKey:@"CacheDataAgressively"];
[[NSUserDefaults standardUserDefaults] registerDefaults:appDefaults];
// Other initialization...
}
When registering default values for scalar types, use an NSNumber object to specify the value for the number.
If you want to register a preference whose value is a URL, use the archivedDataWithRootObject: method
of NSKeyedArchiver to encode the URL in an NSData object first. Although you can use a similar technique
for other types of objects, you should avoid doing so when a simpler option is available.
Getting and Setting Preference Values
You get and set preference values using the methods of the NSUserDefaults class. This class has methods
for getting and setting preferences with scalar values of type Boolean, integer, float, and double. It also
has methodsfor getting and setting preferences whose value is an object of type NSData, NSDate, NSString,
NSNumber, NSArray, NSDictionary, and NSURL. There are two situations where you might get preference
values and one where you might set them:
● Get preference values:
● When you need to use the value to configure your app’s behavior.
● When you need to display the value in your preferences interface.
● Set preference values when the user changes them in your preferences interface.
The following code shows how you might get a preference value in your code. In this example, the code
retrieves the value of the CacheDataAggressively key, which is custom key that the app might use to
determine its caching strategy. Code like this can be used anywhere to handle custom configuration of your
app. If you wanted to display this particular preference value to the user, you would use similar code to configure
the controls of your preferences interface.
Accessing Preference Values
Getting and Setting Preference Values
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
14if ([[NSUserDefaults standardUserDefaults] boolForKey:@"CacheDataAggressively"])
{
// Delete the backup file.
}
To set a preference value programmatically, you call the corresponding setter methods of NSUserDefaults.
When setting object values, you must use the setObject:forKey: method. When calling this method, you
must make sure that the object is one of the standard property list types. The following example sets some
preferences based on the state of the app’s preferences interface.
NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
if ([cacheAgressivelyButton state] == NSOnState) {
// The user wants to cache files aggressively.
[defaults setBool:YES forKey:@"CacheDataAggressively"];
[defaults setObject:[NSDate dateWithTimeIntervalSinceNow:(3600 * 24 * 7)]
forKey:@"CacheExpirationDate"]; // Set a 1-week expiration
} else {
// The user wants to use lazy caching.
[defaults setBool:NO forKey:@"CacheDataAggressively"];
[defaults removeObjectForKey:@"CacheExpirationDate"];
}
You do not have to display a preferences interface to manage all values. Your app can use preferences to cache
interesting information. For example, NSWindow objectsstore their current location in the user defaultssystem.
This data allows them to return to the same location the next time the user starts the app.
Synchronizing and Detecting Preference Changes
Because the NSUserDefaults class caches values, it issometimes necessary to synchronize the cached values
with the current contents of the user defaults database. Your app is not always the only entity modifying the
user defaults database. In iOS, the Settings app can modify the values of preferences for apps that have a
Settings bundle. In OS X, the system and other apps might modify preferences values in response to user
actions. For example, if the user changes preferred languages, the system writes the new values to the user
defaults database. In OS X v10.5 and later, the shared NSUserDefaults object synchronizes its caches
automatically at periodic intervals. However, apps can call the synchronize method manually to force an
update of the cached values.
Accessing Preference Values
Synchronizing and Detecting Preference Changes
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
15To detect when changes to a preference value occur, apps can also register for the notification
NSUserDefaultsDidChangeNotification. The shared NSUserDefaults object sends this notification
to your app whenever it detects a change to a preference located in one of the persistent domains. You can
use this notification to respond to changes that might impact your user interface. For example, you could use
it to detect changes to the user’s preferred language and update your app content appropriately.
Managing Preferences Using Cocoa Bindings
Mac apps can use Cocoa bindings to set preference values directly from their user interfaces. Modifying
preferences using bindings involves adding an NSUserDefaultsController object to the appropriate nib
files and binding the values of your controls to the preference values in the user defaults database. When your
app showsthe interface, the user defaults controller automatically loads valuesfrom the user defaults database
and uses them to set the value of controls. Similarly, when the user changes the value in a control, the user
defaults controller updates the value in the user defaults database.
For more information on how to use the NSUserDefaultsController class to bind preference values to
your user interface, see “User Defaults and Bindings” in Cocoa Bindings Programming Topics.
Managing Preferences Using Core Foundation
The Core Foundation framework provides its own set of interfaces for accessing preferences stored in the user
defaults database. Like the NSUserDefaults class, you can use Core Foundation functions to get and set
preference values and synchronize the user defaults database. Unlike NSUserDefaults, you can use the Core
Foundation functions to write preferences for different apps and on different computers. Note that modifying
some preferences domains(those not belonging to the current app and user) requiresroot privileges(or admin
privileges prior to OS X v10.6); for information on how to gain suitable privileges, see Authorization Services
Programming Guide . Writing outside the app domain is not possible for apps installed in a sandbox.
For information about the Core Foundation functions for getting and setting preferences, see Preferences
Utilities Reference .
Setting a Preference Value Using Core Foundation
Preferences are stored as key-value pairs. The key must be a CFString object, but the value can be any Core
Foundation property list value (see Property List Programming Topics for Core Foundation ), including the
container types. For example, you might have a key called defaultWindowWidth that defines the width in
Accessing Preference Values
Managing Preferences Using Cocoa Bindings
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
16pixels of any new windows that your app creates. Its value would most likely be of type CFNumber. You might
also decide to combine window width and height into a single preference called defaultWindowSize and
make its value be a CFArray object containing two CFNumber objects.
The code in Listing 2-2 demonstrates how to create a simple preference for the app MyTextEditor. The example
sets the default text color for the app to blue.
Listing 2-2 Writing a simple default
CFStringRef textColorKey = CFSTR("defaultTextColor");
CFStringRef colorBLUE = CFSTR("BLUE");
// Set up the preference.
CFPreferencesSetAppValue(textColorKey, colorBLUE,
kCFPreferencesCurrentApplication);
// Write out the preference data.
CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
Notice that CFPreferencesSetAppValue by itself is not sufficient to create the new preference. A call to
CFPreferencesAppSynchronize isrequired to actually save the value. If you are writing multiple preferences,
it is more efficient to sync only once after the last value has been set than to sync after each individual value
is set. For example, if you implement a preference pane you might synchronize only when the user presses an
OK button. In other cases you might not want to sync at all until the app quits—although note that if the app
crashes, all unsaved preferences settings will be lost.
Getting a Preference Value Using Core Foundation
The simplest way to locate and retrieve a preference value is to use the CFPreferencesCopyAppValue
function. This call searches through the various preference domains in order until it finds the key you have
specified. If a preference has been set in a less specific domain—Any Application, for example —its value is
retrieved with this call if a more specific version cannot be found. Listing 2-3 shows how to retrieve the text
color preference saved in Listing 2-2 (page 17).
Listing 2-3 Reading a simple default
CFStringRef textColorKey = CFSTR("defaultTextColor");
CFStringRef textColor;
Accessing Preference Values
Managing Preferences Using Core Foundation
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
17// Read the preference.
textColor = (CFStringRef)CFPreferencesCopyAppValue(textColorKey,
kCFPreferencesCurrentApplication);
// When finished with value, you must release it
// CFRelease(textColor);
All values returned from preferences are immutable, even if you have just set the value using a mutable object.
Accessing Preference Values
Managing Preferences Using Core Foundation
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
18An app can use the iCloud key-value store to share small amounts of data with other instances of itself on the
user’s other computers and iOS devices. The key-value store is intended for simple data types like those you
might use for preferences. For example, a magazine app might store the current issue and page number being
read by the user so that other instances of the app can open to the same page when launched. You should
not use this store for large amounts of data or for complex data types.
To use the iCloud key-value store, do the following:
1. In Xcode, configure the com.apple.developer.ubiquity-kvstore-identifier entitlement for
your app.
2. In your code, create the shared NSUbiquitousKeyValueStore object and register for change notifications.
3. Use the methods of NSUbiquitousKeyValueStore to get and set values.
Key-value data in iCloud is limited to simple property-list types (strings, numbers, dates, and so on).
Strategies for Using the iCloud Key-Value Store
The key-value store is not intended for storing large amounts of data. It is intended for storing configuration
data, preferences, and small amounts of app-related data. To help you decide whether the key-value store is
appropriate for your needs, consider the following:
● Each app is limited to 1 MB of total space in the key-value store. (There is also a separate per-key limit of
1 MB and a maximum of 1024 keys are allowed.) Thus, you cannot use the key-value store to share large
amounts of data.
● The key-value store supports only property-list types. Property-list types include simple types such as
NSNumber, NSString, and NSDate objects. You can also store raw blocks of data in NSData objects and
arrange all of the types using NSArray and NSDictionary objects.
● The key-value store is intended for storing data that changes infrequently. If the apps on a device make
frequent changes to the key-value store, the system may defer the synchronization of some changes in
order to minimize the number of round trips to the server. The more frequently apps make changes, the
more likely it is that later changes will be deferred and not show up on other devices right away.
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
19
Storing Preferences in iCloud● The key-value store is not a replacement for preferences or other local techniques for saving the same
data. The purpose of the key-value store is to share data between apps, but if iCloud is not enabled or is
not available on a given device, you still might want to keep a local copy of the data.
If you are using the key-value store to share preferences, one approach is to store the actual values in the user
defaults database and synchronize them using the key-value store. (If you do not want to use the preferences
system, you could also save the changes in a custom property-list file or some other local storage.) When you
change the value of a key locally, write that change to both the user defaults database and to the iCloud
key-value store at the same time. To receive changesfrom externalsources, add an observer for the notification
NSUbiquitousKeyValueStoreDidChangeExternallyNotification and use your handler method to
detect which keys changed externally and update the corresponding data in the user defaults database. By
doing this, your user defaults database always contains the correct configuration values. The iCloud key-value
store simply becomes a mechanism for ensuring that the user defaults database has the most recent changes.
Configuring Your App to Use the Key-Value Store
In order to use of the key-value store, an app must be explicitly configured with the
com.apple.developer.ubiquity-kvstore-identifier entitlement. You use Xcode to enable this
entitlement and specify its value for your app:
1. In your Xcode project, select the target for your app.
2. In the Summary tab, enable the Entitlements option.
3. Specify a value for the iCloud Key-Value Store field.
When you enable entitlements, Xcode automatically fills in a default value for the iCloud Key-Value Store field
that is based on the bundle identifier of your app. For most apps, the default value is what you want. However,
if your app shares its key-value storage with another app, you must specify the bundle identifier for the other
app instead. For example, if you have a lite version of your app, you might want it to use the same key-value
store as the paid version.
Enabling the entitlement is all you have to do to use the shared NSUbiquitousKeyValueStore object. As
long as the entitlement is configured and contains a valid value, the key-value store object writes its data to
the appropriate location in the user’s iCloud account. If there is a problem attaching to the specified iCloud
container, any attemptsto read or write key values will fail. To ensure the key-value store is configured properly
and accessible, you should execute code similar to the following early in your app’s launch cycle:
NSUbiquitousKeyValueStore* store = [NSUbiquitousKeyValueStore defaultStore];
[[NSNotificationCenter defaultCenter] addObserver:self
Storing Preferences in iCloud
Configuring Your App to Use the Key-Value Store
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
20selector:@selector(updateKVStoreItems:)
name:NSUbiquitousKeyValueStoreDidChangeExternallyNotification
object:store];
[store synchronize];
Creating the key-value store object early in your app’s launch cycle is recommended because it ensures that
your app receives updates from iCloud in a timely manner. The best way to determine if changes have been
made to keys and values is to register for the notification
NSUbiquitousKeyValueStoreDidChangeExternallyNotification. And at launch time, you should
call the synchronize method manually to detect if any changes were made externally. You do not need to
call that method at other times during you app’s execution.
For more information about how to configure entitlements for an iOS app, see “Configuring Apps” in Tools
Workflow Guide for iOS .
Accessing Values in the Key-Value Store
You get and set key-value store values using the methods of the NSUbiquitousKeyValueStore class. This
class has methods for getting and setting preferences with scalar values of type Boolean, long long, and
double. It also has methods for getting and setting keys whose values are NSData, NSDate, NSString,
NSNumber, NSArray, or NSDictionary objects.
If you are using the key-value store as a way to update locally stored preferences, you could use code similar
to that in Listing 3-1 to coordinate updates to the user defaults database. This example assumes that you use
the same key names and corresponding values in both iCloud and the user defaults database. It also assumes
that you previously registered the updateKVStoreItems: method as the method to call in response to the
notification NSUbiquitousKeyValueStoreDidChangeExternallyNotification.
Listing 3-1 Updating local preference values using iCloud
- (void)updateKVStoreItems:(NSNotification*)notification {
// Get the list of keys that changed.
NSDictionary* userInfo = [notification userInfo];
NSNumber* reasonForChange = [userInfo
objectForKey:NSUbiquitousKeyValueStoreChangeReasonKey];
NSInteger reason = -1;
// If a reason could not be determined, do not update anything.
Storing Preferences in iCloud
Accessing Values in the Key-Value Store
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
21if (!reasonForChange)
return;
// Update only for changes from the server.
reason = [reasonForChange integerValue];
if ((reason == NSUbiquitousKeyValueStoreServerChange) ||
(reason == NSUbiquitousKeyValueStoreInitialSyncChange)) {
// If something is changing externally, get the changes
// and update the corresponding keys locally.
NSArray* changedKeys = [userInfo
objectForKey:NSUbiquitousKeyValueStoreChangedKeysKey];
NSUbiquitousKeyValueStore* store = [NSUbiquitousKeyValueStore defaultStore];
NSUserDefaults* userDefaults = [NSUserDefaults standardUserDefaults];
// This loop assumes you are using the same key names in both
// the user defaults database and the iCloud key-value store
for (NSString* key in changedKeys) {
id value = [store objectForKey:key];
[userDefaults setObject:value forKey:key];
}
}
}
Defining the Scope of Key-Value Store Changes
Every call to one of the NSUbiquitousKeyValueStore methods is treated as a single atomic transaction.
When transferring the data for that transaction to iCloud, the whole transaction either fails or succeeds. If it
succeeds, all of the keys are written to the store and if it fails no keys are written. There is no partial writing of
keys to the store. When a failure occurs, the system also generates a
NSUbiquitousKeyValueStoreDidChangeExternallyNotification notification that containsthe reason
for the failure. If you are using the key-value store, you should use that notification to detect possible problems.
Storing Preferences in iCloud
Defining the Scope of Key-Value Store Changes
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
22If you have a group of keys whose values must all be updated at the same time in order to be valid, save them
together in a single transaction. To write multiple keys and values in a single transaction, create an
NSDictionary object with all of the keys and values. Then write the dictionary object to the key-value store
using the setDictionary:forKey: method. Writing an entire dictionary of changes ensures that all of the
keys are written or none of them are.
Storing Preferences in iCloud
Defining the Scope of Key-Value Store Changes
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
23In iOS, the Foundation framework provides the low-level mechanism for storing the preference data. Apps
then have two options for presenting preferences:
● Display preferences inside the app.
● Use a Settings bundle to manage preferences from the Settings app.
Which option you choose depends on how you expect users to interact with preferences. The Settings bundle
is generally the preferred mechanism for displaying preferences. However, games and other apps that contain
configuration options or other frequently accessed preferences might want to present them inside the app
instead. Regardless of how you present them, you use the NSUserDefaults class to access preference values
from your code.
This chapter focuses on the creation of a Settings bundle for your app. A Settings bundle contains files that
describe the structure and presentation style of your preferences. The Settings app uses this information to
create an entry for your app and to display your custom preference pages.
For guidelines on how to manage and present settings and configuration options, see iOS Human Interface
Guidelines.
The Settings App Interface
The Settings app implements a hierarchical set of pages for navigating app preferences. The main page of the
Settings app liststhe system and third-party apps whose preferences can be customized. Selecting a third-party
app takes the user to the preferences for that app.
Every app with a Settings bundle has at least one page of preferences, referred to as the main page . If your
app has only a few preferences, the main page may be the only one you need. If the number of preferences
gets too large to fit on the main page, however, you can create child pages that link off the main page or other
child pages. There is no specific limit to the number of child pages you can create, but you should strive to
keep your preferences as simple and easy to navigate as possible.
The contents of each page consists of one or more controls that you configure. Table 4-1 lists the types of
controls supported by the Settings app and describes how you might use each type. The table also lists the
raw key name stored in the configuration files of your Settings bundle.
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
24
Implementing an iOS Settings BundleTable 4-1 Preference control types
Controltype Description
The text field type displays a title (optional) and an editable text field. You can use this
type for preferences that require the user to specify a custom string value.
The key for this type is PSTextFieldSpecifier.
Text field
The title type displays a read-only string value. You can use thistype to display read-only
preference values. (If the preference contains cryptic or nonintuitive values, this type
lets you map the possible values to custom strings.)
The key for this type is PSTitleValueSpecifier.
Title
The toggle switch type displays an ON/OFF toggle button. You can use this type to
configure a preference that can have only one of two values. Although you typically
use this type to represent preferences containing Boolean values, you can also use it
with preferences containing non-Boolean values.
The key for this type is PSToggleSwitchSpecifier.
Toggle
switch
The slider type displays a slider control. You can use this type for a preference that
represents a range of values. The value for this type is a real number whose minimum
and maximum value you specify.
The key for this type is PSSliderSpecifier.
Slider
The multivalue type lets the user select one value from a list of values. You can use this
type for a preference that supports a set of mutually exclusive values. The values can
be of any type.
The key for this type is PSMultiValueSpecifier.
Multivalue
The group type is for organizing groups of preferences on a single page. The group
type does not represent a configurable preference. It simply contains a title string that
is displayed immediately before one or more configurable preferences.
The key for this type is PSGroupSpecifier.
Group
The child pane type lets the user navigate to a new page of preferences. You use this
type to implement hierarchical preferences. For more information on how you configure
and use this preference type, see “Hierarchical Preferences” (page 27).
The key for this type is PSChildPaneSpecifier.
Child pane
For detailed information about the format of each preference type, see Settings Application Schema Reference .
To learn how to create and edit Settings page files, see “Creating and Modifying the Settings Bundle” (page
29).
Implementing an iOS Settings Bundle
The Settings App Interface
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
25The Settings Bundle
A Settings bundle hasthe name Settings.bundle and residesin the top-level directory of your app’s bundle.
This bundle contains one or more Settings page files that describe the individual pages of preferences. It may
also include other support files needed to display your preferences, such as images or localized strings. Table
4-2 lists the contents of a typical Settings bundle.
Table 4-2 Contents of the Settings.bundle directory
Item name Description
The Settings page file containing the preferences for the root page. The
name of thisfile must be Root.plist. The contents of thisfile are described
in more detail in “The Settings Page File Format” (page 27).
Root.plist
If you build a set of hierarchical preferences using child panes, the contents
for each child pane are stored in a separate Settings page file. You are
responsible for naming these files and associating them with the correct
child pane.
Additional .plist files
These directories store localized string resources for your Settings page files.
Each directory contains a single strings file, whose title is specified in your
Settings page file. The strings files provide the localized strings to display
for your preferences.
One or more .lproj
directories
If you use the slider control, you can store the images for your slider in the
top-level directory of the bundle.
Additional images
In addition to the Settings bundle, the app bundle can contain a custom icon for your app settings. The Settings
app displays the icon you provide next to the entry for your app preferences. For information about app icons
and how you specify them, see iOS App Programming Guide .
When the Settings app launches, it checks each custom app for the presence of a Settings bundle. For each
custom bundle it finds, it loadsthat bundle and displaysthe corresponding app’s name and icon in the Settings
main page. When the user taps the row belonging to your app, Settings loads the Root.plist Settings page
file for your Settings bundle and uses that file to build your app’s main page of preferences.
In addition to loading your bundle’s Root.plist Settings page file, the Settings app also loads any
language-specific resources for that file, as needed. Each Settings page file can have an associated .strings
file containing localized values for any user-visible strings. As it prepares your preferences for display, the
Settings app looksforstring resourcesin the user’s preferred language and substitutesthem in your preferences
page prior to display.
Implementing an iOS Settings Bundle
The Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
26The Settings Page File Format
Each Settings page file is stored in the iPhone Settings property-list file format, which is a structured file format.
The simplest way to edit Settings page files is to use the built-in editor facilities of Xcode; see “Preparing the
Settings Page for Editing” (page 29). You can also edit property-list files using the Property List Editor app that
comes with the Xcode tools.
Note: Xcode converts any XML-based property files in your project to binary format when building
your app. This conversion saves space and is done for you automatically.
The root element of each Settings page file contains the keys listed in Table 4-3. Only one key is actually
required, but it is recommended that you include both of them.
Table 4-3 Root-level keys of a preferences Settings page file
Key Type Value
The value for this key is an array of dictionaries, with each
dictionary containing the information for a single control.
For a list of control types, see Table 4-1 (page 25). For a
description of the keys associated with each control, see
Settings Application Schema Reference .
PreferenceSpecifiers Array
(required)
The name of the strings file associated with this file. A copy
of this file (with appropriate localized strings) should be
located in each of your bundle’s language-specific project
directories. If you do not include this key, the strings in this
file are not localized. For information on how these strings
are used, see “Localized Resources” (page 28).
StringsTable String
Hierarchical Preferences
If you plan to organize your preferences hierarchically, each page you define must have its own separate
.plist file. Each .plist file contains the set of preferences displayed only on that page. Your app’s main
preferences page is always stored in a file called Root.plist. Additional pages can be given any name you
like.
To specify a link between a parent page and a child page, you include a child pane control in the parent page.
A child pane control creates a row that, when tapped, displays a new page of settings. The File key of the
child pane control identifies the name of the .plist file with the contents of the child page. The Title key
Implementing an iOS Settings Bundle
The Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
27identifies the title of the child page; this title is also used as the text of the control used to display the child
page. The Settings app automatically provides navigation controls on the child page to allow the user to
navigate back to the parent page.
Figure 4-1 shows how this hierarchical set of pages works. The left side of the figure shows the .plist files,
and the right side shows the relationships between the corresponding pages.
Figure 4-1 Organizing preferences using child panes
Sounds
New Voicemail
Group 1
Group 2
New Email
Sent Mail
Ringtones
Sounds page
Settings
Group 1
Usage
Sounds
Group 2
Group 3
Brightness
Wallpaper
General
Root page
Sounds.plist
Root.plist
General.plist
General page
General
Date & Time
Group 1
Network
Keyboard
For more information about child pane controls and their associated keys, see Settings Application Schema
Reference .
Localized Resources
Because preferences contain user-visible strings, you should provide localized versions of those strings with
your Settings bundle. Each page of preferences can have an associated .strings file for each localization
supported by your bundle. When the Settings app encounters a key that supports localization, it checks the
appropriately localized .strings file for a matching key. If it finds one, it displays the value associated with
that key.
When looking for localized resources such as .strings files, the Settings app follows the same rules that
other iOS apps follow. It first tries to find a localized version of the resource that matches the user’s preferred
language setting. If no such resource exists, an appropriate fallback language is selected.
Implementing an iOS Settings Bundle
The Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
28For information about the format ofstringsfiles, language-specific project directories, and how language-specific
resources are retrieved from bundles, see Internationalization Programming Topics.
Creating and Modifying the Settings Bundle
Xcode provides a template for adding a Settings bundle to your current project. The default Settings bundle
contains a Root.plist file and a default language directory for storing any localized resources. You can
expand this bundle as needed to include additional property list files and resources needed by your Settings
bundle.
Adding the Settings Bundle
To add a Settings bundle to your Xcode project:
1. Choose File > New > New File.
2. Under iOS, choose Resource, and then select the Settings Bundle template.
3. Name the file Settings.bundle.
In addition to adding a new Settings bundle to your project, Xcode automatically addsthat bundle to the Copy
Bundle Resources build phase of your app target. Thus, all you have to do is modify the property list files of
your Settings bundle and add any needed resources.
The new Settings bundle has the following structure:
Settings.bundle/
Root.plist
en.lproj/
Root.strings
Preparing the Settings Page for Editing
Before editing any of the property-list files in your Settings bundle, you should configure the Xcode editor to
format the contents of those files as iPhone settings. Xcode does this automatically for the Root.plist file,
but you may need to format additional property-list files manually. To format a file as iPhone Settings, do the
following:
1. Select the file.
2. Control-click the editor window and choose Property List Type > iPhone Settings plist if it is not already
chosen.
Implementing an iOS Settings Bundle
Creating and Modifying the Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
29Formatting a property list makes it easier to understand and edit the file’s contents. Xcode substitutes
human-readable strings (as shown in Figure 4-2) that are appropriate for the selected format.
Figure 4-2 Formatted contents of the Root.plist file
Implementing an iOS Settings Bundle
Creating and Modifying the Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
30Configuring a Settings Page: A Tutorial
This section shows you how to configure a Settings page to display the controls you want. The goal of the
tutorial is to create a page like the one in Figure 4-3. If you have not yet created a Settings bundle for your
project, you should do so as described in “Adding the Settings Bundle” (page 29) before proceeding with
these steps.
Figure 4-3 A root Settings page
1. Disclose the Preference Items key to display the default items that come with the template.
2. Change the title of Item 0 to Sound.
● Disclose Item 0 of Preference Items.
● Change the value of the Title key from Group to Sound.
● Leave the Type key set to Group.
● Click the disclosure triangle of the item to hide its contents.
3. Create the first toggle switch for the renamed Sound group.
● Select Item 2 (the toggle switch item) of Preference Items and choose Edit > Cut.
● Select Item 0 and choose Edit > Paste. (This moves the toggle switch item in front of the text field
item.)
● Disclose the toggle switch item to reveal its configuration keys.
● Change the value of the Title key to Play Sounds.
● Change the value of the Identifier key to play_sounds_preference.
Implementing an iOS Settings Bundle
Creating and Modifying the Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
31● Click the disclosure triangle of the item to hide its contents.
4. Create a second toggle switch for the Sound group.
● Select Item 1 (the Play Sounds toggle switch).
● Choose Edit > Copy.
● Choose Edit >Paste to place a copy of the toggle switch right after the first one.
● Disclose the new toggle switch item to reveal its configuration keys.
● Change the value of its Title key to 3D Sound.
● Change the value of its Identifier key to 3D_sound_preference.
● Click the disclosure triangle of the item to hide its contents.
At this point, you have finished the first group of settings and are ready to create the User Info group.
5. Change Item 3 into a Group control and name it User Info.
● Click Item 3 in the Preferences Items. This displays a pop-up menu with a list of item types.
● From the pop-up menu, choose Group to change the type of the control.
● Disclose the contents of Item 3.
● Set the value of the Title key to User Info.
● Click the disclosure triangle of the item to hide its contents.
6. Create the Name field.
● Select Item 4 in the Preferences Items.
● Using the pop-up menu, change its type to Text Field.
● Set the value of the Title key to Name.
● Set the value of the Identifier key to user_name.
● Click the disclosure triangle of the item to hide its contents.
7. Create the Experience Level settings.
● Select Item 4.
● Control-click the editor window and select Add Row to add a new item.
● Set the type of the new item to Multi Value.
● Disclose the item’s contents and set its title to Experience Level, its identifier to
experience_preference, and its default value to 0.
● With the Default Value key selected, Control-click and select Add Row to add a Titles array.
● Select the Titles array and press Return to add a new subitem.
● Add two more subitems to create a total of three items.
Implementing an iOS Settings Bundle
Creating and Modifying the Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
32● Set the values of the subitems to Beginner, Expert, and Master.
● Hide the key’s subitems.
● Add a new item for the Values array.
● Add three subitems to the Values array and set their values to 0, 1, and 2.
● Hide the contents of Item 5.
8. Add the final group to your settings page.
● Create a new item and set its type to Group and its title to Gravity.
● Create another new item and set itstype to Slider, itsidentifier to gravity_preference, its default
value to 1, and its maximum value to 2.
Creating Additional Settings Page Files
The Settings Bundle template includes the Root.plist file, which defines your app’s top Settings page. To
define additional Settings pages, you must add additional property list files to your Settings bundle.
To add a property list file to your Settings bundle in Xcode, do the following:
1. Choose File > New > New File.
2. Under iOS, select Resource, and then select the Property List template.
3. Select the new file to display its contents in the editor.
4. Control-click the editor pane and choose Property List Type > iPhone Settings plist to format the contents.
5. Control-click the editor pane again and choose Add Row to add a new key.
6. Add and configure any additional keys you need.
After adding a new Settings page to your Settings bundle, you can edit the page’s contents as described in
“Configuring a Settings Page: A Tutorial” (page 31). To display the settings for your page, you must reference
it from a child pane control as described in “Hierarchical Preferences” (page 27).
Implementing an iOS Settings Bundle
Creating and Modifying the Settings Bundle
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
33Note: In Xcode 4, adding a property-list file to your project does not automatically associate it with
your Settings bundle. You must use the Finder to move any additional property-list files into your
Settings bundle.
Debugging Preferences for Simulated Apps
When running your app, iOS Simulatorstores any preferences valuesfor your app in ~/Library/Application
Support/iOS Simulator/User/Applications//Library/Preferences, where
is a programmatically generated directory name that iOS uses to identify your app.
Each time you build your app, Xcode preserves your app preferences and other relevant library files. If you
want to remove the current preferences for testing purposes, you can delete the app from Simulator or choose
Reset Contents and Settings from the iOS Simulator menu.
Implementing an iOS Settings Bundle
Debugging Preferences for Simulated Apps
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
34This table describes the changes to Preferences and Settings Programming Guide .
Date Notes
2012-03-01 Updated the document to reflect new limits for key and value sizes.
Updated the document to include information about Settings bundles
and iOS in general. Also incorporated iCloud information.
2011-10-12
Removed the articles on storing NSColor objects and using Cocoa bindings
and now link to their locations instead.
Changed document name from User Defaults Programming Topics.
2007-10-31 Updated information about periodic autosave behavior.
2007-01-08 Corrected typos and capitalization mistakes.
Added overview of procedure forstoring non-property-list objectsin user
defaults, and linked to related article.
2006-11-07
2006-09-05 Made small additions to the content. Changed title from "User Defaults."
Expanded explanation of user defaults in introduction.
Noted requirement that a default’s value must be a property list value at
the beginning of the “Using NSUserDefaults” article.
Included an article that describes the use of NSUserDefaultsController.
Corrected minor typographical errors.
2005-08-11
2004-02-03 Added article “Storing NSColor in User Defaults”.
Linked to the Core Foundation Preferences Programming Topic, which
was also incorrectly named.
2003-05-09
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
35
Document Revision HistoryDate Notes
Added link in limitations area to CFPreferences. Corrected class name in
Defaults Domains Concept.
2003-01-13
Revision history was added to existing topic. It will be used to record
changes to the content of the topic.
2002-11-12
Document Revision History
2012-03-01 | © 2012 Apple Inc. All Rights Reserved.
36Apple Inc.
© 2012 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, Finder, iPhone,
Mac, OS X, and Xcode are trademarks of Apple
Inc., registered in the U.S. and other countries.
.Mac and iCloud are service marks of Apple Inc.,
registered in the U.S. and other countries.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
OpenGL Programming
Guide for MacContents
About OpenGL for OS X 11
At a Glance 11
OpenGL Is a C-based, Platform-Neutral API 12
Different Rendering Destinations Require Different Setup Commands 12
OpenGL on Macs Exists in a Heterogenous Environment 12
OpenGL Helps Applications Harness the Power of Graphics Processors 13
Concurrency in OpenGL Applications Requires Additional Effort 13
Performance Tuning Allows Your Application to Provide an Exceptional User Experience 14
How to Use This Document 14
Prerequisites 15
See Also 15
OpenGL on the Mac Platform 17
OpenGL Concepts 17
OpenGL Implements a Client-Server Model 18
OpenGL Commands Can Be Executed Asynchronously 18
OpenGL Commands Are Executed In Order 19
OpenGL Copies Client Data at Call-Time 19
OpenGL Relies on Platform-Specific Libraries For Critical Functionality 19
OpenGL in OS X 20
Accessing OpenGL Within Your Application 21
OpenGL APIs Specific to OS X 22
Apple-Implemented OpenGL Libraries 23
Terminology 24
Renderer 24
Renderer and Buffer Attributes 24
Pixel Format Objects 24
OpenGL Profiles 25
Rendering Contexts 25
Drawable Objects 25
Virtual Screens 26
Offline Renderer 31
Running an OpenGL Program in OS X 31
Making Great OpenGL Applications on the Macintosh 33
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
2Drawing to a Window or View 35
General Approach 35
Drawing to a Cocoa View 36
Drawing to an NSOpenGLView Class: A Tutorial 37
Drawing OpenGL Content to a Custom View 40
Optimizing OpenGL for High Resolution 44
Enable High-Resolution Backing for an OpenGL View 44
Set Up the Viewport to Support High Resolution 45
Adjust Model and Texture Assets 46
Check for Calls Defined in Pixel Dimensions 46
Tune OpenGL Performance for High Resolution 47
Use a Layer-Backed View to Overlay Text on OpenGL Content 48
Use an Application Window for Fullscreen Operation 49
Convert the Coordinate Space When Hit Testing 49
Drawing to the Full Screen 50
Creating a Full-Screen Application 50
52
Drawing Offscreen 53
Rendering to a Framebuffer Object 53
Using a Framebuffer Object as a Texture 54
Using a Framebuffer Object as an Image 58
Rendering to a Pixel Buffer 60
Setting Up a Pixel Buffer for Offscreen Drawing 61
Using a Pixel Buffer as a Texture Source 61
Rendering to a Pixel Buffer on a Remote System 63
Choosing Renderer and Buffer Attributes 64
OpenGL Profiles (OS X v10.7) 64
Buffer Size Attribute Selection Tips 65
Ensuring That Back Buffer Contents Remain the Same 66
Ensuring a Valid Pixel Format Object 66
Ensuring a Specific Type of Renderer 67
Ensuring a Single Renderer for a Display 68
Allowing Offline Renderers 69
OpenCL 70
Deprecated Attributes 70
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
3
ContentsWorking with Rendering Contexts 72
Update the Rendering Context When the Renderer or Geometry Changes 72
Tracking Renderer Changes 73
Updating a Rendering Context for a Custom Cocoa View 73
Context Parameters Alter the Context’s Behavior 76
Swap Interval Allows an Application to Synchronize Updates to the Screen Refresh 76
Surface Opacity Specifies How the OpenGL Surface Blends with Surfaces Behind It 77
Surface Drawing Order Specifies the Position of the OpenGL Surface Relative to the Window 77
Determining Whether Vertex and Fragment Processing Happens on the GPU 78
Controlling the Back Buffer Size 78
Sharing Rendering Context Resources 79
Determining the OpenGL Capabilities Supported by the Renderer 83
Detecting Functionality 83
Guidelines for Code That Checks for Functionality 87
OpenGL Renderer Implementation-Dependent Values 88
OpenGL Application Design Strategies 89
Visualizing OpenGL 89
Designing a High-Performance OpenGL Application 91
Update OpenGL Content Only When Your Data Changes 94
Synchronize with the Screen Refresh Rate 96
Avoid Synchronizing and Flushing Operations 96
Using glFlush Effectively 97
Avoid Querying OpenGL State 98
Use Fences for Finer-Grained Synchronization 98
Allow OpenGL to Manage Your Resources 99
Use Double Buffering to Avoid Resource Conflicts 100
Be Mindful of OpenGL State Variables 101
Replace State Changes with OpenGL Objects 102
Use Optimal Data Types and Formats 102
Use OpenGL Macros 103
Best Practices for Working with Vertex Data 104
Understand How Vertex Data Flows Through OpenGL 105
Techniques for Handling Vertex Data 107
Vertex Buffers 107
Using Vertex Buffers 108
Buffer Usage Hints 110
Flush Buffer Range Extension 113
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
4
ContentsVertex Array Range Extension 113
Vertex Array Object 116
Best Practices for Working with Texture Data 118
Using Extensions to Improve Texture Performance 119
Pixel Buffer Objects 121
Apple Client Storage 124
Apple Texture Range and Rectangle Texture 125
Combining Client Storage with Texture Ranges 127
Optimal Data Formats and Types 128
Working with Non–Power-of-Two Textures 129
Creating Textures from Image Data 131
Creating a Texture from a Cocoa View 131
Creating a Texture from a Quartz Image Source 133
Getting Decompressed Raw Pixel Data from a Source Image 135
Downloading Texture Data 136
Double Buffering Texture Data 137
Customizing the OpenGL Pipeline with Shaders 139
Shader Basics 141
Advanced Shading Extensions 142
Transform Feedback 142
GPU Shader 4 143
Geometry Shaders 143
Uniform Buffers 143
Techniques for Scene Antialiasing 144
Guidelines 145
General Approach 145
Hinting for a Specific Antialiasing Technique 147
Concurrency and OpenGL 148
Identifying Whether an OpenGL Application Can Benefit from Concurrency 149
OpenGL Restricts Each Context to a Single Thread 149
Strategies for Implementing Concurrency in OpenGL Applications 150
Multithreaded OpenGL 150
Perform OpenGL Computations in a Worker Task 151
Use Multiple OpenGL Contexts 153
Guidelines for Threading OpenGL Applications 154
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
5
ContentsTuning Your OpenGL Application 155
Gathering and Analyzing Baseline Performance Data 156
Using OpenGL Driver Monitor to Measure Stalls 161
Identifying Bottlenecks with Shark 161
Legacy OpenGL Functionality by Version 163
Version 1.1 163
Version 1.2 164
Version 1.3 165
Version 1.4 165
Version 1.5 166
Version 2.0 166
Version 2.1 167
Updating an Application to Support the OpenGL 3.2 Core Specification 168
Removed Functionality 168
Extension Changes on OS X 169
Setting Up Function Pointers to OpenGL Routines 171
Obtaining a Function Pointer to an Arbitrary OpenGL Entry Point 171
Initializing Entry Points 172
Document Revision History 175
Glossary 179
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
6
ContentsFigures, Tables, and Listings
OpenGL on the Mac Platform 17
Figure 1-1 OpenGL provides the reflections in iChat 17
Figure 1-2 OpenGL client-server model 18
Figure 1-3 Graphics platform model 18
Figure 1-4 MacOS X OpenGL driver model 20
Figure 1-5 Layers of OpenGL for OS X 21
Figure 1-6 The programing interfaces used for OpenGL content 22
Figure 1-7 Data flow through OpenGL 26
Figure 1-8 A virtual screen displays what the user sees 27
Figure 1-9 Two virtual screens 28
Figure 1-10 A virtual screen can represent more than one physical screen 29
Figure 1-11 Two virtual screens and two graphics cards 30
Figure 1-12 The flow of data through OpenGL 31
Drawing to a Window or View 35
Figure 2-1 OpenGL content in a Cocoa view 35
Figure 2-2 The output from the Golden Triangle program 39
Listing 2-1 The interface for MyOpenGLView 37
Listing 2-2 Include OpenGL/gl.h 38
Listing 2-3 The drawRect: method for MyOpenGLView 38
Listing 2-4 Code that draws a triangle using OpenGL commands 38
Listing 2-5 The interface for a custom OpenGL view 40
Listing 2-6 The initWithFrame:pixelFormat: method 41
Listing 2-7 The lockFocus method 42
Listing 2-8 The drawRect method for a custom view 42
Listing 2-9 Detaching the context from a drawable object 43
Optimizing OpenGL for High Resolution 44
Figure 3-1 Enabling high-resolution backing for an OpenGL view 45
Figure 3-2 A text overlay scales automatically for standard resolution (left) and high resolution (right)
48
Listing 3-1 Setting up the viewport for drawing 45
Drawing to the Full Screen 50
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
7Figure 4-1 Drawing OpenGL content to the full screen 50
Drawing Offscreen 53
Listing 5-1 Setting up a framebuffer for texturing 57
Listing 5-2 Setting up a renderbuffer for drawing images 59
Choosing Renderer and Buffer Attributes 64
Table 6-1 Renderer types and pixel format attributes 67
Listing 6-1 Using the CGL API to create a pixel format object 66
Listing 6-2 Setting an NSOpenGLContext object to use a specific display 68
Listing 6-3 Setting a CGL context to use a specific display 69
Working with Rendering Contexts 72
Figure 7-1 A fixed size back buffer and variable size front buffer 79
Figure 7-2 Shared contexts attached to the same drawable object 80
Figure 7-3 Shared contexts and more than one drawable object 80
Listing 7-1 Handling context updates for a custom view 74
Listing 7-2 Using CGL to set up synchronization 76
Listing 7-3 Using CGL to set surface opacity 77
Listing 7-4 Using CGL to set surface drawing order 77
Listing 7-5 Using CGL to check whether the GPU is processing vertices and fragments 78
Listing 7-6 Using CGL to set up back buffer size control 79
Listing 7-7 Setting up an NSOpenGLContext object for sharing 81
Listing 7-8 Setting up a CGL context for sharing 82
Determining the OpenGL Capabilities Supported by the Renderer 83
Table 8-1 Common OpenGL renderer limitations 88
Table 8-2 OpenGL shader limitations 88
Listing 8-1 Checking for OpenGL functionality 84
Listing 8-2 Setting up a valid rendering context to get renderer functionality information 86
OpenGL Application Design Strategies 89
Figure 9-1 OpenGL graphics pipeline 90
Figure 9-2 OpenGL client-server architecture 91
Figure 9-3 Application model for managing resources 92
Figure 9-4 Single-buffered vertex array data 100
Figure 9-5 Double-buffered vertex array data 101
Listing 9-1 Setting up a Core Video display link 94
Listing 9-2 Setting up synchronization 96
Listing 9-3 Disabling state variables 102
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
8
Figures, Tables, and ListingsListing 9-4 Using CGL macros 103
Best Practices for Working with Vertex Data 104
Figure 10-1 Vertex data sets can be quite large 104
Figure 10-2 Vertex data path 105
Figure 10-3 Immediate mode requires a copy of the current vertex data 105
Listing 10-1 Submitting vertex data using glDrawElements. 106
Listing 10-2 Using the vertex buffer object extension with dynamic data 109
Listing 10-3 Using the vertex buffer object extension with static data 110
Listing 10-4 Geometry with different usage patterns 111
Listing 10-5 Using the vertex array range extension with dynamic data 115
Listing 10-6 Using the vertex array range extension with static data 116
Best Practices for Working with Texture Data 118
Figure 11-1 Textures add realism to a scene 118
Figure 11-2 Texture data path 119
Figure 11-3 Data copies in an OpenGL program 120
Figure 11-4 The client storage extension eliminates a data copy 124
Figure 11-5 The texture range extension eliminates a data copy 126
Figure 11-6 Combining extensions to eliminate data copies 127
Figure 11-7 Normalized and non-normalized coordinates 129
Figure 11-8 An image segmented into power-of-two tiles 130
Figure 11-9 Using an image as a texture for a cube 131
Figure 11-10 Single-buffered data 137
Figure 11-11 Double-buffered data 138
Listing 11-1 Using texture extensions for a rectangular texture 127
Listing 11-2 Using texture extensions for a power-of-two texture 128
Listing 11-3 Building an OpenGL texture from an NSView object 132
Listing 11-4 Using a Quartz image as a texture source 134
Listing 11-5 Getting pixel data from a source image 135
Listing 11-6 Code that downloads texture data 136
Customizing the OpenGL Pipeline with Shaders 139
Figure 12-1 OpenGL fixed-function pipeline 139
Figure 12-2 OpenGL shader pipeline 140
Listing 12-1 Loading a Shader 141
Techniques for Scene Antialiasing 144
Table 13-1 Antialiasing hints 147
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
9
Figures, Tables, and ListingsConcurrency and OpenGL 148
Figure 14-1 CPU processing and OpenGL on separate threads 152
Figure 14-2 Two contexts on separate threads 153
Listing 14-1 Enabling the multithreaded OpenGL engine 151
Tuning Your OpenGL Application 155
Figure 15-1 Output produced by the top application 157
Figure 15-2 The OpenGL Profiler window 158
Figure 15-3 A statistics window 159
Figure 15-4 A Trace window 160
Figure 15-5 The graph view in OpenGL Driver Monitor 161
Legacy OpenGL Functionality by Version 163
Table A-1 Functionality added in OpenGL 1.1 163
Table A-2 Functionality added in OpenGL 1.2 164
Table A-3 Functionality added in OpenGL 1.3 165
Table A-4 Functionality added in OpenGL 1.4 165
Table A-5 Functionality added in OpenGL 1.5 166
Table A-6 Functionality added in OpenGL 2.0 166
Table A-7 Functionality added in OpenGL 2.1 167
Updating an Application to Support the OpenGL 3.2 Core Specification 168
Table B-1 Extensions described in this guide 169
Setting Up Function Pointers to OpenGL Routines 171
Listing C-1 Using NSLookupAndBindSymbol to obtain a symbol for a symbol name 172
Listing C-2 Using NSGLGetProcAddress to obtain an OpenGL entry point 173
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
10
Figures, Tables, and ListingsOpenGL is an open, cross-platform graphics standard with broad industry support. OpenGL greatly eases the
task of writing real-time 2D or 3D graphics applications by providing a mature, well-documented graphics
processing pipeline that supports the abstraction of current and future hardware accelerators.
OpenGL client
OpenGL server
Graphics hardware
Application
OpenGL framework
OpenGL driver
Runs on GPU
Runs on CPU
At a Glance
OpenGL is an excellent choice for graphics development on the Macintosh platform because it offers the
following advantages:
● Reliable Implementation. The OpenGL client-server model abstracts hardware details and guarantees
consistent presentation on any compliant hardware and software configuration. Every implementation of
OpenGL adheres to the OpenGL specification and must pass a set of conformance tests.
● Performance. Applications can harness the considerable power of the graphics hardware to improve
rendering speeds and quality.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
11
About OpenGL for OS X●
Industry acceptance. The specification for OpenGL is controlled by the Khronos Group, an industry
consortium whose members include many of the major companies in the computer graphics industry,
including Apple. In addition to OpenGL for OS X, there are OpenGL implementations for Windows, Linux,
Irix, Solaris, and many game consoles.
OpenGL Is a C-based, Platform-Neutral API
Because OpenGL is a C-based API, it is extremely portable and widely supported. As a C API, it integrates
seamlessly with Objective-C based Cocoa applications. OpenGL provides functions your application uses to
generate 2D or 3D images. Your application presents the rendered images to the screen or copies them back
to its own memory.
The OpenGL specification does not provide a windowing layer of its own. It relies on functions defined by OS
X to integrate OpenGL drawing with the windowing system. Your application creates an OS X OpenGL rendering
context and attaches a rendering target to it (known as a drawable object). The rendering context manages
OpenGL state changes and objects created by calls to the OpenGL API. The drawable object is the final
destination for OpenGL drawing commands and is typically associated with a Cocoa window or view.
Relevant Chapters: “OpenGL on the Mac Platform” (page 17)
Different Rendering Destinations Require Different Setup Commands
Depending on whether your application intends to draw OpenGL content to a window, to draw to the entire
screen, or to perform offscreen image processing, it takes different steps to create the rendering context and
associate it with a drawable object.
Relevant Chapters: “Drawing to a Window or View” (page 35), “Drawing to the Full Screen” (page
50) and “Drawing Offscreen” (page 53)
OpenGL on Macs Exists in a Heterogenous Environment
Macs support different types of graphics processors, each with different rendering capabilities, supporting
versions of OpenGL from 1.x through OpenGL 3.2. When creating a rendering context, your application can
accept a broad range of renderers or it can restrict itself to devices with specific capabilities. Once you have a
context, you can configure how that context executes OpenGL commands.
About OpenGL for OS X
At a Glance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
12OpenGL on the Mac is not only a heterogenous environment, but it is also a dynamic environment. Users can
add or remove displays, or take a laptop running on battery power and plug it into a wall. When the graphics
environment on the Mac changes, the renderer associated with the context may change. Your application
must handle these changes and adjust how it uses OpenGL.
Relevant Chapters: “Choosing Renderer and Buffer Attributes” (page 64), “Working with Rendering
Contexts” (page 72), and “Determining the OpenGL Capabilities Supported by the Renderer” (page
83)
OpenGL Helps Applications Harness the Power of Graphics Processors
Graphics processors are massively parallelized devices optimized for graphics operations. To access that
computing power adds additional overhead because data must move from your application to the GPU over
slower internal buses. Accessing the same data simultaneously from both your application and OpenGL is
usually restricted. To get great performance in your application, you must carefully design your application to
feed data and commands to OpenGL so that the graphics hardware runs in parallel with your application. A
poorly tuned application may stall either on the CPU or the GPU waiting for the other to finish processing.
When you are ready to optimize your application’s performance, Apple provides both general-purpose and
OpenGL-specific profiling tools that make it easy to learn where your application spends its time.
Relevant Chapters: “Optimizing OpenGL for High Resolution” (page 44), “OpenGL on the Mac
Platform” (page 17),“OpenGL Application Design Strategies” (page 89), “Best Practices for Working
with Vertex Data” (page 104), “Best Practicesfor Working with Texture Data” (page 118), “Customizing
the OpenGL Pipeline with Shaders” (page 139), and “Tuning Your OpenGL Application” (page 155)
Concurrency in OpenGL Applications Requires Additional Effort
Many Macs ship with multiple processors or multiple cores, and future hardware is expected to add more of
each. Designing applications to take advantage of multiprocessing is critical. OpenGL places additional
restrictions on multithreaded applications. If you intend to add concurrency to an OpenGL application, you
must ensure that the application does not access the same context from two different threads at the same
time.
About OpenGL for OS X
At a Glance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
13Relevant Chapters: “Concurrency and OpenGL” (page 148)
Performance Tuning Allows Your Application to Provide an Exceptional User
Experience
Once you’ve improved the performance of your OpenGL application and taken advantage of concurrency, put
some of the freed processing power to work for you. Higher resolution textures, detailed models, and more
complex lighting and shading algorithms can improve image quality. Full-scene antialiasing on modern graphics
hardware can eliminate many of the “jaggies” common on lower resolution images.
Relevant Chapters: “Customizing the OpenGL Pipeline with Shaders” (page 139),“Techniques for
Scene Antialiasing” (page 144)
How to Use This Document
If you have never programmed in OpenGL on the Mac, you should read this book in its entirety, starting with
“OpenGL on the Mac Platform” (page 17). Critical Mac terminology is defined in that chapter as well as in the
“Glossary” (page 179).
If you already have an OpenGL application running on the Mac, but have not yet updated it for OS X v10.7,
read “Choosing Renderer and Buffer Attributes” (page 64) to learn how to choose an OpenGL profile for your
application.
To find out how to update an existing OpenGL app for high resolution, see “Optimizing OpenGL for High
Resolution” (page 44).
Once you have OpenGL content in your application, read “OpenGL Application Design Strategies” (page 89)
to learn fundamental patterns for implementing high-performance OpenGL applications, and the chapters
that follow to learn how to apply those patterns to specific OpenGL problems.
About OpenGL for OS X
How to Use This Document
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
14Important: Although this guide describes how to create rendering contexts that support OpenGL 3.2,
most code examples and discussion in the rest of the book describe the earlier legacy versions of OpenGL.
See “Updating an Application to Support the OpenGL 3.2 Core Specification” (page 168) for more information
on migrating your application to OpenGL 3.2.
Prerequisites
This guide assumes that you have some experience with OpenGL programming, but want to learn how to
apply that knowledge to create software for the Mac. Although this guide provides advice on optimizing
OpenGL code, it does not provide entry-level information on how to use the OpenGL API. If you are unfamiliar
with OpenGL, you should read “OpenGL on the Mac Platform” (page 17) to get an overview of OpenGL on the
Mac platform, and then read the following OpenGL programming guide and reference documents:
● OpenGL Programming Guide, by Dave Shreiner and the Khronos OpenGL Working Group; otherwise known
as "The Red book.”
● OpenGL Shading Language , by Randi J. Rost, is an excellent guide for those who want to write programs
that compute surface properties (also known as shaders).
● OpenGL Reference Pages.
Before reading this document, you should be familiar with Cocoa windows and views asintroduced in Window
Programming Guide and View Programming Guide .
See Also
Keep these reference documents handy as you develop your OpenGL program for OS X:
● NSOpenGLView Class Reference , NSOpenGLContext Class Reference , NSOpenGLPixelBuffer Class Reference ,
and NSOpenGLPixelFormat Class Reference provide a complete description of the classes and methods
needed to integrate OpenGL content into a Cocoa application.
● CGL Reference describes low-level functions that can be used to create full-screen OpenGL applications.
● OpenGL Extensions Guide provides information about OpenGL extensions supported in OS X.
The OpenGL Foundation website, http://www.opengl.org, provides information on OpenGL commands, the
Khronos OpenGL Working Group, logo requirements, OpenGL news, and many other topics. It's a site that
you'll want to visit regularly. Among the many resources it provides, the following are important reference
documents for OpenGL developers:
About OpenGL for OS X
Prerequisites
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
15● OpenGL Specification provides detailed information on how an OpenGL implementation is expected to
handle each OpenGL command.
● OpenGL Reference describes the main OpenGL library.
● OpenGL GLU Reference describes the OpenGL Utility Library, which contains convenience functions
implemented on top of the OpenGL API.
● OpenGL GLUT Reference describes the OpenGL Utility Toolkit, a cross-platform windowing API.
● OpenGL API Code and Tutorial Listings provides code examples for fundamental tasks, such as modeling
and texture mapping, as well as for advanced techniques, such as high dynamic range rendering (HDRR).
About OpenGL for OS X
See Also
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
16You can tell that Apple has an implementation of OpenGL on its platform by looking at the user interface for
many of the applications that are installed with OS X. The reflections built into iChat (Figure 1-1) provide one
of the more notable examples. The responsiveness of the windows, the instant results of applying an effect in
iPhoto, and many other operations in OS X are due to the use of OpenGL. OpenGL is available to all Macintosh
applications.
OpenGL for OS X is implemented as a set of frameworks that contain the OpenGL runtime engine and its
drawing software. These frameworks use platform-neutral virtual resourcesto free your programming as much
as possible from the underlying graphics hardware. OS X provides a set of application programming interfaces
(APIs) that Cocoa applications can use to support OpenGL drawing.
Figure 1-1 OpenGL provides the reflections in iChat
This chapter provides an overview of OpenGL and the interfaces your application uses on the Mac platform to
tap into it.
OpenGL Concepts
To understand how OpenGL fits into OS X and your application, you should first understand how OpenGL is
designed.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
17
OpenGL on the Mac PlatformOpenGL Implements a Client-Server Model
OpenGL uses a client-server model, as shown in Figure 1-2. When your application calls an OpenGL function,
it talks to an OpenGL client. The client delivers drawing commands to an OpenGL server. The nature of the
client, the server, and the communication path between them is specific to each implementation of OpenGL.
For example, the server and clients could be on different computers, or they could be different processes on
the same computer.
Figure 1-2 OpenGL client-server model
Application
OpenGL client
OpenGL server
A client-server model allows the graphics workload to be divided between the client and the server. For
example, all Macintosh computersship with dedicated graphics hardware that is optimized to perform graphics
calculations in parallel. Figure 1-3 shows a common arrangement of CPUs and GPUs. With this hardware
configuration, the OpenGL client executes on the CPU and the server executes on the GPU.
Figure 1-3 Graphics platform model
CPU
RAM
Core Core
GPU
RAM
Core Core Core
Core Core Core
System
OpenGL Commands Can Be Executed Asynchronously
A benefit of the OpenGL client-server model is that the client can return control to the application before the
command has finished executing. An OpenGL client may also buffer or delay execution of OpenGL commands.
If OpenGL required all commands to complete before returning control to the application, then either the CPU
or the GPU would be idle waiting for the other to provide it data, resulting in reduced performance.
OpenGL on the Mac Platform
OpenGL Concepts
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
18Some OpenGL commandsimplicitly or explicitly require the client to wait untilsome or all previously submitted
commands have completed. OpenGL applicationsshould be designed to reduce the frequency of client-server
synchronizations. See “OpenGL Application Design Strategies” (page 89) for more information on how to
design your OpenGL application.
OpenGL Commands Are Executed In Order
OpenGL guarantees that commands are executed in the order they are received by OpenGL.
OpenGL Copies Client Data at Call-Time
When an application calls an OpenGL function, the OpenGL client copies any data provided in the parameters
before returning control to the application. For example, if a parameter points at an array of vertex data stored
in application memory, OpenGL must copy that data before returning. Therefore, an application is free to
change memory it owns regardless of calls it makes to OpenGL.
The data that the client copies is often reformatted before it is transmitted to the server. Copying, modifying,
and transmitting parameters to the server adds overhead to calling OpenGL. Applications should be designed
to minimize copy overhead.
OpenGL Relies on Platform-Specific Libraries For Critical Functionality
OpenGL provides a rich set of cross-platform drawing commands, but does not define functions to interact
with an operating system’s graphics subsystem. Instead, OpenGL expects each implementation to define an
interface to create rendering contexts and associate them with the graphics subsystem. A rendering context
holds all of the data stored in the OpenGL state machine. Allowing multiple contexts allows the state in one
machine to be changed by an application without affecting other contexts.
Associating OpenGL with the graphic subsystem usually means allowing OpenGL content to be rendered to
a specific window. When content is associated with a window, the implementation creates whatever resources
are required to allow OpenGL to render and display images.
OpenGL on the Mac Platform
OpenGL Concepts
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
19OpenGL in OS X
OpenGL in OS X implementsthe OpenGL client-server model using a common OpenGL framework and plug-in
drivers. The framework and driver combine to implement the client portion of OpenGL, as shown in Figure
1-4. Dedicated graphics hardware provides the server. Although this is the common scenario, Apple also
provides a software renderer implemented entirely on the CPU.
Figure 1-4 MacOS X OpenGL driver model
OpenGL client
OpenGL server
Graphics hardware
Application
OpenGL framework
OpenGL driver
Runs on GPU
Runs on CPU
OS X supports a display space that can include multiple dissimilar displays, each driven by different graphics
cards with different capabilities. In addition, multiple OpenGL renderers can drive each graphics card. To
accommodate this versatility, OpenGL for OS X is segmented into well-defined layers: a window system layer,
OpenGL on the Mac Platform
OpenGL in OS X
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
20a framework layer, and a driver layer, as shown in Figure 1-5. This segmentation allows for plug-in interfaces
to both the window system layer and the framework layer. Plug-in interfaces offer flexibility in software and
hardware configuration without violating the OpenGL standard.
Figure 1-5 Layers of OpenGL for OS X
Software GLD plug-in ATI GLD plug-in NVIDIA GLD plug-in Intel GLD plug-in
Application
Hardware
Window system layer
Common OpenGL framework
Driver layer
NSOpenGL CGL OpenGL
The window system layer is an OS X–specific layer that your application uses to create OpenGL rendering
contexts and associate them with the OS X windowing system. The NSOpenGL classes and Core OpenGL (CGL)
API also provide some additional controlsfor how OpenGL operates on that context. See “OpenGL APIs Specific
to OS X” (page 22) for more information. Finally, this layer also includes the OpenGL libraries—GL, GLU, and
GLUT. (See “Apple-Implemented OpenGL Libraries” (page 23) for details.)
The common OpenGL framework layer is the software interface to the graphics hardware. This layer contains
Apple's implementation of the OpenGL specification.
The driver layer contains the optional GLD plug-in interface and one or more GLD plug-in drivers, which may
have different software and hardware support capabilities. The GLD plug-in interface supports third-party
plug-in drivers, allowing third-party hardware vendors to provide drivers optimized to take best advantage of
their graphics hardware.
Accessing OpenGL Within Your Application
The programming interfacesthat your application callsfall into two categories—those specific to the Macintosh
platform and those defined by the OpenGL Working Group. The Apple-specific programming interfaces are
what Cocoa applications use to communicate with the OS X windowing system. These APIs don't create OpenGL
content, they manage content, direct it to a drawing destination, and control various aspects of the rendering
OpenGL on the Mac Platform
Accessing OpenGL Within Your Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
21operation. Your application calls the OpenGL APIs to create content. OpenGL routines accept vertex, pixel, and
texture data and assemble the data to create an image. The final image resides in a framebuffer, which is
presented to the user through the windowing-system specific API.
Figure 1-6 The programing interfaces used for OpenGL content
OpenGL engine and drivers
GLUT
CGL OpenGL
NSOpenGL
classes
GLUT application Cocoa application
OpenGL APIs Specific to OS X
OS X offers two easy-to-use APIs that are specific to the Macintosh platform: the NSOpenGL classes and the
CGL API. Throughout this document, these APIs are referred to as the Apple-specific OpenGL APIs.
Cocoa provides many classes specifically for OpenGL:
● The NSOpenGLContext class implements a standard OpenGL rendering context.
● The NSOpenGLPixelFormat class is used by an application to specify the parameters used to create the
OpenGL context.
● The NSOpenGLView class is a subclass of NSView that uses NSOpenGLContext and
NSOpenGLPixelFormat to display OpenGL content in a view. Applicationsthatsubclass NSOpenGLView
do not need to directly subclass NSOpenGLPixelFormat or NSOpenGLContext. Applications that need
customization or flexibility, can subclass NSView and create NSOpenGLPixelFormat and
NSOpenGLContext objects manually.
● The NSOpenGLLayer class allows your application to integrate OpenGL drawing with Core Animation.
● The NSOpenGLPixelBuffer class provides hardware-accelerated offscreen drawing.
OpenGL on the Mac Platform
Accessing OpenGL Within Your Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
22The Core OpenGL API (CGL) residesin the OpenGL framework and is used to implement the NSOpenGL classes.
CGL offersthe most direct accessto system functionality and providesthe highest level of graphics performance
and control for drawing to the full screen. CGL Reference provides a complete description of this API.
Apple-Implemented OpenGL Libraries
OS X also provides the full suite of graphics libraries that are part of every implementation of OpenGL: GL, GLU,
GLUT, and GLX. Two of these—GL and GLU—provide low-level drawing support. The other two—GLUT and
GLX—support drawing to the screen.
Your application typically interfaces directly with the core OpenGL library (GL), the OpenGL Utility library (GLU),
and the OpenGL Utility Toolkit (GLUT). The GL library provides a low-level modular API that allows you to
define graphical objects. Itsupportsthe core functions defined by the OpenGL specification. It providessupport
for two fundamental types of graphics primitives: objects defined by sets of vertices, such as line segments
and simple polygons, and objects that are pixel-based images, such as filled rectangles and bitmaps. The GL
API does not handle complex custom graphical objects; your application must decompose them into simpler
geometries.
The GLU library combines functions from the GL library to support more advanced graphics features. It runs
on all conforming implementations of OpenGL. GLU is capable of creating and handling complex polygons
(including quartic equations), processing nonuniform rational b-spline curves (NURBs), scaling images, and
decomposing a surface to a series of polygons (tessellation).
The GLUT library provides a cross-platform API for performing operations associated with the user windowing
environment—displaying and redrawing content, handling events, and so on. It isimplemented on most UNIX,
Linux, and Windows platforms. Code that you write with GLUT can be reused across multiple platforms. However,
such code is constrained by a generic set of user interface elements and event-handling options. This document
does not show how to use GLUT. The GLUTBasics sample project shows you how to get started with GLUT.
GLX is an OpenGL extension that supports using OpenGL within a window provided by the X Window system.
X11 for OS X is available as an optional installation. (It's not shown in Figure 1-6 (page 22).) See OpenGL
Programming for the X Window System, published by Addison Wesley for more information.
This document does not show how to use these libraries. For detailed information, either go to the OpenGL
Foundation website http://www.opengl.org or see the most recent version of "The Red book"—OpenGL Programming Guide, published by Addison Wesley.
OpenGL on the Mac Platform
Accessing OpenGL Within Your Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
23Terminology
There are a number of termsthat you’ll want to understand so that you can write code effectively using OpenGL:
renderer, renderer attributes, buffer attributes, pixel format objects, rendering contexts, drawable objects, and
virtual screens. As an OpenGL programmer, some of these may seem familiar to you. However, understanding
the Apple-specific nuances of these terms will help you get the most out of OpenGL on the Macintosh platform.
Renderer
A renderer isthe combination of the hardware and software that OpenGL usesto execute OpenGL commands.
The characteristics of the final image depend on the capabilities of the graphics hardware associated with the
renderer and the device used to display the image. OS X supports graphics accelerator cards with varying
capabilities, as well as a software renderer. It is possible for multiple renderers, each with different capabilities
or features, to drive a single set of graphics hardware. To learn how to determine the exact features of a
renderer, see “Determining the OpenGL Capabilities Supported by the Renderer” (page 83).
Renderer and Buffer Attributes
Your application uses renderer and buffer attributes to communicate renderer and buffer requirements to
OpenGL. The Apple implementation of OpenGL dynamically selectsthe best renderer for the current rendering
task and doesso transparently to your application. If your application has very specific rendering requirements
and wants to control renderer selection, it can do so by supplying the appropriate renderer attributes. Buffer
attributes describe such things as color and depth buffer sizes, and whether the data is stereoscopic or
monoscopic.
Renderer and buffer attributes are represented by constants defined in the Apple-specific OpenGL APIs. OpenGL
uses the attributes you supply to perform the setup work needed prior to drawing content. “Drawing to a
Window or View” (page 35) provides a simple example that shows how to use renderer and buffer attributes.
“Choosing Renderer and Buffer Attributes” (page 64) explains how to choose renderer and buffer attributes
to achieve specific rendering goals.
Pixel Format Objects
A pixel format describes the format for pixel data storage in memory. The description includes the number
and order of components as well as their names (typically red, blue, green and alpha). It also includes other
information, such as whether a pixel contains stencil and depth values. A pixel format object is an opaque
data structure that holds a pixel format along with a list of renderers and display devices that satisfy the
requirements specified by an application.
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
24Each of the Apple-specific OpenGL APIs defines a pixel format data type and accessor routines that you can
use to obtain the information referenced by this object. See “Virtual Screens” (page 26) for more information
on renderer and display devices.
OpenGL Profiles
OpenGL profiles are new in OS X 10.7. An OpenGL profile is a renderer attribute used to request a specific
version of the OpenGL specification. When your application provides an OpenGL profile as part of its renderer
attributes, it only receives renderers that provide the complete feature set promised by that profile. The render
can implement a different version of the OpenGL so long asthe version itsuppliesto your application provides
the same functionality that your application requested.
Rendering Contexts
A rendering context, or simply context, contains OpenGL state information and objects for your application.
State variables include such things as drawing color, the viewing and projection transformations, lighting
characteristics, and material properties. State variables are set per context. When your application creates
OpenGL objects (for example, textures), these are also associated with the rendering context.
Although your application can maintain more than one context, only one context can be the current context
in a thread. The current context is the rendering context that receives OpenGL commands issued by your
application.
Drawable Objects
A drawable object refers to an object allocated by the windowing system that can serve as an OpenGL
framebuffer. A drawable object is the destination for OpenGL drawing operations. The behavior of drawable
objects is not part of the OpenGL specification, but is defined by the OS X windowing system.
A drawable object can be any of the following: a Cocoa view, offscreen memory, a full-screen graphics device,
or a pixel buffer.
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
25Note: A pixel buffer (pbuffer) is an OpenGL buffer designed for hardware-accelerated offscreen
drawing and as a source for texturing. An application can render an image into a pixel buffer and
then use the pixel buffer as a texture for other OpenGL commands. Although pixel buffers are
supported on Apple’s implementation of OpenGL, Apple recommends you use framebuffer objects
instead. See “Drawing Offscreen” (page 53) for more information on offscreen rendering.
Before OpenGL can draw to a drawable object, the object must be attached to a rendering context. The
characteristics of the drawable object narrow the selection of hardware and software specified by the rendering
context. Apple’s OpenGL automatically allocates buffers, creates surfaces, and specifies which renderer is the
current renderer.
The logical flow of data from an application through OpenGL to a drawable object is shown in Figure 1-7. The
application issues OpenGL commands that are sent to the current rendering context. The current context,
which contains state information, constrains how the commands are interpreted by the appropriate renderer.
The renderer converts the OpenGL primitives to an image in the framebuffer. (See also “Running an OpenGL
Program in OS X ” (page 31).)
Figure 1-7 Data flow through OpenGL
Rendered Image
Application
Possible renderers
OpenGL
buffers
Current
Drawable
objects
CONTEXT
Virtual Screens
The characteristics and quality of the OpenGL content that the user sees depend on both the renderer and
the physical display used to view the content. The combination of renderer and physical display is called a
virtual screen. This important concept has implications for any OpenGL application running on OS X.
A simple system, with one graphics card and one physical display, typically has two virtual screens. One virtual
screen consists of a hardware-based renderer and the physical display and the other virtual screen consists of
a software-based renderer and the physical display. OS X provides a software-based renderer as a fallback. It's
possible for your application to decline the use of thisfallback. You'llsee how in “Choosing Renderer and Buffer
Attributes” (page 64).
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
26The green rectangle around the OpenGL image in Figure 1-8 surrounds a virtual screen for a system with one
graphics card and one display. Note that a virtual screen is not the physical display, which is why the green
rectangle is drawn around the application window thatshowsthe OpenGL content. In this case, it isthe renderer
provided by the graphics card combined with the characteristics of the display.
Figure 1-8 A virtual screen displays what the user sees
Graphics card
Virtual screen
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
27Because a virtual screen is not simply the physical display, a system with one display can use more than one
virtualscreen at a time, asshown in Figure 1-9. The green rectangles are drawn to point out each virtualscreen.
Imagine that the virtual screen on the right side uses a software-only renderer and that the one on the left
uses a hardware-dependent renderer. Although this is a contrived example, it illustrates the point.
Figure 1-9 Two virtual screens
Graphics card
Virtual screen 2
(Software renderer)
Virtual screen 1
(Hardware renderer)
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
28It's also possible to have a virtualscreen that can represent more than one physical display. The green rectangle
in Figure 1-10 is drawn around a virtual screen that spans two physical displays. In this case, the same graphics
hardware drives a pair of identical displays. A mirrored display also has a single virtual screen associated with
multiple physical displays.
Figure 1-10 A virtual screen can represent more than one physical screen
Dual-headed
graphics card
Identical displays Virtual screen
The concept of a virtualscreen is particularly important when the user drags an image from one physicalscreen
to another. When this happens, the virtual screen may change, and with it, a number of attributes of the
imaging process, such as the current renderer, may change. With the dual-headed graphics card shown in
Figure 1-10 (page 29), dragging between displays preserves the same virtual screen. However, Figure 1-11
shows the case for which two displays represent two unique virtual screens. Not only are the two graphics
cards different, but it's possible that the renderer, buffer attributes, and pixel characteristics are different. A
change in any of these three items can result in a change in the virtual screen.
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
29When the user drags an image from one display to another, and the virtualscreen isthe same for both displays,
the image quality should appear similar. However, for the case shown in Figure 1-11, the image quality can be
quite different.
Figure 1-11 Two virtual screens and two graphics cards
Graphics card 1
Graphics card 2
Virtual screen 1 Virtual screen 2
OpenGL for OS X transparently manages rendering across multiple monitors. A user can drag a window from
one monitor to another, even though their display capabilities may be different or they may be driven by
dissimilar graphics cards with dissimilar resolutions and color depths.
OpenGL dynamically switches renderers when the virtual screen that contains the majority of the pixels in an
OpenGL window changes. When a window issplit between multiple virtualscreens, the framebuffer israsterized
entirely by the renderer driving the screen that contains the largest segment of the window. The regions of
the window on the other virtual screens are drawn by copying the rasterized image. When the entire OpenGL
drawable object is displayed on one virtual screen, there is no performance impact from multiple monitor
support.
Applications need to track virtual screen changes and, if appropriate, update the current application state to
reflect changes in renderer capabilities. See “Working with Rendering Contexts” (page 72).
OpenGL on the Mac Platform
Terminology
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
30Offline Renderer
An offline renderer is one that is not currently associated with a display. For example, a graphics processor
might be powered down to conserve power, or there might not be a display hooked up to the graphics card.
Offline renderers are not normally visible to your application, but your application can enable them by adding
the appropriate renderer attribute. Taking advantage of offline renderers is useful because it gives the user a
seamless experience when they plug in or remove displays.
For more information about configuring a context to see offline renderers, see “Choosing Renderer and Buffer
Attributes” (page 64). To enable your application to switch to a renderer when a display is attached,see “Update
the Rendering Context When the Renderer or Geometry Changes” (page 72).
Running an OpenGL Program in OS X
Figure 1-12 shows the flow of data in an OpenGL program, regardless of the platform that the program runs
on.
Figure 1-12 The flow of data through OpenGL
Rasterization
Fragment shading
and per-fragment
operations
Per-pixel
operations
Texture
assembly
Framebuffer
Vertex shading
and per-vertex
operations
Pixel data
Vertex data
Per-vertex operations include such things as applying transformation matrices to add perspective or to clip,
and applying lighting effects. Per-pixel operations include such things as color conversion and applying blur
and distortion effects. Pixels destined for textures are sent to texture assembly, where OpenGL stores textures
until it needs to apply them onto an object.
OpenGL rasterizesthe processed vertex and pixel data, meaning that the data are converged to create fragments.
A fragment encapsulates all the values for a pixel, including color, depth, and sometimes texture values. These
values are used during antialiasing and any other calculations needed to fill shapes and to connect vertices.
OpenGL on the Mac Platform
Running an OpenGL Program in OS X
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
31Per-fragment operations include applying environment effects, depth and stencil testing, and performing
other operations such as blending and dithering. Some operations—such as hidden-surface removal—end
the processing of a fragment. OpenGL draws fully processed fragments into the appropriate location in the
framebuffer.
The dashed arrows in Figure 1-12 indicate reading pixel data back from the framebuffer. They represent
operations performed byOpenGL functionssuch as glReadPixels, glCopyPixels, and glCopyTexImage2D.
So far you've seen how OpenGL operates on any platform. But how do Cocoa applications provide data to the
OpenGL for processing? A Mac application must perform these tasks:
● Set up a list of buffer and renderer attributes that define the sort of drawing you want to perform. (See
“Renderer and Buffer Attributes” (page 24).)
● Request the system to create a pixel format object that contains a pixel format that meets the constraints
of the buffer and render attributes and a list of all suitable combinations of displays and renderers. (See
“Pixel Format Objects” (page 24) and “Virtual Screens” (page 26).)
● Create a rendering context to hold state information that controls such things as drawing color, view and
projection matrices, characteristics of light, and conventions used to pack pixels. When you set up this
context, you must provide a pixel format object because the rendering context needs to know the set of
virtual screens that can be used for drawing. (See “Rendering Contexts” (page 25).)
● Bind a drawable object to the rendering context. The drawable object is what capturesthe OpenGL drawing
sent to that rendering context. (See “Drawable Objects” (page 25).)
● Make the rendering context the current context. OpenGL automatically targets the current context.
Although your application might have several rendering contexts set up, only the current one is the active
one for drawing purposes.
●
Issue OpenGL drawing commands.
● Flush the contents of the rendering context. This causes previously submitted commands to be rendered
to the drawable object and displays them to the user.
The tasks described in the first five bullet items are platform-specific. “Drawing to a Window or View” (page
35) provides simple examples of how to perform them. As you read other parts of this document, you'll see
there are a number of other tasks that, although not mandatory for drawing, are really quite necessary for any
application that wantsto use OpenGL to perform complex 3D drawing efficiently on a wide variety of Macintosh
systems.
OpenGL on the Mac Platform
Running an OpenGL Program in OS X
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
32Making Great OpenGL Applications on the Macintosh
OpenGL lets you create applications with outstanding graphics performance as well as a great user
experience—but neither of these things come for free. Your application performs best when it works with
OpenGL rather than against it. With that in mind, here are guidelines you should follow to create
high-performance, future-looking OpenGL applications:
● Ensure your application runs successfully with offline renderers and multiple graphics cards.
Apple ships many sophisticated hardware configurations. Your application should handle renderer changes
seamlessly. You should test your application on a Mac with multiple graphics processors and include tests
for attaching and removing displays. For more information on how to implement hot plugging correctly,
see “Working with Rendering Contexts” (page 72)
● Avoid finishing and flushing operations.
Pay particular attention to OpenGL functions that force previously submitted commands to complete.
Synchronizing the graphics hardware to the CPU may result in dramatically lower performance. Performance
is covered in detail in “OpenGL Application Design Strategies” (page 89).
● Use multithreading to improve the performance of your OpenGL application.
Many Macs support multiple simultaneous threads of execution. Your application should take advantage
of concurrency. Well-behaved applications can take advantage of concurrency in just a few line of code.
See “Concurrency and OpenGL” (page 148).
● Use buffer objects to manage your data.
Vertex buffer objects (VBOs) allow OpenGL to manage your application’s vertex data. Using vertex buffer
objects gives OpenGL more opportunities to cache vertex data in a format that is friendly to the graphics
hardware, improving application performance. For more information see “Best Practices for Working with
Vertex Data” (page 104).
Similarly, pixel buffer objects (PBOs) should be used to manage your image data. See “Best Practices for
Working with Texture Data” (page 118)
● Use framebuffer objects (FBOs) when you need to render to offscreen memory.
Framebuffer objects allow your application to create offscreen rendering targets without many of the
limitations of platform-dependent interfaces. See “Rendering to a Framebuffer Object” (page 53).
● Generate objects before binding them.
Earlier version of OpenGL allowed your applications to create its own object names before binding them.
However, you should avoid this. Always use the OpenGL API to generate object names.
● Migrate your OpenGL Applications to OpenGL 3.2
OpenGL on the Mac Platform
Making Great OpenGL Applications on the Macintosh
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
33The OpenGL 3.2 Core profile provides a clean break from earlier versions of OpenGL in favor of a simpler
shader-based pipeline. For better compatibility with future hardware and OS X releases, migrate your
applications away from legacy versions of OpenGL. Many of the recommendationslisted above are required
when your application uses OpenGL 3.2.
● Harness the power of Apple’s development tools.
Apple provides many toolsthat help create OpenGL applications and analyze and tune their performance.
Learning how to use these tools helps you create fast, reliable applications. “Tuning Your OpenGL
Application” (page 155) describes many of these tools.
OpenGL on the Mac Platform
Making Great OpenGL Applications on the Macintosh
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
34The OpenGL programming interface provides hundreds of drawing commands that drive graphics hardware.
It doesn't provide any commands that interface with the windowing system of an operating system. Without
a windowing system, the 3D graphics of an OpenGL program are trapped inside the GPU. Figure 2-1 shows a
cube drawn to a Cocoa view.
Figure 2-1 OpenGL content in a Cocoa view
This chapter shows how to display OpenGL drawing onscreen using the APIs provided by OS X. (This chapter
does not show how to use GLUT.) The first section describes the overall approach to drawing onscreen and
provides an overview of the functions and methods used by each API.
General Approach
To draw your content to a view or a layer, your application uses the NSOpenGL classes from within the Cocoa
application framework. While the CGL API is used by your applications only to create full-screen content, every
NSOpenGLContext object contains a CGL context object. This object can be retrieved from the
NSOpenGLContext when your application needs to reference it directly. To show the similarities between the
two, this chapter discusses both the NSOpenGL classes and the CGL API.
To draw OpenGL content to a window or view using the NSOpenGL classes, you need to perform these tasks:
1. Set up the renderer and buffer attributes that support the OpenGL drawing you want to perform.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
35
Drawing to a Window or ViewEach of the OpenGL APIs in OS X has its own set of constants that represent renderer and buffer attributes.
For example, the all-renderers attribute is represented by the NSOpenGLPFAAllRenderers constant in
Cocoa and the kCGLPFAAllRenderers constant in the CGL API.
2. Request, from the operating system, a pixel format object that encapsulates pixel storage information and
the renderer and buffer attributes required by your application. The returned pixel format object contains
all possible combinations of renderers and displays available on the system that your program runs on
and that meets the requirements specified by the attributes. The combinations are referred to as virtual
screens. (See “Virtual Screens” (page 26).)
There may be situationsfor which you want to ensure that your program uses a specific renderer. “Choosing
Renderer and Buffer Attributes” (page 64) discusses how to set up an attributes array that guarantees the
system passes back a pixel format object that uses only that renderer.
If an error occurs, your application may receive a NULL pixel format object. Your application must handle
this condition.
3. Create a rendering context and bind the pixel format object to it. The rendering context keeps track of
state information that controls such things as drawing color, view and projection matrices, characteristics
of light, and conventions used to pack pixels.
Your application needs a pixel format object to create a rendering context.
4. Release the pixel format object. Once the pixel format object is bound to a rendering context, itsresources
are no longer needed.
5. Bind a drawable object to the rendering context. For a windowed context, this is typically a Cocoa view.
6. Make the rendering context the current context. The system sends OpenGL drawing to whichever rendering
context is designated as the current one. It's possible for you to set up more than one rendering context,
so you need to make sure that the one you want to draw to is the current one.
7. Perform your drawing.
The specific functions or methods that you use to perform each of the steps are discussed in the sections that
follow.
Drawing to a Cocoa View
There are two ways to draw OpenGL content to a Cocoa view. If your application has modest drawing
requirements, then you can use the NSOpenGLView class. See “Drawing to an NSOpenGLView Class: A
Tutorial” (page 37).
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
36If your application is more complex and needs to support drawing to multiple rendering contexts, you may
want to consider subclassing the NSView class. For example, if your application supports drawing to multiple
views at the same time, you need to set up a custom NSView class. See “Drawing OpenGL Content to a Custom
View” (page 40).
Drawing to an NSOpenGLView Class: A Tutorial
The NSOpenGLView class is a lightweight subclass of the NSView class that provides convenience methods
for setting up OpenGL drawing. An NSOpenGLView object maintains an NSOpenGLPixelFormat object and
an NSOpenGLContext object into which OpenGL calls can be rendered. It provides methods for accessing
and managing the pixel format object and the rendering context, and handles notification of visible region
changes.
An NSOpenGLView object does notsupportsubviews. You can, however, divide the view into multiple rendering
areas using the OpenGL function glViewport.
This section provides step-by-step instructions for creating a simple Cocoa application that draws OpenGL
content to a view. The tutorial assumes that you know how to use Xcode and Interface Builder. If you have
never created an application using the Xcode development environment, see Getting Started with Tools.
1. Create a Cocoa application project named Golden Triangle.
2. Add the OpenGL framework to your project.
3. Add a new file to your project using the Objective-C class template. Name the file MyOpenGLView.m and
create a header file for it.
4. Open the MyOpenGLView.h file and modify the file so that it looks like the code shown in Listing 2-1 to
declare the interface.
Listing 2-1 The interface for MyOpenGLView
#import
@interface MyOpenGLView : NSOpenGLView
{
}
- (void) drawRect: (NSRect) bounds;
@end
5. Save and close the MyOpenGLView.h file.
6. Open the MyOpenGLView.m file and include the gl.h file, as shown in Listing 2-2.
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
37Listing 2-2 Include OpenGL/gl.h
#import "MyOpenGLView.h"
#include
@implementation MyOpenGLView
@end
7. Implement the drawRect: method asshown in Listing 2-3, adding the code after the @implementation
statement. The method sets the clear color to black and clears the color buffer in preparation for drawing.
Then, drawRect: calls your drawing routine, which you’ll add next. The OpenGL command glFlush
draws the content provided by your routine to the view.
Listing 2-3 The drawRect: method for MyOpenGLView
-(void) drawRect: (NSRect) bounds
{
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
drawAnObject();
glFlush();
}
8. Add the code to perform your drawing. In your own application, you'd perform whatever drawing is
appropriate. But for the purpose of learning how to draw OpenGL content to a view, add the code shown
in Listing 2-4. This code draws a 2D, gold-colored triangle, whose dimensions are not quite the dimensions
of a true golden triangle, but good enough to show how to perform OpenGL drawing.
Make sure that you insert this routine before the drawRect: method in the MyOpenGLView.m file.
Listing 2-4 Code that draws a triangle using OpenGL commands
static void drawAnObject ()
{
glColor3f(1.0f, 0.85f, 0.35f);
glBegin(GL_TRIANGLES);
{
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
38glVertex3f( 0.0, 0.6, 0.0);
glVertex3f( -0.2, -0.3, 0.0);
glVertex3f( 0.2, -0.3 ,0.0);
}
glEnd();
}
9. Open the MainMenu.xib in Interface Builder.
10. Change the window’s title to Golden Triangle.
11. Drag an NSOpenGLView object from the Library to the window. Resize the view to fit the window.
12. Change the class of this object to MyOpenGLView.
13. Open the Attributes pane of the inspector for the view, and take a look at the renderer and buffer attributes
that are available to set. These settings save you from setting attributes programmatically.
Only those attributes listed in the Interface Builder inspector are set when the view is instantiated. If you
need additional attributes, you need to set them programmatically.
14. Build and run your application. You should see content similar to the triangle shown in Figure 2-2.
Figure 2-2 The output from the Golden Triangle program
This example is extremely simple. In a more complex application, you'd want to do the following:
● Replace the immediate-mode drawing commands with commands that persist your vertex data inside
OpenGL. See “OpenGL Application Design Strategies” (page 89).
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
39●
In the interface for the view, declare a variable that indicates whether the view is ready to accept drawing.
A view is ready for drawing only if it is bound to a rendering context and that context is set to be the
current one.
● Cocoa does not call initialization routines for objects created in Interface Builder. If you need to perform
any initialization tasks, do so in the awakeFromNib method for the view. Note that because you set
attributes in the inspector, there is no need to set them up programmatically unless you need additional
ones. There is also no need to create a pixel format object programmatically; it is created and loaded when
Cocoa loads the nib file.
● Your drawRect: method should test whether the view is ready to draw into. You need to provide code
that handles the case when the view is not ready to draw into.
● OpenGL is at its best when doing real-time and interactive graphics. Your application needs to provide a
timer or support user interaction. For more information about creating animation in your OpenGL
application, see “Synchronize with the Screen Refresh Rate” (page 96).
Drawing OpenGL Content to a Custom View
This section provides an overview of the key tasks you need to perform to customize the NSView class for
OpenGL drawing. Before you create a custom view for OpenGL drawing, you should read “Creating a Custom
View” in View Programming Guide .
When you subclass the NSView class to create a custom view for OpenGL drawing, you override any Quartz
drawing or other content that is in that view. To set up a custom view for OpenGL drawing, subclass NSView
and create two private variables—one which is an NSOpenGLContext object and the other an
NSOpenGLPixelFormat object, as shown in Listing 2-5.
Listing 2-5 The interface for a custom OpenGL view
@class NSOpenGLContext, NSOpenGLPixelFormat;
@interface CustomOpenGLView : NSView
{
@private
NSOpenGLContext* _openGLContext;
NSOpenGLPixelFormat* _pixelFormat;
}
+ (NSOpenGLPixelFormat*)defaultPixelFormat;
- (id)initWithFrame:(NSRect)frameRect pixelFormat:(NSOpenGLPixelFormat*)format;
- (void)setOpenGLContext:(NSOpenGLContext*)context;
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
40- (NSOpenGLContext*)openGLContext;
- (void)clearGLContext;
- (void)prepareOpenGL;
- (void)update;
- (void)setPixelFormat:(NSOpenGLPixelFormat*)pixelFormat;
- (NSOpenGLPixelFormat*)pixelFormat;
@end
In addition to the usual methods for the private variables (openGLContext, setOpenGLContext:,
pixelFormat, and setPixelFormat:) you need to implement the following methods:
● + (NSOpenGLPixelFormat*) defaultPixelFormat
Use this method to allocate and initialize the NSOpenGLPixelFormat object.
● - (void) clearGLContext
Use this method to clear and release the NSOpenGLContext object.
● - (void) prepareOpenGL
Use this method to initialize the OpenGL state after creating the NSOpenGLContext object.
You need to override the update and initWithFrame: methods of the NSView class.
● update calls the update method of the NSOpenGLContext class.
● initWithFrame:pixelFormat retains the pixel format and sets up the notification
NSViewGlobalFrameDidChangeNotification. See Listing 2-6.
Listing 2-6 The initWithFrame:pixelFormat: method
- (id)initWithFrame:(NSRect)frameRect pixelFormat:(NSOpenGLPixelFormat*)format
{
self = [super initWithFrame:frameRect];
if (self != nil) {
_pixelFormat = [format retain];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(_surfaceNeedsUpdate:)
name:NSViewGlobalFrameDidChangeNotification
object:self];
}
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
41return self;
}
- (void) _surfaceNeedsUpdate:(NSNotification*)notification
{
[self update];
}
If the custom view is not guaranteed to be in a window, you must also override the lockFocus method of
the NSView class. See Listing 2-7. This method makes sure that the view is locked prior to drawing and that
the context is the current one.
Listing 2-7 The lockFocus method
- (void)lockFocus
{
NSOpenGLContext* context = [self openGLContext];
[super lockFocus];
if ([context view] != self) {
[context setView:self];
}
[context makeCurrentContext];
}
The reshape method is not supported by the NSView class. You need to update bounds in the drawRect:
method, which should take the form shown in Listing 2-8.
Listing 2-8 The drawRect method for a custom view
-(void) drawRect
{
[context makeCurrentContext];
//Perform drawing here
[context flushBuffer];
}
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
42There may be other methods that you want to add. For example, you might consider detaching the context
from the drawable object when the custom view is moved from the window, as shown in Listing 2-9.
Listing 2-9 Detaching the context from a drawable object
-(void) viewDidMoveToWindow
{
[super viewDidMoveToWindow];
if ([self window] == nil)
[context clearDrawable];
}
Drawing to a Window or View
Drawing to a Cocoa View
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
43OpenGL is a pixel-based API so the NSOpenGLView class does not provide high-resolution surfaces by default.
Because adding more pixelsto renderbuffers has performance implications, you must explicitly opt in to support
high-resolution screens. It’s easy to enable high-resolution backing for an OpenGL view. When you do, you’ll
want to perform a few additional tasks to ensure the best possible high-resolution experience for your users.
Enable High-Resolution Backing for an OpenGL View
You can opt in to high resolution by calling the method setWantsBestResolutionOpenGLSurface: when
you initialize the view, and supplying YES as an argument:
[self setWantsBestResolutionOpenGLSurface:YES];
If you don’t opt in, the system magnifies the rendered results.
The wantsBestResolutionOpenGLSurface property is relevant only for views to which an
NSOpenGLContext object is bound. Its value does not affect the behavior of other views. For compatibility,
wantsBestResolutionOpenGLSurface defaultsto NO, providing a 1-pixel-per-point framebuffer regardless
of the backing scale factor for the display the view occupies. Setting this property to YES for a given view
causes AppKit to allocate a higher-resolution framebuffer when appropriate for the backing scale factor and
target display.
To function correctly with wantsBestResolutionOpenGLSurface set to YES, a view must perform correct
conversions between view units (points) and pixel units as needed. For example, the common practice of
passing the width and height of [self bounds] to glViewport() will yield incorrect results at high resolution,
because the parameters passed to the glViewport() function must be in pixels. As a result, you’ll get only
partial instead of complete coverage of the render surface. Instead, use the backing store bounds:
[self convertRectToBacking:[self bounds]];
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
44
Optimizing OpenGL for High ResolutionYou can also opt in to high resolution by enabling the Supports Hi-Res Backing setting for the OpenGL view
in Xcode, as shown in Figure 3-1.
Figure 3-1 Enabling high-resolution backing for an OpenGL view
Set Up the Viewport to Support High Resolution
The viewport dimensions are in pixelsrelative to the OpenGL surface. Passthe width and height to glViewPort
and use 0,0 for the x and y offsets. Listing 3-1 shows how to get the view dimensions in pixels and take the
backing store size into account.
Listing 3-1 Setting up the viewport for drawing
- (void)drawRect:(NSRect)rect // NSOpenGLView subclass
{
// Get view dimensions in pixels
NSRect backingBounds = [self convertRectToBacking:[self bounds]];
Optimizing OpenGL for High Resolution
Set Up the Viewport to Support High Resolution
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
45GLsizei backingPixelWidth = (GLsizei)(backingBounds.size.width),
backingPixelHeight = (GLsizei)(backingBounds.size.height);
// Set viewport
glViewport(0, 0, backingPixelWidth, backingPixelHeight);
// draw…
}
You don’t need to perform rendering in pixels, but you do need to be aware of the coordinate system you
want to render in. For example, if you want to render in points, this code will work:
glOrtho(NSWidth(bounds), NSHeight(bounds),...)
Adjust Model and Texture Assets
If you opt in to high-resolution drawing, you also need to adjust the model and texture assets of your app. For
example, when running on a high-resolution display, you might want to choose larger models and more
detailed textures to take advantage of the increased number of pixels. Conversely, on a standard-resolution
display, you can continue to use smaller models and textures.
If you create and cache textures when you initialize your app, you might want to consider a strategy that
accommodates changing the texture based on the resolution of the display.
Check for Calls Defined in Pixel Dimensions
These functions use pixel dimensions:
● glViewport (GLint x, GLint y, GLsizei width, GLsizei height)
● glScissor (GLint x, GLint y, GLsizei width, GLsizei height)
● glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, ...)
● glLineWidth (GLfloat width)
● glRenderbufferStorage (..., GLsizei width, GLsizei height)
● glTexImage2D (..., GLsizei width, GLsizei height, ...)
Optimizing OpenGL for High Resolution
Adjust Model and Texture Assets
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
46Tune OpenGL Performance for High Resolution
Performance is an important factor when determining whether to support high-resolution content. The
quadrupling of pixels that occurs when you opt in to high resolution requires more work by the fragment
processor. If your app performs many per-fragment calculations, the increase in pixels might reduce its frame
rate. If your app runs significantly slower at high resolution, consider the following options:
● Optimize fragment shader performance. (See “Tuning Your OpenGL Application” (page 155).)
● Choose a simpler algorithm to implement in your fragment shader. This reduces the quality of each
individual pixel to allow for rendering the overall image at a higher resolution.
● Use a fractional scale factor between 1.0 and 2.0. A scale factor of 1.5 provides better quality than a scale
factor of 1.0, but it needs to fill fewer pixels than an image scaled to 2.0.
● Multisampling antialiasing can be costly with marginal benefit at high resolution. If you are using it, you
might want to reconsider.
The best solution depends on the needs of your OpenGL app; you should test more than one of these options
and choose the approach that provides the best balance between performance and image quality.
Optimizing OpenGL for High Resolution
Tune OpenGL Performance for High Resolution
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
47Use a Layer-Backed View to Overlay Text on OpenGL Content
When you draw standard controls and Cocoa text to a layer-backed view, the system handles scaling the
contents of that layer for you. You need to perform only a few steps to set and use the layer. Compare the
controls and text in standard and high resolutions, as shown in Figure 3-2. The text looks the same on both
without any additional work on your part.
Figure 3-2 A text overlay scales automatically for standard resolution (left) and high resolution (right)
To set up a layer-backed view for OpenGL content
1. Set the wantsLayer property of your NSOpenGLView subclass to YES.
Enabling the wantsLayer property of an NSOpenGLView object activates layer-backed rendering of
the OpenGL view. Drawing a layer-backed OpenGL view proceeds mostly normally through the view’s
drawRect: method. The layer-backed rendering mode usesits own NSOpenGLContext object, which
is distinct from the NSOpenGLContext that the view uses for drawing in non-layer-backed mode.
AppKit automatically creates this context and assigns it to the view by invoking the
setOpenGLContext: method. The view’s openGLContext accessor will return the layer-backed
OpenGL context (rather than the non-layer-backed context) while the view is operating in layer-backed
mode.
Optimizing OpenGL for High Resolution
Use a Layer-Backed View to Overlay Text on OpenGL Content
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
482. Create the layer content either as a XIB file or programmatically.
The controls shown in Figure 3-2 were created in a XIB file by subclassing NSBox and using static text
with a variety of standard controls. Using this approach allows the NSBox subclass to ignore mouse
events while still allowing the user to interact with the OpenGL content.
3. Add the layer to the OpenGL view by calling the addSublayer: method.
Use an Application Window for Fullscreen Operation
For the best user experience, if you want your app to run full screen, create a window that covers the entire
screen. This approach offers two advantages:
● The system provides optimized context performance.
● Users will be able to see critical system dialogs above your content.
You should avoid changing the display mode of the system.
Convert the Coordinate Space When Hit Testing
Always convert window event coordinates when performing hit testing in OpenGL. The locationInWindow
method of the NSEvent class returns the receiver’s location in the base coordinate system of the window. You
then need to call the convertPoint:fromView: method to get the local coordinates for the OpenGL view.
NSPoint aPoint = [theEvent locationInWindow];
NSPoint localPoint = [myOpenGLView convertPoint:aPoint fromView:nil];
Optimizing OpenGL for High Resolution
Use an Application Window for Fullscreen Operation
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
49In OS X, you have the option to draw to the entire screen. This is a common scenario for games and other
immersive applications, and OS X applies additional optimizations to improve the performance of full-screen
contexts.
Figure 4-1 Drawing OpenGL content to the full screen
OS X v10.6 and later automatically optimize the performance ofscreen-sized windows, allowing your application
to take complete advantage of the window server environment on OS X. For example, critical operating system
dialogs may be displayed over your content when necessary.
For information about high-resolution and full-screen drawing, see “Use an Application Window for Fullscreen
Operation” (page 49).
Creating a Full-Screen Application
Creating a full-screen context is very simple. Your application should follow these steps:
1. Create a screen-sized window on the display you want to take over:
NSRect mainDisplayRect = [[NSScreen mainScreen] frame];
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
50
Drawing to the Full ScreenNSWindow *fullScreenWindow = [[NSWindow alloc] initWithContentRect:
mainDisplayRect styleMask:NSBorderlessWindowMask
backing:NSBackingStoreBuffered defer:YES];
2. Set the window level to be above the menu bar.:
[fullScreenWindow setLevel:NSMainMenuWindowLevel+1];
3. Perform any other window configuration you desire:
[fullScreenWindow setOpaque:YES];
[fullScreenWindow setHidesOnDeactivate:YES];
4. Create a view with a double-buffered OpenGL context and attach it to the window:
NSOpenGLPixelFormatAttribute attrs[] =
{
NSOpenGLPFADoubleBuffer,
0
};
NSOpenGLPixelFormat* pixelFormat = [[NSOpenGLPixelFormat alloc]
initWithAttributes:attrs];
NSRect viewRect = NSMakeRect(0.0, 0.0, mainDisplayRect.size.width,
mainDisplayRect.size.height);
MyOpenGLView *fullScreenView = [[MyOpenGLView alloc] initWithFrame:viewRect
pixelFormat: pixelFormat];
[fullScreenWindow setContentView: fullScreenView];
5. Show the window:
[fullScreenWindow makeKeyAndOrderFront:self];
That’s all you need to do. Your content is in a window that is above most other content, but because it is in a
window, OS X can still show critical UI elements above your content when necessary (such as error dialogs).
When there is no content above your full-screen window, OS X automatically attemptsto optimize this context’s
performance. For example, when your application calls flushBuffer on the NSOpenGLContext object, the
Drawing to the Full Screen
Creating a Full-Screen Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
51system may swap the buffers rather than copying the contents of the back buffer to the front buffer. These
performance optimizations are not applied when your application adds the NSOpenGLPFABackingStore
attribute to the context. Because the system may choose to swap the buffers rather than copy them, your
application must completely redraw the scene after every call to flushBuffer. For more information on
NSOpenGLPFABackingStore, see “Ensuring That Back Buffer Contents Remain the Same” (page 66).
Avoid changing the display resolution from that chosen by the user. If your application needs to render data
at a lower resolution for performance reasons, you can explicitly create a back buffer at the desired resolution
and allow OpenGL to scale those results to the display. See “Controlling the Back Buffer Size” (page 78).
Drawing to the Full Screen
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
52OpenGL applications may want to use OpenGL to render images without actually displaying them to the user.
For example, an image processing application might render the image, then copy that image back to the
application and save it to disk. Another useful strategy is to create intermediate images that are used later to
render additional content. For example, your application might want to render an image and use it as a texture
in a future rendering pass. For best performance, offscreen targets should be managed by OpenGL. Having
OpenGL manage offscreen targets allows you to avoid copying pixel data back to your application, except
when this is absolutely necessary.
OS X offers two useful options for creating offscreen rendering targets:
● Framebuffer objects. The OpenGL framebuffer extension allows your application to create fully supported
offscreen OpenGL framebuffers. Framebuffer objects are fully supported as a cross-platform extension, so
they are the preferred way to create offscreen rendering targets. See “Rendering to a Framebuffer
Object” (page 53).
● Pixel buffer drawable objects. Pixel buffer drawable objects are an Apple-specific technology for creating
an offscreen target. Each of the Apple-specific OpenGL APIs provides routines to create an offscreen
hardware accelerated pixel buffer. Pixel buffers are recommended for use only when framebuffer objects
are not available. See “Rendering to a Pixel Buffer” (page 60).
Rendering to a Framebuffer Object
The OpenGL framebuffer extension (GL_EXT_framebuffer_object) allows applications to create offscreen
rendering targets from within OpenGL. OpenGL manages the memory for these framebuffers.
Note: Extensions are available on a per-renderer basis. Before you use framebuffer objects you must
check each renderer to make sure that itsupportsthe extension. See “Detecting Functionality” (page
83) for more information.
A framebuffer object(FBO) issimilar to a drawable object, except a drawable object is a window-system-specific
object, whereas a framebuffer object is a window-agnostic object that's defined in the OpenGL standard. After
drawing to a framebuffer object, it is straightforward to read the pixel data to the application, or to use it as
source data for other OpenGL commands.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
53
Drawing OffscreenFramebuffer objects offer a number of benefits:
● They are window-system independent, which makes porting code easier.
● They are easy to set up and save memory. There is no need to set up attributes and obtain a pixel format
object.
● They are associated with a single OpenGL context, whereas each pixel buffer must be bound to a context.
● You can switch between them faster since there is no context switch as with pixel buffers. Because all
commands are rendered by a single context, no additional serialization is required.
● They can share depth buffers; pixel buffers cannot.
● You can use them for 2D pixel images and texture images.
Completeness is a key concept to understanding framebuffer objects. Completeness is a state that indicates
whether a framebuffer object meets all the requirements for drawing. You test for this state after performing
all the necessary setup work. If a framebuffer object is not complete, it cannot be used as the destination for
rendering operations and as a source for read operations.
Completeness is dependent on many factors that are not possible to condense into one or two statements,
but these factors are thoroughly defined in the OpenGL specification for the framebuffer object extension. The
specification describes the requirements for internal formats of images attached to the framebuffer, how to
determine if a format is color-, depth-, and stencil-renderable, as well as other requirements.
Prior to using framebuffer objects, read the OpenGL specification, which not only defines the framebuffer
object API, but provides detailed definitions of all the terms necessary to understand their use and shows
several code examples.
The remainder of thissection provides an overview of how to use a framebuffer as either a texture or an image.
The functions used to set up textures and images are slightly different. The API for images usesthe renderbuffer
terminology defined in the OpenGL specification. A renderbuffer image is simply a 2D pixel image. The API
for textures uses texture terminology, as you might expect. For example, one of the calls for setting up a
framebuffer object for a texture is glFramebufferTexture2DEXT, whereasthe call forsetting up a framebuffer
object for an image is glFramebufferRenderbufferEXT. You'll see how to set up a simple framebuffer
object for each type of drawing, starting first with textures.
Using a Framebuffer Object as a Texture
These are the basic steps needed to set up a framebuffer object for drawing a texture offscreen:
1. Make sure the framebuffer extension (GL_EXT_framebuffer_object) is supported on the system that
your code runs on. See “Determining the OpenGL Capabilities Supported by the Renderer” (page 83).
Drawing Offscreen
Rendering to a Framebuffer Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
542. Check the renderer limits. For example, you might want to call the OpenGL function glGetIntegerv to
check the maximum texture size (GL_MAX_TEXTURE_SIZE) or find out the maximum number of color
buffers you can attach to the framebuffer object(GL_MAX_COLOR_ATTACHMENTS_EXT).
3. Generate a framebuffer object name by calling the following function:
void glGenFramebuffersEXT (GLsizei n, GLuint *ids);
n is the number of framebuffer object names that you want to create.
On return, *ids points to the generated names.
4. Bind the framebuffer object name to a framebuffer target by calling the following function:
void glBindFramebufferEXT(GLenum target, GLuint framebuffer);
target should be the constant GL_FRAMEBUFFER_EXT.
framebuffer is set to an unused framebuffer object name.
On return, the framebuffer object is initialized to the state values described in the OpenGL specification
for the framebuffer object extension. Each attachment point of the framebuffer is initialized to the
attachment point state values described in the specification. The number of attachment points is equal
to GL_MAX_COLOR_ATTACHMENTS_EXT plus 2 (for depth and stencil attachment points).
Whenever a framebuffer object is bound, drawing commands are directed to it instead of being directed
to the drawable associated with the rendering context.
5. Generate a texture name.
void glGenTextures(GLsizei n, GLuint *textures);
n is the number of texture object names that you want to create.
On return, *textures points to the generated names.
6. Bind the texture name to a texture target.
void glBindTexture(GLenum target, GLuint texture);
target is the type of texture to bind.
texture is the texture name you just created.
7. Set up the texture environment and parameters.
Drawing Offscreen
Rendering to a Framebuffer Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
558. Define the texture by calling the appropriate OpenGL function to specify the target, level of detail, internal
format, dimensions, border, pixel data format, and texture data storage.
9. Attach the texture to the framebuffer by calling the following function:
void glFramebufferTexture2DEXT (GLenum target, GLenum attachment,
GLenum textarget, GLuint texture,
GLint level);
target must be GL_FRAMEBUFFER_EXT.
attachment must be one of the attachment points of the framebuffer: GL_STENCIL_ATTACHMENT_EXT,
GL_DEPTH_ATTACHMENT_EXT, or GL_COLOR_ATTACHMENTn_EXT, where n is a number from 0 to
GL_MAX_COLOR_ATTACHMENTS_EXT-1.
textarget is the texture target.
texture is an existing texture object.
level is the mipmap level of the texture image to attach to the framebuffer.
10. Check to make sure that the framebuffer is complete by calling the following function:
GLenum glCheckFramebufferStatusEXT(GLenum target);
target must be the constant GL_FRAMEBUFFER_EXT.
This function returns a status constant. You must test to make sure that the constant is
GL_FRAMEBUFFER_COMPLETE_EXT. If it isn't, see the OpenGL specification for the framebuffer object
extension for a description of the other constants in the status enumeration.
11. Render content to the texture. You must make sure to bind a different texture to the framebuffer object
or disable texturing before you render content. If you render to a framebuffer object texture attachment
with that same texture currently bound and enabled, the result is undefined.
12. To draw the contents of the texture to a window, make the window the target of all rendering commands
by calling the function glBindFramebufferEXT and passing the constant GL_FRAMEBUFFER_EXT and
0. The window is always specified as 0.
13. Use the texture attachment as a normal texture by binding it, enabling texturing, and drawing.
14. Delete the texture.
15. Delete the framebuffer object by calling the following function:
void glDeleteFramebuffersEXT (GLsizei n, const GLuint *framebuffers);
Drawing Offscreen
Rendering to a Framebuffer Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
56n is the number of framebuffer objects to delete.
*framebuffers points to an array that contains the framebuffer object names.
Listing 5-1 shows code that performs these tasks. This example creates and draws to a single framebuffer
object.
Listing 5-1 Setting up a framebuffer for texturing
GLuint framebuffer, texture;
GLenum status;
glGenFramebuffersEXT(1, &framebuffer);
// Set up the FBO with one texture attachment
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, TEXWIDE, TEXHIGH, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, texture, 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
// Handle error here
// Your code to draw content to the FBO
// ...
// Make the window the target
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
//Your code to use the contents of the FBO
// ...
//Tear down the FBO and texture attachment
glDeleteTextures(1, &texture);
glDeleteFramebuffersEXT(1, &framebuffer);
Drawing Offscreen
Rendering to a Framebuffer Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
57Using a Framebuffer Object as an Image
There is a lot of similarity between setting up a framebuffer object for drawing images and setting one up to
draw textures. These are the basic steps needed to set up a framebuffer object for drawing a 2D pixel image
(a renderbuffer image) offscreen:
1. Make sure the framebuffer extension (EXT_framebuffer_object) is supported on the renderer that
your code runs on.
2. Check the renderer limits. For example, you might want to call the OpenGL function glGetIntegerv to
find out the maximum number of color buffers (GL_MAX_COLOR_ATTACHMENTS_EXT).
3. Generate a framebuffer object name by calling the function glGenFramebuffersEXT.
4. Bind the framebuffer object name to a framebuffer target by calling the function glBindFramebufferEXT.
5. Generate a renderbuffer object name by calling the following function:
void glGenRenderbuffersEXT (GLsizei n, GLuint *renderbuffers );
n is the number of renderbuffer object names to create.
*renderbuffers points to storage for the generated names.
6. Bind the renderbuffer object name to a renderbuffer target by calling the following function:
void glBindRenderbufferEXT (GLenum target, GLuint renderbuffer);
target must be the constant GL_RENDERBUFFER_EXT.
renderbuffer is the renderbuffer object name generated previously.
7. Create data storage and establish the pixel format and dimensions of the renderbuffer image by calling
the following function:
void glRenderbufferStorageEXT (GLenum target, GLenum internalformat,
GLsizei width, GLsizei height);
target must be the constant GL_RENDERBUFFER_EXT.
internalformat is the pixel format of the image. The value must be RGB, RGBA, DEPTH_COMPONENT,
STENCIL_INDEX, or one of the other formats listed in the OpenGL specification.
width is the width of the image, in pixels.
height is the height of the image, in pixels.
Drawing Offscreen
Rendering to a Framebuffer Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
588. Attach the renderbufferto a framebuffertarget by calling the function glFramebufferRenderbufferEXT.
void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment,
GLenum renderbuffertarget, GLuint
renderbuffer);
target must be the constant GL_FRAMEBUFFER_EXT.
attachment should be one of the attachment points of the framebuffer: GL_STENCIL_ATTACHMENT_EXT,
GL_DEPTH_ATTACHMENT_EXT, or GL_COLOR_ATTACHMENTn_EXT, where n is a number from 0 to
GL_MAX_COLOR_ATTACHMENTS_EXT–1.
renderbuffertarget must be the constant GL_RENDERBUFFER_EXT.
renderbuffer should be set to the name of the renderbuffer object that you want to attach to the
framebuffer.
9. Check to make sure that the framebuffer is complete by calling the following function:
enum glCheckFramebufferStatusEXT(GLenum target);
target must be the constant GL_FRAMEBUFFER_EXT.
This function returns a status constant. You must test to make sure that the constant is
GL_FRAMEBUFFER_COMPLETE_EXT. If it isn't, see the OpenGL specification for the framebuffer object
extension for a description of the other constants in the status enumeration.
10. Render content to the renderbuffer.
11. To access the contents of the renderbuffer object, bind the framebuffer object and then use OpenGL
functions such as glReadPixels or glCopyTexImage2D.
12. Delete the framebuffer object with its renderbuffer attachment.
Listing 5-2 shows code that sets up and draws to a single renderbuffer object. Your application can set up
more than one renderbuffer object if it requires them.
Listing 5-2 Setting up a renderbuffer for drawing images
GLuint framebuffer, renderbuffer;
GLenum status;
// Set the width and height appropriately for your image
GLuint imageWidth = 1024,
imageHeight = 1024;
Drawing Offscreen
Rendering to a Framebuffer Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
59//Set up a FBO with one renderbuffer attachment
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer);
glGenRenderbuffersEXT(1, &renderbuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, imageWidth, imageHeight);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, renderbuffer);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
// Handle errors
//Your code to draw content to the renderbuffer
// ...
//Your code to use the contents
// ...
// Make the window the target
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
// Delete the renderbuffer attachment
glDeleteRenderbuffersEXT(1, &renderbuffer);
Rendering to a Pixel Buffer
The OpenGL extension string GL_APPLE_pixel_buffer provides hardware-accelerated offscreen rendering
to a pixel buffer. A pixel buffer is typically used as a texture source. It can also be used for remote rendering.
Important: Pixel buffers are deprecated starting with OS X v10.7 and are not supported by the OpenGL
3.2 Core profile; use framebuffer objects instead.
You must create a rendering context for each pixel buffer. For example, if you want to use a pixel buffer as a
texture source, you create one rendering context attached to the pixel buffer and a second context attached
to a window or view.
The first step in using a pixel buffer is to create it. The Apple-specific OpenGL APIs each provide a routine for
this purpose:
Drawing Offscreen
Rendering to a Pixel Buffer
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
60● The NSOpenGLPixelBuffer method
initWithTextureTarget:textureInternalFormat:textureMaxMipMapLevel:pixelsWide:pixelsHigh:
● The CGL function CGLCreatePBuffer
Each of these routinesrequiresthat you provide a texture target, an internal format, a maximum mipmap level,
and the width and height of the texture.
The texture target must be one of these OpenGL texture constants: GL_TEXTURE_2D for a 2D texture,
GL_TEXTURE_RECTANGLE_ARB for a rectangular (not power-of-two) texture, or GL_TEXTURE_CUBE_MAP for
a cube map texture.
The internal format specifies how to interpret the data for texturing operations. You can supply any of these
options: GL_RGB (each pixel is a three-component group), GL_RGBA (each pixel is a four-component group),
or GL_DEPTH_COMPONENT (each pixel is a single depth component).
The maximum mipmap level should be 0 for a pixel buffer that does not have a mipmap. The value that you
supply should not exceed the actual maximum number of mipmap levels that can be represented with the
given width and height.
Note that none of the routines that create a pixel buffer allocate the storage needed. The storage is allocated
by the system at the time that you attach the pixel buffer to a rendering context.
Setting Up a Pixel Buffer for Offscreen Drawing
After you create a pixel buffer, the general procedure for using a pixel buffer for drawing is similar to the way
you set up windows and views for drawing:
1. Specify renderer and buffer attributes.
2. Obtain a pixel format object.
3. Create a rendering context and make it current.
4. Attach a pixel buffer to the context using the appropriate Apple OpenGL attachment function:
● The setPixelBuffer:cubeMapFace:mipMapLevel:currentVirtualScreen: method of the
NSOpenGLContext class instructs the receiver to render into a pixel buffer.
● The CGL function CGLSetPBuffer attaches a CGL rendering context to a pixel buffer.
5. Draw, as you normally would, using OpenGL.
Using a Pixel Buffer as a Texture Source
Pixel bufferslet you perform direct texturing without incurring the cost of extra copies. After drawing to a pixel
buffer, you can create a texture by following these steps:
Drawing Offscreen
Rendering to a Pixel Buffer
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
611. Generate a texture name by calling the OpenGL function glGenTextures.
2. Bind the named texture to a target by calling the OpenGL function glBindTexture.
3. Set the texture parameters by calling OpenGL function glTexEnvParameter.
4. Set up the pixel buffer asthe source for the texture by calling one of the following Apple OpenGL functions:
● The setTextureImageToPixelBuffer:colorBuffer: method of the NSOpenGLContext class
attaches the image data in the pixel buffer to the texture object currently bound by the receiver.
● The CGL function CGLTexImagePBuffer binds the contents of a CGL pixel buffer as the data source
for a texture object.
The context that you attach to the pixel buffer is the target rendering context: the context that uses the
pixel buffer as the source of the texture data. Each of these routines requires a source parameter, which
is an OpenGL constant that specifies the source buffer to texture from. The source parameter must be a
valid OpenGL buffer, such as GL_FRONT, GL_BACK, or GL_AUX0, and should be compatible with the buffer
attributes used to create the OpenGL context associated with the pixel buffer. This means that the pixel
buffer must possess the buffer in question for texturing to succeed. For example, if the buffer attribute
used with the pixel buffer is only single buffered, then texturing from the GL_BACK buffer will fail.
If you modify content of any pixel buffer that contains mipmap levels, you must call the appropriate Apple
OpenGL function again (setTextureImageToPixelBuffer:colorBuffer: or CGLTexImagePBuffer)
before drawing with the pixel buffer to ensure that the content issynchronized with OpenGL. To synchronize
the content of pixel buffers without mipmaps, simply rebind to the texture object using glBind.
5. Draw primitives using the appropriate texture coordinates. (See "The Red book"—OpenGL Programming
Guide—for details.)
6. Call glFlush to cause all drawing commands to be executed.
7. When you no longer need the texture object, call the OpenGL function glDeleteTextures.
8. Set the current context to NULL using one of the Apple OpenGL routines:
● The makeCurrentContext method of the NSOpenGLContext class
● The CGL function CGLSetCurrentContext
9. Destroy the pixel buffer by calling CGLDestroyPBuffer.
10. Destroy the context by calling CGLDestroyContext.
11. Destroy the pixel format by calling CGLDestroyPixelFormat.
You might find these guidelines useful when using pixel buffers for texturing:
Drawing Offscreen
Rendering to a Pixel Buffer
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
62● You cannot make OpenGL texturing calls that modify pixel buffer content (such as glTexSubImage2D or
glCopyTexImage2D) with the pixel buffer as the destination. You can use texturing commands to read
data from a pixel buffer, such as glCopyTexImage2D, with the pixel buffer texture as the source. You can
also use OpenGL functions such as glReadPixels to read the contents of a pixel buffer directly from the
pixel buffer context.
● Texturing can fail to produce the intended results without reporting an error. You must make sure that
you enable the proper texture target, set a compatible filter mode, and adhere to other requirements
described in the OpenGL specification.
● You are not required to set up contextsharing when you texture from a pixel buffer. You can have different
pixel format objects and rendering contexts for both the pixel buffer and the target drawable object,
without sharing resources, and still texture using a pixel buffer in the target context.
Rendering to a Pixel Buffer on a Remote System
Follow these steps to render to a pixel buffer on a remote system. The remote system does not need to have
a display attached to it.
1. When you set the renderer and buffer attributes, include the remote pixel buffer attribute
kCGLPFARemotePBuffer.
2. Log in to the remote machine using the ssh command to ensure security.
3. Run the application on the target system.
4. Retrieve the content.
Drawing Offscreen
Rendering to a Pixel Buffer
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
63Renderer and buffer attributes determine the renderers that the system chooses for your application. Each of
the Apple-specific OpenGL APIs provides constants that specify a variety of renderer and buffer attributes. You
supply a list of attribute constants to one of the Apple OpenGL functions for choosing a pixel format object.
The pixel format object maintains a list of renderers that meet the requirements defined by those attributes.
In a real-world application, selecting attributes is an art because you don't know the exact combination of
hardware and software that your application will run on. An attribute list that is too restrictive may miss out
on future capabilities or it may fail to return renderers on some systems. For example, if you specify a buffer
of a specific depth, your application won't be able to take advantage of a larger buffer when more memory is
available in the future. In this case, you might specify a required minimum and direct OpenGL to use the
maximum available.
Although you might specify attributes that make your OpenGL content look and run its best, you also need
to consider whether your application should run on a less-capable system with less speed or detail. If tradeoffs
are acceptable, you need to set the attributes accordingly.
OpenGL Profiles (OS X v10.7)
When your application is running on OS X v10.7, it should always include the kCGLPFAOpenGLProfile
attribute, followed by a constant for the profile whose functionality your application requires. A profile affects
different parts of OpenGL in OS X:
● A profile requires that a specific version of the OpenGL API must provided by the renderer. The renderer
may implement a different version of the OpenGL specification only if that version implements the same
functions and constants required by the profile; typically, this means a renderer that supports a later
version of the OpenGL specification that did not remove or alter behavior specified in the version of the
OpenGL specification your application requested.
● The profile alters the list of OpenGL extensions returned by the renderer. For example, extensions whose
functionality is provided by the version of the OpenGL specification you requested are not also returned
in the list of extensions.
● On OS X, the profile affects what other renderer and buffer attributes may be included in the attributes
list.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
64
Choosing Renderer and Buffer AttributesFollow these guidelines to choose an OpenGL profile:
●
If you are developing a new OS X v10.7 application, implement your OpenGL functionality using the
OpenGL 3.2 Core profile; include the kCGLOGLPVersion_3_2_Core constant.
The OpenGL 3.2 core profile is defined by Khronos and explicitly removes removes deprecated features
described in earlier versions of the OpenGL specification; further the core profile prohibits these functions
from being added back into OpenGL using extensions. OpenGL 3.2 core represents a complete break from
the fixed function pipeline of OpenGL 1.x in favor of a clean, lean shader-based pipeline.
When you use the OpenGL 3.2 Core profile on OS X, legacy extensions are removed wherever their
functionality is already provided by OpenGL 3.2. Further, pixel and buffer format attributesthat are marked
as deprecated may not be used in conjunction with the OpenGL 3.2 core profile.
●
If you are updating an existing OS X application, include the kCGLOGLPVersion_Legacy constant.
The legacy profile provides the same functionality found in earlier versions of OS X, with no changes. It
continues to support older extensions as well as deprecated pixel and buffer format attributes. No new
functionality will be added to the legacy profile in future versions of OS X.
●
If you want to use OpenGL 3.2 in your application, but also want to support earlier versions of OS X or
Macsthat lack hardware support for OpenGL 3.2, you must implement multiple OpenGL rendering options
in your application. On OS X v10.7, your application should first test to see if OpenGL 3.2 is supported. If
OpenGL 3.2 is supported, create a context and provide it to your OpenGL 3.2 rendering path. Otherwise,
search for a pixel format using the legacy profile instead.
For more information on migrating an application to OpenGL 3.2, see “Updating an Application to Support
the OpenGL 3.2 Core Specification” (page 168).
Buffer Size Attribute Selection Tips
Follow these guidelines to choose buffer attributes that specify buffer size:
● To choose color, depth, and accumulation buffers that are greater than or equal to a size you specify, use
the minimum policy attribute (NSOpenGLPFAMinimumPolicy or kCGLPFAMinimumPolicy).
● To choose color, depth, and accumulation buffers that are closest to a size you specify, use the closest
policy attribute (NSOpenGLPFAClosestPolicy or kCGLPFAClosestPolicy).
● To choose the largest color, depth, and accumulation buffers available, use the maximum policy attribute
(NSOpenGLPFAMaximumPolicy or kCGLPFAMaximumPolicy). Aslong as you pass a value that is greater
than 0, this attribute specifies the use of color, depth, and accumulation buffers that are the largest size
possible.
Choosing Renderer and Buffer Attributes
Buffer Size Attribute Selection Tips
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
65Ensuring That Back Buffer Contents Remain the Same
When your application uses a double-buffered context, it displays the rendered image by calling a function to
flush the image to the screen— theNSOpenGLContext class’s flushBuffer method or the CGL function
CGLFlushDrawable. When the image is displayed, the contents of the back buffer are not preserved. The
next time your application wants to update the back buffer, it must completely redraw the scene.
Your application can add a backing store attribute (NSOpenGLPFABackingStore or kCGLPFABackingStore)
to preserve the contents of the buffer after the back buffer is flushed. Adding this attribute disables some
optimizations that the system can perform, which may impact the performance of your application.
Ensuring a Valid Pixel Format Object
The pixel format routines (the initWithAttributes: method of the NSOpenGLPixelFormat class and the
CGLChoosePixelFormat function) return a pixel format object to your application that you use to create a
rendering context. The buffer and renderer attributes that you supply to the pixel format routine determine
the characteristics of the OpenGL drawing sent to the rendering context. If the system can't find at least one
pixel format that satisfies the constraints specified by the attribute array, it returns NULL for the pixel format
object. In this case, your application should have an alternative that ensures it can obtain a valid object.
One alternative is to set up your attribute array with the least restrictive attribute first and the most restrictive
attribute last. Then, it is fairly easy to adjust the attribute list and make another request for a pixel format
object. The code in Listing 6-1 illustrates this technique using the CGL API. Notice that the initial attributes list
is set up with the supersample attribute last in the list. If the function CGLChoosePixelFormat returns NULL,
it clears the supersample attribute to NULL and tries again.
Listing 6-1 Using the CGL API to create a pixel format object
int last_attribute = 6;
CGLPixelFormatAttribute attribs[] =
{
kCGLPFAAccelerated,
kCGLPFAColorSize, 24
kCGLPFADepthSize, 16,
kCGLPFADoubleBuffer,
kCGLPFASupersample,
0
};
Choosing Renderer and Buffer Attributes
Ensuring That Back Buffer Contents Remain the Same
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
66CGLPixelFormatObj pixelFormatObj;
GLint numPixelFormats;
long value;
CGLChoosePixelFormat (attribs, &pixelFormatObj, &numPixelFormats);
if( pixelFormatObj == NULL ) {
attribs[last_attribute] = NULL;
CGLChoosePixelFormat (attribs, &pixelFormatObj, &numPixelFormats);
}
if( pixelFormatObj == NULL ) {
// Your code to notify the user and take action.
}
Ensuring a Specific Type of Renderer
There are times when you want to ensure that you obtain a pixel format that supports a specific renderer type,
such as a hardware-accelerated renderer. Table 6-1 lists attributes that support specific types of renderers. The
table reflects the following tips for setting up pixel formats:
● To select only hardware-accelerated renderers, use both the accelerated and no-recovery attributes.
● To use only the floating-point software renderer, use the appropriate generic floating-point constant.
● To render to system memory, use the offscreen pixel attribute. Note that this rendering option does not
use hardware acceleration.
● To render offscreen with hardware acceleration, specify a pixel buffer attribute. (See “Rendering to a Pixel
Buffer” (page 60).)
Table 6-1 Renderer types and pixel format attributes
Renderer type CGL Cocoa
NSOpenGLPFAAccelerated
NSOpenGLPFANoRecovery
kCGLPFAAccelerated
kCGLPFANoRecovery
Hardware-accelerated
onscreen
Choosing Renderer and Buffer Attributes
Ensuring a Specific Type of Renderer
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
67Renderer type CGL Cocoa
NSOpenGLPFARendererID
kCGLRendererGenericFloatID
kCGLPFARendererID
kCGLRendererGenericFloatID
Software (floating-point)
System memory (not kCGLPFAOffScreen NSOpenGLPFAOffScreen
accelerated)
Hardware-accelerated kCGLPFAPBuffer NSOpenGLPFAPixelBuffer
offscreen
Ensuring a Single Renderer for a Display
In some cases you may want to use a specific hardware renderer and nothing else. Since the OpenGL framework
normally provides a software renderer as a fallback in addition to whatever hardware renderer it chooses, you
need to prevent OpenGL from choosing the software renderer as an option. To do this, specify the no-recovery
attribute for a windowed drawable object.
Limiting a context to use a specific display, and thus a single renderer, has its risks. If your application runs on
a system that uses more than one display, dragging a windowed drawable object from one display to the other
is likely to yield a less than satisfactory result. Either rendering fails, or OpenGL uses the specified renderer and
then copiesthe result to the second display. The same unsatisfactory result happens when attaching a full-screen
context to another display. If you choose to use the hardware renderer associated with a specific display, you
need to add code that detects and handles display changes.
The code examples that follow show how to use each of the Apple-specific OpenGL APIs to set up a context
that uses a single renderer. Listing 6-2 shows how to set up an NSOpenGLPixelFormat object that supports
a single renderer. The attribute NSOpenGLPFANoRecovery specifies to OpenGL not to provide the fallback
option of the software renderer.
Listing 6-2 Setting an NSOpenGLContext object to use a specific display
#import
+ (NSOpenGLPixelFormat*)defaultPixelFormat
{
NSOpenGLPixelFormatAttribute attributes [] = {
NSOpenGLPFAScreenMask, 0,
NSOpenGLPFANoRecovery,
Choosing Renderer and Buffer Attributes
Ensuring a Single Renderer for a Display
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
68NSOpenGLPFADoubleBuffer,
(NSOpenGLPixelFormatAttribute)nil };
CGDirectDisplayID display = CGMainDisplayID ();
// Adds the display mask attribute for selected display
attributes[1] = (NSOpenGLPixelFormatAttribute)
CGDisplayIDToOpenGLDisplayMask (display);
return [[(NSOpenGLPixelFormat *)[NSOpenGLPixelFormat alloc]
initWithAttributes:attributes]
autorelease];
}
Listing 6-3 shows how to use CGL to set up a context that uses a single renderer. The attribute
kCGLPFANoRecovery ensures that OpenGL does not provide the fallback option of the software renderer.
Listing 6-3 Setting a CGL context to use a specific display
#include
CGLPixelFormatAttribute attribs[] = { kCGLPFADisplayMask, 0,
kCGLPFANoRecovery,
kCGLPFADoubleBuffer,
0 };
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLContextObj cglContext = NULL;
CGDirectDisplayID display = CGMainDisplayID ();
// Adds the display mask attribute for selected display
attribs[1] = CGDisplayIDToOpenGLDisplayMask (display);
CGLChoosePixelFormat (attribs, &pixelFormat, &numPixelFormats);
Allowing Offline Renderers
Adding the attribute NSOpenGLPFAAllowOfflineRenderers allows OpenGL to include offline renderers in
the list of virtual screens returned in the pixel format object. Apple recommends you include this attribute,
because it allows your application to work better in environments where renderers come and go,such as when
a new display is plugged into a Mac.
Choosing Renderer and Buffer Attributes
Allowing Offline Renderers
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
69If your application includes NSOpenGLPFAAllowOfflineRenderers in the list of attributes, your application
must also watch for display changes and update its rendering context. See “Update the Rendering Context
When the Renderer or Geometry Changes” (page 72).
OpenCL
If your applications uses OpenCL to perform other computations, you may want to find an OpenGL renderer
that also supports OpenCL. To do this, add the attribute NSOpenGLPFAAcceleratedCompute to the pixel
format attribute list. Adding this attribute restricts the list of renderers to those that also support OpenCL.
More information on OpenCL can be found in the OpenCL Programming Guide for Mac .
Deprecated Attributes
There are several renderer and buffer attributes that are no longer recommended either because they are too
narrowly focused or no longer useful. Your application should move away from using any of these attributes:
● The robust attribute (NSOpenGLPFARobust or kCGLPFARobust) specifies only those renderers that do
not have any failure modes associated with a lack of video card resources.
● The multiple-screen attribute (NSOpenGLPFAMultiScreen or kCGLPFAMultiScreen) specifies only
those renderers that can drive more than one screen at a time.
● The multiprocessing-safe attribute (kCGLPFAMPSafe) specifies only those renderers that are thread safe.
This attribute is deprecated in OS X because all renderers can accept commands for threads running on
a second processor. However, this does not mean that all renderers are thread safe or reentrant. See
“Concurrency and OpenGL” (page 148).
● The compliant attribute (NSOpenGLPFACompliant or kCGLPFACompliant) specifies only
OpenGL-compliant renderers. All OS X renderers are OpenGL-compliant, so this attribute is no longer
useful.
● The fullscreen attribute (kCGLPFAFullScreen) requested special fullscreen contexts. The window screen
attribute (kCGLPFAWindow) required the context to support windowed contexts. OS X no longer requires
a special full screen context to be created, as it automatically provides the same performance benefits
with a properly formatted window.
● The offscreen buffer attribute (kCGLPFAOffScreen) selects renderers capable of rendering to offscreen
memory. Instead, use a frame buffer object as the rendering target and read the final results back to
application memory.
Choosing Renderer and Buffer Attributes
OpenCL
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
70● The pixel buffer attributes(kCGLPFAPBuffer and kCGLPFARemotePBuffer are no longer recommended;
use frame buffer objects instead.
● The auxiliary buffers attribute (kCGLPFAAuxBuffers) specifies the number of required auxiliary buffers
your application requires. Auxiliary buffers are not supported by the OpenGL 3.2 Core profile. Because
auxiliary buffers are not supported, the kCGLPFAAuxDepthStencil attribute that modifies it is also
deprecated.
● The accumulation buffersize attribute (kCGLPFAAccumSize)specifiesthe desired size for the accumulation
buffer. Accumulation buffers are not supported by the OpenGL 3.2 Core Profile.
Important: Your application may not use any of the deprecated attributes in conjunction with a profile
other than the legacy profile; if you do, pixel format creation fails.
Choosing Renderer and Buffer Attributes
Deprecated Attributes
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
71A rendering context is a container forstate information. When you designate a rendering context asthe current
rendering context,subsequent OpenGL commands modify that context’sstate, objects attached to that context,
or the drawable object associated with that context. The actual drawing surfaces are never owned by the
rendering context but are created, as needed, when the rendering context is actually attached to a drawable
object. You can attach multiple rendering contexts to the same drawing surfaces. Each context maintains its
own drawing state.
“Drawing to a Window or View” (page 35), “Drawing to the Full Screen” (page 50), and “Drawing
Offscreen” (page 53) show how to create a rendering context and attach it to a drawable object. This chapter
describes advanced ways to interact with rendering contexts.
Update the Rendering Context When the Renderer or Geometry
Changes
A renderer change can occur when the user drags a window from one display to another or when a display is
attached or removed. Geometry changes occur when the display mode changes or when a window is resized
or moved. If your application uses an NSOpenGLView object to maintain the context, it is automatically updated.
An application that creates a custom view to hold the rendering context must track the appropriate system
events and update the context when the geometry or display changes.
Updating a rendering context notifies it of geometry changes; it doesn't flush content. Calling an update
function updates the attached drawable objects and ensures that the renderer is properly updated for any
virtual screen changes. If you don't update the rendering context, you may see rendering artifacts.
The routine that you call for updating determines how events related to renderer and geometry changes are
handled. For applications that use or subclass NSOpenGLView, Cocoa calls the update method automatically.
Applications that create an NSOpenGLContext object manually must call the update method of
NSOpenGLContext directly. For a full-screen Cocoa application, calling the setFullScreen method of
NSOpenGLContext ensures that depth, size, or display changes take affect.
Your application must update the rendering context after the system event but before drawing to the context.
If the drawable object is resized, you may want to issue a glViewport command to ensure that the content
scales properly.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
72
Working with Rendering ContextsNote: Some system-level events(such as display mode changes) that require a context update could
reallocate the buffers of the context; thus you need to redraw the entire scene after all context
updates.
It's important that you don't update rendering contexts more than necessary. Your application should respond
to system-level events and notifications rather than updating every frame. For example, you'll want to respond
to window move and resize operations and to display configuration changes such as a color depth change.
Tracking Renderer Changes
It's fairly straightforward to track geometry changes, but how are renderer changes tracked? This is where the
concept of a virtual screen becomes important (see “Virtual Screens” (page 26)). A change in the virtual screen
indicates a renderer change, a change in renderer capability, or both. When your application detects a window
resize event, window move event, or display change, it should check for a virtual screen change and respond
to the change to ensure that the current application state reflects any changes in renderer capabilities.
Each of the Apple-specific OpenGL APIs has a function that returns the current virtual screen number:
● The currentVirtualScreen method of the NSOpenGLContext class
● The CGLGetVirtualScreen function
The virtual screen number represents an index in the list of virtual screens that were set up specifically for the
pixel format object used for the rendering context. The number is unique to the list but is meaningless otherwise.
When the renderer changes, the limits and extensions available to OpenGL may also change. Your application
should retest the capabilities of the renderer and use these to choose its rendering algorithms appropriately.
See “Determining the OpenGL Capabilities Supported by the Renderer” (page 83).
Updating a Rendering Context for a Custom Cocoa View
If you subclass NSView instead of using the NSOpenGLView class, your application must update the rendering
context. That's due to a slight difference between the events normally handled by the NSView class and those
handled by the NSOpenGLView class. Cocoa does not call a reshape method for the NSView class when the
size changes because that class does not export a reshape method to override. Instead, you need to perform
reshape operations directly in your drawRect: method, looking for changes in view bounds prior to drawing
content. Using this approach provides results that are equivalent to using the reshape method of the
NSOpenGLView class.
Working with Rendering Contexts
Update the Rendering Context When the Renderer or Geometry Changes
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
73Listing 7-1 is a partial implementation of a custom view thatshows how to handle context updates. The update
method is called after move, resize, and display change events and when the surface needs updating. The class
adds an observer to the notification NSViewGlobalFrameDidChangeNotification, which is posted
whenever an NSView object that has attached surfaces (that is, NSOpenGLContext objects) resizes, moves,
or changes coordinate offsets.
It's slightly more complicated to handle changes in the display configuration. For that, you need to register
for the notification NSApplicationDidChangeScreenParametersNotification through the
NSApplication class. This notification is posted whenever the configuration of any of the displays attached
to the computer is changed (either programmatically or when the user changes the settings in the interface).
Listing 7-1 Handling context updates for a custom view
#import
#import
#import
@class NSOpenGLContext, NSOpenGLPixelFormat;
@interface CustomOpenGLView : NSView
{
@private
NSOpenGLContext* _openGLContext;
NSOpenGLPixelFormat* _pixelFormat;
}
- (id)initWithFrame:(NSRect)frameRect
pixelFormat:(NSOpenGLPixelFormat*)format;
- (void)update;
@end
@implementation CustomOpenGLView
- (id)initWithFrame:(NSRect)frameRect
pixelFormat:(NSOpenGLPixelFormat*)format
{
Working with Rendering Contexts
Update the Rendering Context When the Renderer or Geometry Changes
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
74self = [super initWithFrame:frameRect];
if (self != nil) {
_pixelFormat = [format retain];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(_surfaceNeedsUpdate:)
name:NSViewGlobalFrameDidChangeNotification
object:self];
}
return self;
}
- (void)dealloc
[[NSNotificationCenter defaultCenter] removeObserver:self
name:NSViewGlobalFrameDidChangeNotification
object:self];
[self clearGLContext];
}
- (void)update
{
if ([_openGLContext view] == self) {
[_openGLContext update];
}
}
- (void) _surfaceNeedsUpdate:(NSNotification*)notification
{
[self update];
}
@end
Working with Rendering Contexts
Update the Rendering Context When the Renderer or Geometry Changes
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
75Context Parameters Alter the Context’s Behavior
A rendering context has a variety of parameters that you can set to suit the needs of your OpenGL drawing.
Some of the most useful, and often overlooked, context parameters are discussed in thissection:swap interval,
surface opacity, surface drawing order, and back-buffer size control.
Each of the Apple-specific OpenGL APIs provides a routine forsetting and getting rendering context parameters:
● The setValues:forParameter: method of the NSOpenGLContext class takes as arguments a list of
values and a list of parameters.
● The CGLSetParameter function takes as parameters a rendering context, a constant that specifies an
option, and a value for that option.
Some parameters need to be enabled for their values to take effect. The reference documentation for a
parameter indicates whether a parameter needs to be enabled. See NSOpenGLContext Class Reference , and
CGL Reference .
Swap Interval Allows an Application to Synchronize Updatesto the Screen Refresh
If the swap interval is set to 0 (the default), buffers are swapped as soon as possible, without regard to the
vertical refresh rate of the monitor. If the swap interval is set to any other value, the buffers are swapped only
during the vertical retrace of the monitor. For more information, see “Synchronize with the Screen Refresh
Rate” (page 96).
You can use the following constants to specify that you are setting the swap interval value:
● For Cocoa, use NSOpenGLCPSwapInterval.
●
If you are using the CGL API, use kCGLCPSwapInterval as shown in Listing 7-2.
Listing 7-2 Using CGL to set up synchronization
GLint sync = 1;
// ctx must be a valid context
CGLSetParameter (ctx, kCGLCPSwapInterval, &sync);
Working with Rendering Contexts
Context Parameters Alter the Context’s Behavior
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
76Surface Opacity Specifies How the OpenGL Surface Blends with Surfaces Behind
It
OpenGL surfaces are typically rendered as opaque. Thus the background color for pixels with alpha values of
0.0 is the surface background color. If you set the value of the surface opacity parameter to 0, then the
contents of the surface are blended with the contents of surfaces behind the OpenGL surface. This operation
is equivalent to OpenGL blending with a source contribution proportional to the source alpha and a background
contribution proportional to 1 minus the source alpha. A value of 1 means the surface is opaque (the default);
0 means completely transparent.
You can use the following constants to specify that you are setting the surface opacity value:
● For Cocoa, use NSOpenGLCPSurfaceOpacity.
●
If you are using the CGL API, use kCGLCPSurfaceOpacity as shown in Listing 7-3.
Listing 7-3 Using CGL to set surface opacity
GLint opaque = 0;
// ctx must be a valid context
CGLSetParameter (ctx, kCGLCPSurfaceOpacity, &opaque);
Surface Drawing Order Specifies the Position of the OpenGL Surface Relative to
the Window
A value of 1 means that the position is above the window; a value of –1 specifies a position that is below the
window. When you have overlapping views, setting the order to -1 causes OpenGL to draw underneath, 1
causes OpenGL to draw on top. This parameter is useful for drawing user interface controls on top of an OpenGL
view.
You can use the following constants to specify that you are setting the surface drawing order value:
● For Cocoa, use NSOpenGLCPSurfaceOrder.
●
If you are using the CGL API, use kCGLCPSurfaceOrder as shown in Listing 7-4.
Listing 7-4 Using CGL to set surface drawing order
GLint order = –1; // below window
// ctx must be a valid context
CGLSetParameter (ctx, kCGLCPSurfaceOrder, &order);
Working with Rendering Contexts
Context Parameters Alter the Context’s Behavior
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
77Determining Whether Vertex and Fragment Processing Happens on the GPU
CGL provides two parameters for checking whether the system is using the GPU for processing:
kCGLCPGPUVertexProcessing and kCGLCPGPUFragmentProcessing. To check vertex processing, pass
the vertex constant to the CGLGetParameter function. To check fragment processing, pass the fragment
constant to CGLGetParameter. Listing 7-5 demonstrates how to use these parameters.
Important: Although you can perform these queries at any time, keep in mind that such queries
force an internal state validation, which can impact performance. For best performance, do not use
these queries inside your drawing loop. Instead, perform the queries once at initialization or context
setup time to determine whether OpenGL is using the CPU or the GPU for processing, and then act
appropriately in your drawing loop.
Listing 7-5 Using CGL to check whether the GPU is processing vertices and fragments
BOOL gpuProcessing;
GLint fragmentGPUProcessing, vertexGPUProcessing;
CGLGetParameter (CGLGetCurrentContext(), kCGLCPGPUFragmentProcessing,
&fragmentGPUProcessing);
CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUVertexProcessing,
&vertexGPUProcessing);
gpuProcessing = (fragmentGPUProcessing && vertexGPUProcessing) ? YES : NO;
Controlling the Back Buffer Size
Normally, the back buffer is the same size as the window or view that it's drawn into, and it changes size when
the window or view changes size. For a window whose size is 720×pixels, the OpenGL back buffer is sized to
match. If the window grows to 1024×768 pixels, for example, then the back buffer is resized as well. If you do
not want this behavior, use the back buffer size control parameter.
Using this parameter fixes the size of the back buffer and lets the system scale the image automatically when
it moves the data to a variable size buffer (see Figure 7-1). The size of the back buffer remains fixed at the size
that you set up regardless of whether the image is resized to display larger onscreen.
You can use the following constants to specify that you are setting the surface backing size:
●
If you are using the CGL API, use kCGLCPSurfaceBackingSize, as shown in Listing 7-6.
Working with Rendering Contexts
Context Parameters Alter the Context’s Behavior
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
78Listing 7-6 Using CGL to set up back buffer size control
GLint dim[2] = {720, 480};
// ctx must be a valid context
CGLSetParameter(ctx, kCGLCPSurfaceBackingSize, dim);
CGLEnable (ctx, kCGLCESurfaceBackingSize);
Figure 7-1 A fixed size back buffer and variable size front buffer
Sharing Rendering Context Resources
A rendering context does not own the drawing objects attached to it, which leaves open the option forsharing.
Rendering contexts can share resources and can be attached to the same drawable object (see Figure 7-2 (page
80)) or to different drawable objects (see Figure 7-3 (page 80)). You set up context sharing—either with more
than one drawable object or with another context—at the time you create a rendering context.
Contexts can share object resources and their associated object state by indicating a shared context at context
creation time. Shared contexts share all texture objects, display lists, vertex programs, fragment programs, and
buffer objects created before and after sharing is initiated. The state of the objects is also shared but not other
Working with Rendering Contexts
Sharing Rendering Context Resources
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
79contextstate,such as current color, texture coordinate settings, matrix and lighting settings, rasterization state,
and texture environment settings. You need to duplicate context state changes as required, but you need to
set up individual objects only once.
Figure 7-2 Shared contexts attached to the same drawable object
Context Context
Drawable
object
Shared
object state
When you create an OpenGL context, you can designate another context whose object resources you want to
share. Allsharing is peer to peer. Shared resources are reference-counted and thus are maintained until explicitly
released or when the last context-sharing resource is released.
Not every context can be shared with every other context. Both contexts must share the same OpenGL profile.
You must also ensure that both contexts share the same set of renderers. You meet these requirements by
ensuring each context uses the same virtual screen list, using either of the following techniques:
● Use the same pixel format object to create all the rendering contexts that you want to share.
● Create pixel format objects using attributes that narrow down the choice to a single display. This practice
ensures that the virtual screen is identical for each pixel format object.
Figure 7-3 Shared contexts and more than one drawable object
Context Context
Drawable
object
Drawable
object
Shared
object state
Setting up shared rendering contextsis very straightforward. Each Apple-specific OpenGL API providesfunctions
with an option to specify a context to share in its context creation routine:
● Use the share argument for the initWithFormat:shareContext: method of the NSOpenGLContext
class. See Listing 7-7 (page 81).
● Use the share parameter for the function CGLCreateContext. See Listing 7-8 (page 82).
Working with Rendering Contexts
Sharing Rendering Context Resources
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
80Listing 7-7 ensures the same virtual screen list by using the same pixel format object for each of the shared
contexts.
Listing 7-7 Setting up an NSOpenGLContext object for sharing
#import
+ (NSOpenGLPixelFormat*)defaultPixelFormat
{
NSOpenGLPixelFormatAttribute attributes [] = {
NSOpenGLPFADoubleBuffer,
(NSOpenGLPixelFormatAttribute)nil };
return [(NSOpenGLPixelFormat *)[NSOpenGLPixelFormat alloc]
initWithAttributes:attribs];
}
- (NSOpenGLContext*)openGLContextWithShareContext:(NSOpenGLContext*)context
{
if (_openGLContext == NULL) {
_openGLContext = [[NSOpenGLContext alloc]
initWithFormat:[[self class] defaultPixelFormat]
shareContext:context];
[_openGLContext makeCurrentContext];
[self prepareOpenGL];
}
return _openGLContext;
}
- (void)prepareOpenGL
{
// Your code here to initialize the OpenGL state
}
Listing 7-8 ensures the same virtual screen list by using the same pixel format object for each of the shared
contexts.
Working with Rendering Contexts
Sharing Rendering Context Resources
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
81Listing 7-8 Setting up a CGL context for sharing
#include
CGLPixelFormatAttribute attrib[] = {kCGLPFADoubleBuffer, 0};
CGLPixelFormatObj pixelFormat = NULL;
Glint numPixelFormats = 0;
CGLContextObj cglContext1 = NULL;
CGLContextObj cglContext2 = NULL;
CGLChoosePixelFormat (attribs, &pixelFormat, &numPixelFormats);
CGLCreateContext(pixelFormat, NULL, &cglContext1);
CGLCreateContext(pixelFormat, cglContext1, &cglContext2);
Working with Rendering Contexts
Sharing Rendering Context Resources
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
82One of the benefits of using OpenGL isthat it is extensible. An extension istypically introduced by one or more
vendors and then later is accepted by the OpenGL Working Group. Some extensions are promoted from a
vendor-specific extension to one shared by more than one vendor, sometimes even being incorporated into
the core OpenGL API. Extensions allow OpenGL to embrace innovation, but require you to verify that the
OpenGL functionality you want to use is available.
Because extensions can be introduced at the vendor level, more than one extension can provide the same
basic functionality. There might also be an ARB-approved extension that has functionality similar to that of a
vendor-specific extension. Your application should prefer core functionality or ARB-approved extensions over
those specific to a particular vendor, when both are offered by the same renderer. This makes it easier to
transparently support new renderers from other vendors.
As particular functionality becomes widely adopted, it can be moved into the core OpenGL API by the ARB. As
a result, functionality that you want to use could be included as an extension, as part of the core API, or both.
For example, the ability to combine texture environments is supported through the
GL_ARB_texture_env_combine and the GL_EXT_texture_env_combine extensions. It's also part of the
core OpenGL version 1.3 API. Although each has similar functionality, they use a different syntax. You may
need to check in several places (core OpenGL API and extension strings) to determine whether a specific
renderer supports functionality that you want to use.
Detecting Functionality
OpenGL hastwo types of commands—those that are part of the core API and those that are part of an extension
to OpenGL. Your application first needs to check for the version of the core OpenGL API and then check for
the available extensions. Keep in mind that OpenGL functionality is available on a per-renderer basis. For
example, a software renderer might notsupport fog effects even though fog effects are available in an OpenGL
extension implemented by a hardware vendor on the same system. For this reason, it's important that you
check for functionality on a per-renderer basis.
Regardless of what functionality you are checking for, the approach is the same. You need to call the OpenGL
function glGetString twice. The first time pass the GL_VERSION constant. The function returns a string that
specifies the version of OpenGL. The second time, pass the GL_EXTENSIONS constant. The function returns a
pointer to an extension name string. The extension name string is a space-delimited list of the OpenGL
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
83
Determining the OpenGL Capabilities Supported
by the Rendererextensions that are supported by the current renderer. This string can be rather long, so do not allocate a
fixed-length string for the return value of the glGetString function. Use a pointer and evaluate the string
in place.
Pass the extension name string to the function gluCheckExtension along with the name of the extension
you want to check for. The gluCheckExtension function returns a Boolean value that indicates whether or
not the extension is available for the current renderer.
If an extension becomes part of the core OpenGL API, OpenGL continues to export the name strings of the
promoted extensions. It also continuesto support the previous versions of any extension that has been exported
in earlier versions of OS X. Because extensions are not typically removed, the methodology you use today to
check for a feature works in future versions of OS X.
Checking for functionality, although fairly straightforward, involves writing a large chunk of code. The best
way to check for OpenGL functionality is to implement a capability-checking function that you call when your
program starts up, and then any time the renderer changes. Listing 8-1 shows a code excerpt that checks for
a few extensions. A detailed explanation for each line of code appears following the listing.
Listing 8-1 Checking for OpenGL functionality
GLint maxRectTextureSize;
GLint myMaxTextureUnits;
GLint myMaxTextureSize;
const GLubyte * strVersion;
const GLubyte * strExt;
float myGLVersion;
GLboolean isVAO, isTexLOD, isColorTable, isFence, isShade,
isTextureRectangle;
strVersion = glGetString (GL_VERSION); // 1
sscanf((char *)strVersion, "%f", &myGLVersion);
strExt = glGetString (GL_EXTENSIONS); // 2
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &myMaxTextureUnits); // 3
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &myMaxTextureSize); // 4
isVAO =
gluCheckExtension ((const GLubyte*)"GL_APPLE_vertex_array_object",strExt); // 5
isFence = gluCheckExtension ((const GLubyte*)"GL_APPLE_fence", strExt); // 6
isShade =
gluCheckExtension ((const GLubyte*)"GL_ARB_shading_language_100", strExt); // 7
Determining the OpenGL Capabilities Supported by the Renderer
Detecting Functionality
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
84isColorTable =
gluCheckExtension ((const GLubyte*)"GL_SGI_color_table", strExt) ||
gluCheckExtension ((const GLubyte*)"GL_ARB_imaging", strExt); // 8
isTexLOD =
gluCheckExtension ((const GLubyte*)"GL_SGIS_texture_lod", strExt) ||
(myGLVersion >= 1.2); // 9
isTextureRectangle = gluCheckExtension ((const GLubyte*)
"GL_EXT_texture_rectangle", strExt);
if (isTextureRectangle)
glGetIntegerv (GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT, &maxRectTextureSize);
else
maxRectTextureSize = 0; // 10
Here is what the code does:
1. Gets a string that specifies the version of OpenGL.
2. Gets the extension name string.
3. Calls the OpenGL function glGetIntegerv to get the value of the attribute passed to it which, in this
case, is the maximum number of texture units.
4. Gets the maximum texture size.
5. Checks whether vertex array objects are supported.
6. Checks for the Apple fence extension.
7. Checks for support for version 1.0 of the OpenGL shading language.
8. Checks for RGBA-format color lookup table support. In this case, the code needs to check for the
vendor-specific string and for the ARB string. If either is present, the functionality is supported.
9. Checks for an extension related to the texture level of detail parameter (LOD). In this case, the code needs
to check for the vendor-specific string and for the OpenGL version. If the vendor string is present or the
OpenGL version is greater than or equal to 1.2, the functionality is supported.
10. Getsthe OpenGL limit for rectangle textures. Forsome extensions,such asthe rectangle texture extension,
it may not be enough to check whether the functionality is supported. You may also need to check the
limits. You can use glGetIntegerv and related functions (glGetBooleanv, glGetDoublev,
glGetFloatv) to obtain a variety of parameter values.
You can extend this example to make a comprehensive functionality-checking routine for your application.
For more details, see the GLCheck.c file in the Cocoa OpenGL sample application.
Determining the OpenGL Capabilities Supported by the Renderer
Detecting Functionality
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
85The code in Listing 8-2 shows one way to query the current renderer. It uses the CGL API, which can be called
from Cocoa applications. In reality, you need to iterate over all displays and all renderers for each display to
get a true picture of the OpenGL functionality available on a particular system. You also need to update your
functionality snapshot each time the list of displays or display configuration changes.
Listing 8-2 Setting up a valid rendering context to get renderer functionality information
#include
#include
CGDirectDisplayID display = CGMainDisplayID (); // 1
CGOpenGLDisplayMask myDisplayMask =
CGDisplayIDToOpenGLDisplayMask (display); // 2
{ // Check capabilities of display represented by display mask
CGLPixelFormatAttribute attribs[] = {kCGLPFADisplayMask,
myDisplayMask,
0}; // 3
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLContextObj myCGLContext = 0;
CGLContextObj curr_ctx = CGLGetCurrentContext (); // 4
CGLChoosePixelFormat (attribs, &pixelFormat, &numPixelFormats); // 5
if (pixelFormat) {
CGLCreateContext (pixelFormat, NULL, &myCGLContext); // 6
CGLDestroyPixelFormat (pixelFormat); // 7
CGLSetCurrentContext (myCGLContext); // 8
if (myCGLContext) {
// Check for capabilities and functionality here
}
}
CGLDestroyContext (myCGLContext); // 9
CGLSetCurrentContext (curr_ctx); // 10
}
Here's what the code does:
1. Gets the display ID of the main display.
Determining the OpenGL Capabilities Supported by the Renderer
Detecting Functionality
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
862. Maps a display ID to an OpenGL mask.
3. Fills a pixel format attributes array with the display mask attribute and the mask value.
4. Saves the current context so that it can be restored later.
5. Gets the pixel format object for the display. The numPixelFormats parameter specifies how many pixel
formats are listed in the pixel format object.
6. Creates a context based on the first pixel format in the list supplied by the pixel format object. Only one
renderer will be associated with this context.
In your application, you would need to iterate through all pixel formats for this display.
7. Destroys the pixel format object when it is no longer needed.
8. Sets the current context to the newly created, single-renderer context. Now you are ready to check for
the functionality supported by the current renderer. See Listing 8-1 (page 84) for an example of
functionality-checking code.
9. Destroys the context because it is no longer needed.
10. Restores the previously saved context as the current context, thus ensuring no intrusion upon the user.
Guidelines for Code That Checks for Functionality
The guidelines in this section ensure that your functionality-checking code is thorough yet efficient.
● Don't rely on what's in a header file. A function declaration in a header file does not ensure that a feature
is supported by the current renderer. Neither does linking against a stub library that exports a function.
● Make sure that a renderer is attached to a valid rendering context before you check the functionality of
that renderer.
● Check the API version or the extension name string for the current renderer before you issue OpenGL
commands.
● Check only once per renderer. After you've determined that the current renderer supports an OpenGL
command, you don't need to check for that functionality again for that renderer.
● Make sure that you are aware of whether a feature is being used as part of the Core OpenGL API or as an
extension. When a feature is implemented both as part of the core OpenGL API and as an extension, it
uses different constants and function names.
Determining the OpenGL Capabilities Supported by the Renderer
Guidelines for Code That Checks for Functionality
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
87OpenGL Renderer Implementation-Dependent Values
The OpenGL specification definesimplementation-dependent valuesthat define the limits of what an OpenGL
implementation is capable of. For example, the maximum size of a texture and the number of texture units
are both common implementation-dependent values that an application is expected to check. Each of these
values provides a minimum value that all conforming OpenGL implementations are expected to support. If
your application’s usage exceeds these minimums, it must check the limit first, and fail gracefully if the
implementation cannot provide the limit desired. Your application may need to load smaller textures, disable
a rendering feature, or choose a different implementation.
Although the specification provides a comprehensive list of these limitations, a few stand out in most OpenGL
applications. Table 8-1 lists values that applications should test if they require more than the minimum values
in the specification.
Table 8-1 Common OpenGL renderer limitations
Maximum size of the texture GL_MAX_TEXTURE_SIZE
Number of depth buffer planes GL_DEPTH_BITS
Number of stencil buffer planes GL_STENCIL_BITS
The limit on the size and complexity of your shaders is a key area you need to test. All graphics hardware
supportslimited memory to pass attributesinto the vertex and fragmentshaders. Your application must either
keep its usage below the minimums as defined in the specification, or it must check the shader limitations
documented in Table 8-2 and choose shaders that are within those limits.
Table 8-2 OpenGL shader limitations
Maximum number of vertex attributes GL_MAX_VERTEX_ATTRIBS
Maximum number of uniform vertex vectors GL_MAX_VERTEX_UNIFORM_COMPONENTS
Maximum number of uniform fragment vectors GL_MAX_FRAGMENT_UNIFORM_COMPONENTS
Maximum number of varying vectors GL_MAX_VARYING_FLOATS
Maximum number of texture units usable in a GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
vertex shader
Maximum number of texture units usable in a GL_MAX_TEXTURE_IMAGE_UNITS
fragment shader
Determining the OpenGL Capabilities Supported by the Renderer
OpenGL Renderer Implementation-Dependent Values
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
88OpenGL performs many complex operations—transformations, lighting, clipping, texturing, environmental
effects, and so on—on large data sets. The size of your data and the complexity of the calculations performed
on it can impact performance, making your stellar 3D graphics shine less brightly than you'd like. Whether
your application is a game using OpenGL to provide immersive real-time images to the user or an image
processing application more concerned with image quality, use the information in this chapter to help you
design your application.
Visualizing OpenGL
The most common way to visualize OpenGL is as a graphics pipeline, as shown in Figure 9-1 (page 90). Your
application sends vertex and image data, configuration and state changes, and rendering commandsto OpenGL.
Vertices are processed, assembled into primitives, and rasterized into fragments. Each fragment is calculated
and merged into the framebuffer. The pipeline model is useful for identifying exactly what work your application
must perform to generate the results you want. OpenGL allows you to customize each stage of the graphics
pipeline, either through customized shader programs or by configuring a fixed-function pipeline through
OpenGL function calls.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
89
OpenGL Application Design StrategiesIn most implementations, each pipeline stage can act in parallel with the others. This is a key point. If any one
pipeline stage performs too much work, then the other stages sit idle waiting for it to complete. Your design
should balance the work performed in each pipeline stage to the capabilities of the renderer. When you tune
your application’s performance, the firststep is usually to determine which stage the application is bottlenecked
in, and why.
Figure 9-1 OpenGL graphics pipeline
Geometry
Fragment
Framebuffer operations
Texturing
Fog
Alpha, stencil, and depth tests
Framebuffer blending
Primitive assembly
Clipping
Vertex
Application Primitives and image data
Transform and lighting
Another way to visualize OpenGL is as a client-server architecture, as shown in Figure 9-2 (page 91). OpenGL
state changes, texture and vertex data, and rendering commands must all travel from the application to the
OpenGL client. The client transforms these items so that the graphics hardware can understand them, and
then forwards them to the GPU. Not only do these transformations add overhead, but the bandwidth between
the CPU and the graphics hardware is often lower than other parts of the system.
OpenGL Application Design Strategies
Visualizing OpenGL
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
90To achieve great performance, an application must reduce the frequency of callsthey make to OpenGL, minimize
the transformation overhead, and carefully manage the flow of data between the application and the graphics
hardware. For example, OpenGL provides mechanismsthat allow some kinds of data to be cached in dedicated
graphics memory. Caching reusable data in graphics memory reduces the overhead of transmitting data to
the graphics hardware.
Figure 9-2 OpenGL client-server architecture
OpenGL client
OpenGL server
Graphics hardware
Application
OpenGL framework
OpenGL driver
Runs on GPU
Runs on CPU
Designing a High-Performance OpenGL Application
To summarize, a well-designed OpenGL application needs to:
● Exploit parallelism in the OpenGL pipeline.
● Manage data flow between the application and the graphics hardware.
OpenGL Application Design Strategies
Designing a High-Performance OpenGL Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
91Figure 9-3 shows a suggested process flow for an application that uses OpenGL to perform animation to the
display.
Figure 9-3 Application model for managing resources
Update dynamic resources Execute rendering commands
Read back results
Present to display
Free up resources
Render loop
Slower process
Faster process
Create static resources
When the application launches, it creates and initializes any static resources it intends to use in the renderer,
encapsulating those resources into OpenGL objects where possible. The goal is to create any object that can
remain unchanged for the runtime of the application. Thistradesincreased initialization time for better rendering
performance. Ideally, complex commands or batches ofstate changesshould be replaced with OpenGL objects
that can be switched in with a single function call. For example, configuring the fixed-function pipeline can
take dozens of function calls. Replace it with a graphics shader that is compiled at initialization time, and you
can switch to a different program with a single function call. In particular, OpenGL objects that are expensive
to create or modify should be created as static objects.
The rendering loop processes all of the items you intend to render to the OpenGL context, then swaps the
buffersto display the resultsto the user. In an animated scene,some data needsto be updated for every frame.
In the inner rendering loop shown in Figure 9-3, the application alternates between updating rendering
resources(possibly creating or modifying OpenGL objectsin the process) and submitting rendering commands
that use those resources. The goal of this inner loop is to balance the workload so that the CPU and GPU are
working in parallel, without blocking each other by using the same resources simultaneously.
OpenGL Application Design Strategies
Designing a High-Performance OpenGL Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
92A goal for the inner loop is to avoid copying data back from the graphics processor to the CPU. Operations
that require the CPU to read results back from the graphics hardware are sometimes necessary, but in general
reading back results should be used sparingly. If those results are also used to render the current frame, as
shown in the middle rendering loop, this can be very slow. Copying data from the GPU to the CPU often requires
that some or all previously submitted drawing commands have completed.
After the application submits all drawing commands needed in the frame, it presents the results to the screen.
Alternatively, a non-interactive application might read the final image back to the CPU, but this is also slower
than presenting results to the screen. This step should be performed only for results that must be read back
to the application. For example, you might copy the image in the back buffer to save it to disk.
Finally, when your application is ready to shut down, it deletes static and dynamic resources to make more
hardware resources available to other applications. If your application is moved to the background, releasing
resources to other applications is also good practice.
To summarize the important characteristics of this design:
● Create static resources, whenever practical.
● The inner rendering loop alternates between modifying dynamic resources and submitting rendering
commands. Enough work should be included in this loop so that when the application needs to read or
write to any OpenGL object, the graphics processor has finished processing any commands that used it.
● Avoid reading intermediate rendering results into the application.
The rest of this chapter provides useful OpenGL programming techniques to implement the features of this
rendering loop. Later chapters demonstrate how to apply these general techniquesto specific areas of OpenGL
programming.
●
“Update OpenGL Content Only When Your Data Changes” (page 94)
●
“Avoid Synchronizing and Flushing Operations” (page 96)
●
“Allow OpenGL to Manage Your Resources” (page 99)
●
“Use Optimal Data Types and Formats” (page 102)
●
“Use Double Buffering to Avoid Resource Conflicts” (page 100)
●
“Be Mindful of OpenGL State Variables” (page 101)
●
“Use OpenGL Macros” (page 103)
●
“Replace State Changes with OpenGL Objects” (page 102)
OpenGL Application Design Strategies
Designing a High-Performance OpenGL Application
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
93Update OpenGL Content Only When Your Data Changes
OpenGL applications should avoid recomputing a scene when the data has not changed. This is critical on
portable devices, where power conservation is critical to maximizing battery life. You can ensure that your
application draws only when necessary by following a few simple guidelines:
●
If your application isrendering animation, use a Core Video display link to drive the animation loop. Listing
9-1 (page 94) provides code that allows your application to be notified when a new frame needs to be
displayed. This code also synchronizes image updates to the refresh rate of the display. See “Synchronize
with the Screen Refresh Rate” (page 96) for more information.
●
If your application does not animate its OpenGL content, you should allow the system to regulate drawing.
For example, in Cocoa call the setNeedsDisplay: method when your data changes.
●
If your application does not use a Core Video display link, you should still advance an animation only when
necessary. To determine when to draw the next frame of an animation, calculate the difference between
the current time and the start of the last frame. Use the difference to determine how much to advance
the animation. You can use the Core Foundation function CFAbsoluteTimeGetCurrent to obtain the
current time.
Listing 9-1 Setting up a Core Video display link
@interface MyView : NSOpenGLView
{
CVDisplayLinkRef displayLink; //display link for managing rendering thread
}
@end
- (void)prepareOpenGL
{
// Synchronize buffer swaps with vertical refresh rate
GLint swapInt = 1;
[[self openGLContext] setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
// Create a display link capable of being used with all active displays
CVDisplayLinkCreateWithActiveCGDisplays(&displayLink);
// Set the renderer output callback function
CVDisplayLinkSetOutputCallback(displayLink, &MyDisplayLinkCallback, self);
OpenGL Application Design Strategies
Update OpenGL Content Only When Your Data Changes
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
94// Set the display link for the current renderer
CGLContextObj cglContext = [[self openGLContext] CGLContextObj];
CGLPixelFormatObj cglPixelFormat = [[self pixelFormat] CGLPixelFormatObj];
CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(displayLink, cglContext,
cglPixelFormat);
// Activate the display link
CVDisplayLinkStart(displayLink);
}
// This is the renderer output callback function
static CVReturn MyDisplayLinkCallback(CVDisplayLinkRef displayLink, const
CVTimeStamp* now, const CVTimeStamp* outputTime,
CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* displayLinkContext)
{
CVReturn result = [(MyView*)displayLinkContext getFrameForTime:outputTime];
return result;
}
- (CVReturn)getFrameForTime:(const CVTimeStamp*)outputTime
{
// Add your drawing codes here
return kCVReturnSuccess;
}
- (void)dealloc
{
// Release the display link
CVDisplayLinkRelease(displayLink);
[super dealloc];
}
OpenGL Application Design Strategies
Update OpenGL Content Only When Your Data Changes
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
95Synchronize with the Screen Refresh Rate
Tearing is a visual anomaly caused when part of the current frame overwrites previous frame data in the
framebuffer before the current frame is fully rendered on the screen. To avoid tearing, applications use a
double-buffered context and synchronize buffer swaps with the screen refresh rate (sometimes called VBL ,
vertical blank , or vsynch ) to eliminate frame tearing.
Note: During development, it's best to disable synchronization so that you can more accurately
benchmark your application. Enable synchronization when you are ready to deploy your application.
The refresh rate of the display limits how often the screen can be refreshed. The screen can be refreshed at
rates that are divisible by integer values. For example, a CRT display that has a refresh rate of 60 Hz can support
screen refresh rates of 60 Hz, 30 Hz, 20 Hz, and 15 Hz. LCD displays do not have a vertical retrace in the CRT
sense and are typically considered to have a fixed refresh rate of 60 Hz.
After you tell the context to swap the buffers, OpenGL must defer any rendering commands that follow that
swap until after the buffers have successfully been exchanged. Applications that attempt to draw to the screen
during this waiting period waste time that could be spent performing other drawing operations or saving
battery life and minimizing fan operation.
Listing 9-2 shows how an NSOpenGLView object can synchronize with the screen refresh rate; you can use a
similar approach if your application uses CGL contexts. It assumes that you set up the context for double
buffering. The swap interval can be set only to 0 or 1. If the swap interval is set to 1, the buffers are swapped
only during the vertical retrace.
Listing 9-2 Setting up synchronization
GLint swapInterval = 1;
[[self openGLContext] setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
Avoid Synchronizing and Flushing Operations
OpenGL is not required to execute most commandsimmediately. Often, they are queued to a command buffer
and read and executed by the hardware at a later time. Usually, OpenGL waits until the application has queued
up a significant number of commands before sending the buffer to the hardware—allowing the graphics
hardware to execute commands in batches is often more efficient. However, some OpenGL functions must
flush the buffer immediately. Other functions not only flush the buffer, but also block until previously submitted
commands have completed before returning control to the application. Your application should restrict the
OpenGL Application Design Strategies
Avoid Synchronizing and Flushing Operations
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
96use of flushing and synchronizing commands only to those cases where that behavior is necessary. Excessive
use of flushing or synchronizing commands add additional stalls waiting for the hardware to finish rendering.
On a single-buffered context, flushing may also cause visual anomalies, such as flickering or tearing.
These situations require OpenGL to submit the command buffer to the hardware for execution.
● The function glFlush waits until commands are submitted but does not wait for the commands to finish
executing.
● The function glFinish waits for all previously submitted commands to complete executing.
● Functions that retrieve OpenGL state (for example, glGetError), also wait for submitted commands to
complete.
● Buffer swapping routines (the flushBuffer method of the NSOpenGLContext class or the
CGLFlushDrawable function) implicitly call glFlush. Note that when using the NSOpenGLContext
class or the CGL API, the term flush actually refers to a buffer-swapping operation. For single-buffered
contexts, glFlush and glFinish are equivalent to a swap operation, since all rendering is taking place
directly in the front buffer.
● The command buffer is full.
Using glFlush Effectively
Most of the time you don't need to call glFlush to move image data to the screen. There are only a few cases
that require you to call the glFlush function:
●
If your application submits rendering commands that use a particular OpenGL object, and it intends to
modify that object in the near future. If you attempt to modify an OpenGL object that has pending drawing
commands, your application may be forced to wait until those commands have been completed. In this
situation, calling glFlush ensures that the hardware begins processing commands immediately. After
flushing the command buffer, your application should perform work that does not need that resource. It
can perform other work (even modifying other OpenGL objects).
● Your application needs to change the drawable object associated with the rendering context. Before you
can switch to another drawable object, you must call glFlush to ensure that all commands written in
the command queue for the previous drawable object have been submitted.
● When two contexts share an OpenGL object. After submitting any OpenGL commands, call glFlush
before switching to the other context.
● To keep drawing synchronized across multiple threads and prevent command buffer corruption, each
thread should submit its rendering commands and then call glFlush.
OpenGL Application Design Strategies
Avoid Synchronizing and Flushing Operations
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
97Avoid Querying OpenGL State
Calls to glGet*(), including glGetError(), may require OpenGL to execute previous commands before
retrieving any state variables. This synchronization forces the graphics hardware to run lockstep with the CPU,
reducing opportunities for parallelism.
Your application should keep shadow copies of any OpenGL state that you need to query, and maintain these
shadow copies as you change the state.
When errors occur, OpenGL sets an error flag that you can retrieve with the function glGetError. During
development, it's crucial that your code contains error checking routines, not only for the standard OpenGL
calls, but for the Apple-specific functions provided by the CGL API. If you are developing a performance-critical
application, retrieve error information only in the debugging phase. Calling glGetError excessively in a
release build degrades performance.
Use Fences for Finer-Grained Synchronization
Avoid using glFinish in your application, because it waits until all previously submitted commands are
completed before returning control to your application. Instead, you should use the fence extension
(APPLE_fence). This extension was created to provide the level of granularity that is not provided by glFinish.
A fence is a token used to mark the current point in the command stream. When used correctly, it allows you
to ensure that a specific series of commands has been completed. A fence helps coordinate activity between
the CPU and the GPU when they are using the same resources.
Follow these steps to set up and use a fence:
1. At initialization time, create the fence object by calling the function glGenFencesAPPLE.
GLint myFence;
glGenFencesAPPLE(1,&myFence);
2. Call the OpenGL functions that must complete prior to the fence.
3. Set up the fence by calling the function glSetFenceAPPLE. Thisfunction inserts a token into the command
stream and sets the fence state to false.
void glSetFenceAPPLE(GLuint fence);
fence specifies the token to insert. For example:
glSetFenceAPPLE(myFence);
OpenGL Application Design Strategies
Avoid Synchronizing and Flushing Operations
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
984. Call glFlush to force the commands to be sent to the hardware. This step is optional, but recommended
to ensure that the hardware begins processing OpenGL commands.
5. Perform other work in your application.
6. Wait for all OpenGL commands issued prior to the fence to complete by calling the function
glFinishFenceAPPLE.
glFinishFenceAPPLE(myFence);
As an alternative to calling glFinishFenceAPPLE, you can call glTestFenceAPPLE to determine whether
the fence has been reached. The advantage of testing the fence is that your application does not block
waiting for the fence to complete. This is useful if your application can continue processing other work
while waiting for the fence to trigger.
glTestFenceAPPLE(myFence);
7. When your application no longer needsthe fence, delete it by calling the function glDeleteFencesAPPLE.
glDeleteFencesAPPLE(1,&myFence);
There is an art to determining where to insert a fence in the command stream. If you insert a fence for too few
drawing commands, you risk having your application stall while it waits for drawing to complete. You'll want
to set a fence so your application operates as asynchronously as possible without stalling.
The fence extension also lets you synchronize buffer updates for objects such as vertex arrays and textures.
For that you call the function glFinishObjectAPPLE, supplying an object name along with the token.
For detailed information on this extension, see the OpenGL specification for the Apple fence extension.
Allow OpenGL to Manage Your Resources
OpenGL allows many data types to be stored persistently inside OpenGL. Creating OpenGL objects to store
vertex, texture, or other forms of data allows OpenGL to reduce the overhead of transforming the data and
sending them to the graphics processor. If data is used more frequently than it is modified, OpenGL can
substantially improve the performance of your application.
OpenGL Application Design Strategies
Allow OpenGL to Manage Your Resources
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
99OpenGL allows your application to hint how it intends to use the data. These hints allow OpenGL to make an
informed choice of how to process your data. For example, static data might be placed in high-speed graphics
memory directly connected to the graphics processor. Data that changes frequently might be kept in main
memory and accessed by the graphics hardware through DMA.
Use Double Buffering to Avoid Resource Conflicts
Resource conflicts occur when your application and OpenGL want to access a resource at the same time. When
one participant attempts to modify an OpenGL object being used by the other, one of two problems results:
● The participant that wantsto modify the object blocks until it is no longer in use. Then the other participant
is not allowed to read from or write to the object until the modifications are complete. This is safe, but
these can be hidden bottlenecks in your application.
● Some extensions allow OpenGL to access application memory that can be simultaneously accessed by
the application. In this situation, synchronizing between the two participants is left to the application to
manage. Your application calls glFlush to force OpenGL to execute commands and uses a fence or
glFinish to ensure that no commands that access that memory are pending.
Whether your application relies on OpenGL to synchronize access to a resource, or it manually synchronizes
access, resource contention forces one of the participants to wait, rather than allowing them both to execute
in parallel. Figure 9-4 demonstrates this problem. There is only a single buffer for vertex data, which both the
application and OpenGL want to use and therefore the application must wait until the GPU finishes processing
commands before it modifies the data.
Figure 9-4 Single-buffered vertex array data
CPU
GPU
Vertex array 1 Vertex array 1
Vertex array 1 Vertex array 1
glFlush glFlush
glFinishObject(..., 1) glFinishObject(..., 1)
Time Frame 1 Frame 2
OpenGL Application Design Strategies
Use Double Buffering to Avoid Resource Conflicts
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
100To solve this problem, your application could fill this idle time with other processing, even other OpenGL
processing that does not need the objects in question. If you need to process more OpenGL commands, the
solution is to create two of the same resource type and let each participant access a resource. Figure 9-5
illustrates the double-buffered approach. While the GPU operates on one set of vertex array data, the CPU is
modifying the other. After the initialstartup, neither processing unit isidle. This example uses a fence to ensure
that access to each buffer is synchronized.
Figure 9-5 Double-buffered vertex array data
CPU Vertex array 1 Vertex array 1
GPU Vertex array 1 Vertex array 1
Vertex array 2 Vertex array 2
Vertex array 2 Vertex array 2
glFlush glFlush glFlush glFlush
glFinishObject(..., 1) glFinishObject(..., 1)
glFinishObject(..., 2) glFinishObject(..., 2)
Time Frame 1 Frame 2 Frame 3 Frame 4
Double buffering issufficient for most applications, but it requiresthat both participantsfinish processing their
commands before a swap can occur. For a traditional producer-consumer problem, more than two buffers
may prevent a participant from blocking. With triple buffering, the producer and consumer each have a buffer,
with a third idle buffer. If the producer finishes before the consumer finishes processing commands, it takes
the idle buffer and continues to process commands. In this situation, the producer idles only if the consumer
falls badly behind.
Be Mindful of OpenGL State Variables
The hardware has one current state, which is compiled and cached. Switching state is expensive, so it's best
to design your application to minimize state switches.
Don't set a state that's already set. Once a feature is enabled, it does not need to be enabled again. Calling an
enable function more than once does nothing except waste time because OpenGL does not check the state
of a feature when you call glEnable or glDisable. For instance, if you call glEnable(GL_LIGHTING) more
than once, OpenGL does not check to see if the lighting state is already enabled. It simply updates the state
value even if that value is identical to the current value.
OpenGL Application Design Strategies
Be Mindful of OpenGL State Variables
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
101You can avoid setting a state more than necessary by using dedicated setup or shutdown routines rather than
putting such callsin a drawing loop. Setup and shutdown routines are also useful for turning on and off features
that achieve a specific visual effect—for example, when drawing a wire-frame outline around a textured
polygon.
If you are drawing 2D images, disable all irrelevant state variables, similar to what's shown in Listing 9-3.
Listing 9-3 Disabling state variables
glDisable(GL_DITHER);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
glDisable(GL_FOG);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glPixelZoom(1.0,1.0);
// Disable other state variables as appropriate.
Replace State Changes with OpenGL Objects
The “Be Mindful of OpenGL State Variables” (page 101) section suggests that reducing the number of state
changes can improve performance. Some OpenGL extensions also allow you to create objects that collect
multiple OpenGL state changes into an object that can be bound with a single function call. Where such
techniques are available, they are recommended. For example, configuring the fixed-function pipeline requires
many function calls to change the state of the various operators. Not only does this incur overhead for each
function called, but the code is more complex and difficult to manage. Instead, use a shader. A shader, once
compiled, can have the same effect but requires only a single call to glUseProgram.
Other examples of objects that take the place of multiple state changes include the “Vertex Array Range
Extension” (page 113) and “Uniform Buffers” (page 143).
Use Optimal Data Types and Formats
If you don't use data types and formats that are native to the graphics hardware, OpenGL must convert those
data types into a format that the graphics hardware understands.
OpenGL Application Design Strategies
Replace State Changes with OpenGL Objects
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
102For vertex data, use GLfloat, GLshort, or GLubyte data types. Most graphics hardware handle these types
natively.
For texture data, you’ll get the best performance if you use the following format and data type combination:
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV
These format and data type combinations also provide acceptable performance:
GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV
GL_YCBCR_422_APPLE, GL_UNSIGNED_SHORT_8_8_REV_APPLE
The combination GL_RGBA and GL_UNSIGNED_BYTE needs to be swizzled by many cards when the data is
loaded, so it's not recommended.
Use OpenGL Macros
OpenGL performs a global context and renderer lookup for each command it executesto ensure that all OpenGL
commands are issued to the correct rendering context and renderer. There is significant overhead associated
with these lookups; applicationsthat have extremely high call frequenciesmay find that the overheadmeasurably
affects performance. OS X allows your application to use macros to provide a local context variable and cache
the current renderer in that variable. You get more benefit from using macros when your code makes millions
of function calls per second.
Before implementing this technique, consider carefully whether you can redesign your application to perform
less function calls. Frequently changing OpenGL state, pushing or popping matrices, or even submitting one
vertex at a time are all examples of techniques that should be replaced with more efficient operations.
You can use the CGL macro header (CGL/CGLMacro.h) if your application uses CGL from a Cocoa application.
You must define the local variable cgl_ctx to be equal to the current context. Listing 9-4 shows what's needed
to set up macro use for the CGL API. First, you need to include the correct macro header. Then, you must set
the current context.
Listing 9-4 Using CGL macros
#include // include the header
CGL_MACRO_DECLARE_VARIABLES // set the current context
glBegin (GL_QUADS); // This code now uses the macro
// draw here
glEnd ();
OpenGL Application Design Strategies
Use OpenGL Macros
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
103Complex shapes and detailed 3D models require large amounts of vertex data to describe them in OpenGL.
Moving vertex data from your application to the graphics hardware incurs a performance cost that can be
quite large depending on the size of the data set.
Figure 10-1 Vertex data sets can be quite large
Applications that use large vertex data sets can adopt one or more of the strategies described in “OpenGL
Application Design Strategies” (page 89) to optimize how vertex data is delivered to OpenGL.This chapter
expands on those best practices with specific techniques for working with vertex data.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
104
Best Practices for Working with Vertex DataUnderstand How Vertex Data Flows Through OpenGL
Understanding how vertex data flows through OpenGL is important to choosing strategies for handling the
data. Vertex data enters into the vertex stage, where it is processed by either the built-in fixed function vertex
stage or a custom vertex.
Figure 10-2 Vertex data path
Rasterization
Fragment shading
and per-fragment
operations
Per-pixel
operations
Texture
assembly
Framebuffer
Vertex shading
and per-vertex
operations
Pixel data
Vertex data
Figure 10-3 takes a closer look at the vertex data path when using immediate mode. Without any optimizations,
your vertex data may be copied at various points in the data path. If your application uses immediate mode
to each vertex separately, calls to OpenGL first modify the current vertex, which is copied into the command
buffer whenever your application makes a glVertex* call. Thisis not only expensive in terms of copy operations,
but also in function overhead to specify each vertex.
Figure 10-3 Immediate mode requires a copy of the current vertex data
GPU
VRAM
Copy
Copy
Original
Command buffer
Current vertex
Application
Best Practices for Working with Vertex Data
Understand How Vertex Data Flows Through OpenGL
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
105The OpenGL commands glDrawRangeElements, glDrawElements, and glDrawArrays render multiple
geometric primitives from array data, using very few subroutine calls. Listing 10-1 shows a typical
implementation. Your application creates a vertex structure that holds all the elements for each vertex. For
each element , you enable a client array and provide a pointer and offset to OpenGL so that it knows how to
find those elements.
Listing 10-1 Submitting vertex data using glDrawElements.
typedef struct _vertexStruct
{
GLfloat position[2];
GLubyte color[4];
} vertexStruct;
void DrawGeometry()
{
const vertexStruct vertices[] = {...};
const GLubyte indices[] = {...};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(vertexStruct), &vertices[0].position);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(vertexStruct), &vertices[0].color);
glDrawElements(GL_TRIANGLE_STRIP, sizeof(indices)/sizeof(GLubyte),
GL_UNSIGNED_BYTE, indices);
}
Each time you call glDrawElements, OpenGL must copy all of the vertex data into the command buffer, which
is later copied to the hardware. The copy overhead is still expensive.
Best Practices for Working with Vertex Data
Understand How Vertex Data Flows Through OpenGL
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
106Techniques for Handling Vertex Data
Avoiding unnecessary copies of your vertex data is critical to application performance. Thissection summarizes
common techniques for managing your vertex data using either built-in functionality or OpenGL extensions.
Before using these techniques, you must ensure that the necessary functions are available to your application.
See “Detecting Functionality” (page 83).
● Avoid the use of glBegin and glEnd to specify your vertex data. The function and copying overhead
makes this path useful only for very small data sets. Also, applications written with glBegin and glEnd
are not portable to OpenGL ES on iOS.
● Minimize data type conversions by supplying OpenGL data types for vertex data. Use GLfloat, GLshort,
or GLubyte data types because most graphics processors handle these types natively. If you use some
other type, then OpenGL may need to perform a costly data conversion.
● The preferred way to manage your vertex data is with vertex buffer objects. Vertex buffer objects are
buffers owned by OpenGL that hold your vertex information. These buffers allow OpenGL to place your
vertex data into memory that is accessible to the graphics hardware. See “Vertex Buffers” (page 107) for
more information.
●
If vertex buffer objects are not available, your application can search for the
GL_APPLE_vertex_array_range and APPLE_fence extensions. Vertex array ranges allow you to
prevent OpenGL from copying your vertex data into the command buffer. Instead, your application must
avoid modifying or deleting the vertex data until OpenGL finishes executing drawing commands. This
solution requires more effort from the application, and is not compatible with other platforms, including
iOS. See “Vertex Array Range Extension” (page 113) for more information.
● Complex vertex operations require many array pointers to be enabled and set before you call
glDrawElements. The GL_APPLE_vertex_array_object extension allows your application to
consolidate a group of array pointers into a single object. Your application switches multiple pointers by
binding a single vertex array object, reducing the overhead of changing state. See “Vertex Array
Object” (page 116).
● Use double buffering to reduce resource contention between your application and OpenGL. See “Use
Double Buffering to Avoid Resource Conflicts” (page 100).
●
If you need to compute new vertex information between frames, consider using vertex shaders and buffer
objects to perform and store the calculations.
Vertex Buffers
Vertex buffers are available as a core feature starting in OpenGL 1.5, and on earlier versions of OpenGL through
the vertex buffer object extension (GL_ARB_vertex_buffer_object). Vertex buffers are used to improve
the throughput of static or dynamic vertex data in your application.
Best Practices for Working with Vertex Data
Techniques for Handling Vertex Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
107A buffer object is a chunk of memory owned by OpenGL. Your application reads from or writes to the buffer
using OpenGL callssuch as glBufferData, glBufferSubData, and glGetBufferSubData. Your application
can also gain a pointer to this memory, an operation referred to as mapping a buffer. OpenGL prevents your
application and itself from simultaneously using the data stored in the buffer. When your application maps a
buffer or attempts to modify it, OpenGL may block until previous drawing commands have completed.
Using Vertex Buffers
You can set up and use vertex buffers by following these steps:
1. Call the function glGenBuffers to create a new name for a buffer object.
void glGenBuffers(sizei n, uint *buffers );
n is the number of buffers you wish to create identifiers for.
buffers specifies a pointer to memory to store the buffer names.
2. Call the function glBindBuffer to bind an unused name to a buffer object. After this call, the newly
created buffer object is initialized with a memory buffer of size zero and a default state. (For the default
setting, see the OpenGL specification for ARB_vertex_buffer_object.)
void glBindBuffer(GLenum target, GLuint buffer);
target must be set to GL_ARRAY_BUFFER.
buffer specifies the unique name for the buffer object.
3. Fill the buffer object by calling the function glBufferData. Essentially, this call uploads your data to the
GPU.
void glBufferData(GLenum target, sizeiptr size,
const GLvoid *data, GLenum usage);
target must be set to GL_ARRAY_BUFFER.
size specifies the size of the data store.
*data points to the source data. If this is not NULL, the source data is copied to the data stored of the
buffer object. If NULL, the contents of the data store are undefined.
Best Practices for Working with Vertex Data
Vertex Buffers
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
108usage is a constant that provides a hint as to how your application plans to use the data stored in the
buffer object. These examples use GL_STREAM_DRAW, which indicates that the application plans to both
modify and draw using the buffer, and GL_STATIC_DRAW, which indicates that the application will define
the data once but use it to draw many times. For more details on buffer hints,see “Buffer Usage Hints” (page
110)
4. Enable the vertex array by calling glEnableClientState and supplying the GL_VERTEX_ARRAY constant.
5. Point to the contents of the vertex buffer object by calling a function such as glVertexPointer. Instead
of providing a pointer, you provide an offset into the vertex buffer object.
6. To update the data in the buffer object, your application calls glMapBuffer. Mapping the buffer prevents
the GPU from operating on the data, and gives your application a pointer to memory it can use to update
the buffer.
void *glMapBuffer(GLenum target, GLenum access);
target must be set to GL_ARRAY_BUFFER.
access indicatesthe operations you plan to performon the data. You can supply READ_ONLY, WRITE_ONLY,
or READ_WRITE.
7. Write pixel data to the pointer received from the call to glMapBuffer.
8. When your application hasfinished modifying the buffer contents, call the function glUnmapBuffer. You
must supply GL_ARRAY_BUFFER as the parameter to this function. Once the buffer is unmapped, the
pointer is no longer valid, and the buffer’s contents are uploaded again to the GPU.
Listing 10-2 shows code that usesthe vertex buffer object extension for dynamic data. This example overwrites
all of the vertex data during every draw operation.
Listing 10-2 Using the vertex buffer object extension with dynamic data
// To set up the vertex buffer object extension
#define BUFFER_OFFSET(i) ((char*)NULL + (i))
glBindBuffer(GL_ARRAY_BUFFER, myBufferName);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, stride, BUFFER_OFFSET(0));
// When you want to draw using the vertex data
draw_loop {
Best Practices for Working with Vertex Data
Vertex Buffers
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
109glBufferData(GL_ARRAY_BUFFER, bufferSize, NULL, GL_STREAM_DRAW);
my_vertex_pointer = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
GenerateMyDynamicVertexData(my_vertex_pointer);
glUnmapBuffer(GL_ARRAY_BUFFER);
PerformDrawing();
}
Listing 10-3 shows code that uses the vertex buffer object extension with static data.
Listing 10-3 Using the vertex buffer object extension with static data
// To set up the vertex buffer object extension
#define BUFFER_OFFSET(i) ((char*)NULL + (i))
glBindBuffer(GL_ARRAY_BUFFER, myBufferName);
glBufferData(GL_ARRAY_BUFFER, bufferSize, NULL, GL_STATIC_DRAW);
GLvoid* my_vertex_pointer = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
GenerateMyStaticVertexData(my_vertex_pointer);
glUnmapBuffer(GL_ARRAY_BUFFER);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, stride, BUFFER_OFFSET(0));
// When you want to draw using the vertex data
draw_loop {
PerformDrawing();
}
Buffer Usage Hints
A key advantage of buffer objectsisthat the application can provide information on how it usesthe data stored
in each buffer. For example, Listing 10-2 and Listing 10-3 differentiated between cases where the data were
expected to never change (GL_STATIC_DRAW) and cases where the buffer data might change
(GL_DYNAMIC_DRAW). The usage parameter allows an OpenGL renderer to alter its strategy for allocating the
vertex buffer to improve performance. For example, static buffers may be allocated directly in GPU memory,
while dynamic buffers may be stored in main memory and retrieved by the GPU via DMA.
If OpenGL ES compatibility is useful to you, you should limit your usage hints to one of three usage cases:
Best Practices for Working with Vertex Data
Vertex Buffers
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
110● GL_STATIC_DRAW should be used for vertex data that isspecified once and never changed. Your application
should create these vertex buffers during initialization and use them repeatedly until your application
shuts down.
● GL_DYNAMIC_DRAW should be used when the buffer is expected to change after it is created. Your
application should still allocate these buffers during initialization and periodically update them by mapping
the buffer.
● GL_STREAM_DRAW is used when your application needs to create transient geometry that is rendered and
then discarded. This is most useful when your application must dynamically change vertex data every
frame in a way that cannot be performed in a vertex shader. To use a stream vertex buffer, your application
initially fills the buffer using glBufferData, then alternates between drawing using the buffer and
modifying the buffer.
Other usage constants are detailed in the vertex buffer specification.
If different elements in your vertex format have different usage characteristics, you may want to split the
elements into one structure for each usage pattern and allocate a vertex buffer for each. Listing 10-4 shows
how to implement this. In this example, position data is expected to be the same in each frame, while color
data may be animated in every frame.
Listing 10-4 Geometry with different usage patterns
typedef struct _vertexStatic
{
GLfloat position[2];
} vertexStatic;
typedef struct _vertexDynamic
{
GLubyte color[4];
} vertexDynamic;
// Separate buffers for static and dynamic data.
GLuint staticBuffer;
GLuint dynamicBuffer;
GLuint indexBuffer;
const vertexStatic staticVertexData[] = {...};
vertexDynamic dynamicVertexData[] = {...};
Best Practices for Working with Vertex Data
Vertex Buffers
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
111const GLubyte indices[] = {...};
void CreateBuffers()
{
glGenBuffers(1, &staticBuffer);
glGenBuffers(1, &dynamicBuffer);
glGenBuffers(1, &indexBuffer);
// Static position data
glBindBuffer(GL_ARRAY_BUFFER, staticBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(staticVertexData), staticVertexData,
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// Dynamic color data
// While not shown here, the expectation is that the data in this buffer changes
between frames.
glBindBuffer(GL_ARRAY_BUFFER, dynamicBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(dynamicVertexData), dynamicVertexData,
GL_DYNAMIC_DRAW);
}
void DrawUsingVertexBuffers()
{
glBindBuffer(GL_ARRAY_BUFFER, staticBuffer);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(vertexStatic),
(void*)offsetof(vertexStatic,position));
glBindBuffer(GL_ARRAY_BUFFER, dynamicBuffer);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(vertexDynamic),
(void*)offsetof(vertexDynamic,color));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
Best Practices for Working with Vertex Data
Vertex Buffers
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
112glDrawElements(GL_TRIANGLE_STRIP, sizeof(indices)/sizeof(GLubyte),
GL_UNSIGNED_BYTE, (void*)0);
}
Flush Buffer Range Extension
When your application unmaps a vertex buffer, the OpenGL implementation may copy the full contents of the
buffer to the graphics hardware. If your application changes only a subset of a large buffer, this is inefficient.
The APPLE_flush_buffer_range extension allows your application to tell OpenGL exactly which portions
of the buffer were modified, allowing it to send only the changed data to the graphics hardware.
To use the flush buffer range extension, follow these steps:
1. Turn on the flush buffer extension by calling glBufferParameteriAPPLE.
glBufferParameteriAPPLE(GL_ARRAY_BUFFER,GL_BUFFER_FLUSHING_UNMAP_APPLE,
GL_FALSE);
This disables the normal flushing behavior of OpenGL.
2. Before you unmap a buffer, you must call glFlushMappedBufferRangeAPPLE for each range of the
buffer that was modified by the application.
void glFlushMappedBufferRangeAPPLE(enum target, intptr offset, sizeiptr
size);
target is the type of buffer being modified; for vertex data it’s ARRAY_BUFFER.
offset is the offset into the buffer for the modified data.
size is the length of the modified data in bytes.
3. Call glUnmapBuffer. OpenGL unmaps the buffer, but it is required to update only the portions of the
buffer your application explicitly marked as changed.
For more information see the APPLE_flush_buffer_range specification.
Vertex Array Range Extension
The vertex array range extension (APPLE_vertex_array_range) lets you define a region of memory for your
vertex data. The OpenGL driver can optimize memory usage by creating a single memory mapping for your
vertex data. You can also provide a hint as to how the data should be stored: cached or shared. The cached
Best Practices for Working with Vertex Data
Vertex Array Range Extension
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
113option specifiesto cache vertex data in video memory. The shared option indicatesthat data should be mapped
into a region of memory that allows the GPU to access the vertex data directly using DMA transfer. This option
is best for dynamic data. If you use shared memory, you'll need to double buffer your data.
You can set up and use the vertex array range extension by following these steps:
1. Enable the extension by calling glEnableClientState and supplying the
GL_VERTEX_ARRAY_RANGE_APPLE constant.
2. Allocate storage for the vertex data. You are responsible for maintaining storage for the data.
3. Define an array of vertex data by calling a function such as glVertexPointer. You need to supply a
pointer to your data.
4. Optionally set up a hint about handling the storage of the array data by calling the function
glVertexArrayParameteriAPPLE.
GLvoid glVertexArrayParameteriAPPLE(GLenum pname, GLint param);
pname must be VERTEX_ARRAY_STORAGE_HINT_APPLE.
param is a hint that specifies how your application expects to use the data. OpenGL uses this hint to
optimize performance. You can supply either STORAGE_SHARED_APPLE or STORAGE_CACHED_APPLE.
The default value is STORAGE_SHARED_APPLE, which indicates that the vertex data is dynamic and that
OpenGL should use optimization and flushing techniques suitable for this kind of data. If you expect the
supplied data to be static, use STORAGE_CACHED_APPLE so that OpenGL can optimize appropriately.
5. Call the OpenGL function glVertexArrayRangeAPPLE to establish the data set.
void glVertexArrayRangeAPPLE(GLsizei length, GLvoid *pointer);
length specifies the length of the vertex array range. The length is typically the number of unsigned
bytes.
*pointer points to the base of the vertex array range.
6. Draw with the vertex data using standard OpenGL vertex array commands.
7. If you need to modify the vertex data,set a fence object after you’ve submitted all the drawing commands.
See “Use Fences for Finer-Grained Synchronization” (page 98)
8. Perform other work so that the GPU has time to process the drawing commands that use the vertex array.
9. Call glFinishFenceAPPLE to gain access to the vertex array.
10. Modify the data in the vertex array.
11. Call glFlushVertexArrayRangeAPPLE.
Best Practices for Working with Vertex Data
Vertex Array Range Extension
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
114void glFlushVertexArrayRangeAPPLE(GLsizei length, GLvoid *pointer);
length specifies the length of the vertex array range, in bytes.
*pointer points to the base of the vertex array range.
For dynamic data, each time you change the data, you need to maintain synchronicity by calling
glFlushVertexArrayRangeAPPLE. You supply as parameters an array size and a pointer to an array,
which can be a subset of the data, as long as it includes all of the data that changed. Contrary to the name
of the function, glFlushVertexArrayRangeAPPLE doesn't actually flush data like the OpenGL function
glFlush does. It simply makes OpenGL aware that the data has changed.
Listing 10-5 shows code thatsets up and usesthe vertex array range extension with dynamic data. It overwrites
all of the vertex data during each iteration through the drawing loop. The call to the glFinishFenceAPPLE
command guaranteesthat the CPU and the GPU don't accessthe data at the same time. Although this example
calls the glFinishFenceAPPLE function almost immediately after setting the fence, in reality you need to
separate these calls to allow parallel operation of the GPU and CPU. To see how that's done, read “Use Double
Buffering to Avoid Resource Conflicts” (page 100).
Listing 10-5 Using the vertex array range extension with dynamic data
// To set up the vertex array range extension
glVertexArrayParameteriAPPLE(GL_VERTEX_ARRAY_STORAGE_HINT_APPLE,
GL_STORAGE_SHARED_APPLE);
glVertexArrayRangeAPPLE(buffer_size, my_vertex_pointer);
glEnableClientState(GL_VERTEX_ARRAY_RANGE_APPLE);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, my_vertex_pointer);
glSetFenceAPPLE(my_fence);
// When you want to draw using the vertex data
draw_loop {
glFinishFenceAPPLE(my_fence);
GenerateMyDynamicVertexData(my_vertex_pointer);
glFlushVertexArrayRangeAPPLE(buffer_size, my_vertex_pointer);
PerformDrawing();
glSetFenceAPPLE(my_fence);
}
Best Practices for Working with Vertex Data
Vertex Array Range Extension
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
115Listing 10-6 shows code that usesthe vertex array range extension with static data. Unlike the setup for dynamic
data, the setup forstatic data includes using the hint for cached data. Because the data isstatic, it's unnecessary
to set a fence.
Listing 10-6 Using the vertex array range extension with static data
// To set up the vertex array range extension
GenerateMyStaticVertexData(my_vertex_pointer);
glVertexArrayParameteriAPPLE(GL_VERTEX_ARRAY_STORAGE_HINT_APPLE,
GL_STORAGE_CACHED_APPLE);
glVertexArrayRangeAPPLE(array_size, my_vertex_pointer);
glEnableClientState(GL_VERTEX_ARRAY_RANGE_APPLE);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, stride, my_vertex_pointer);
// When you want to draw using the vertex data
draw_loop {
PerformDrawing();
}
For detailed information on this extension, see the OpenGL specification for the vertex array range extension.
Vertex Array Object
Look at the DrawUsingVertexBuffers function in Listing 10-4 (page 111). It configures buffer pointers for
position, color, and indexing before calling glDrawElements. A more complex vertex structure may require
additional buffer pointers to be enabled and changed before you can finally draw your geometry. If your
application swaps frequently between multiple configurations of elements, changing these parameters adds
significant overhead to your application. The APPLE_vertex_array_object extension allows you to combine
a collection of buffer pointers into a single OpenGL object, allowing you to change all the buffer pointers by
binding a different vertex array object.
To use this extension, follow these steps during your application’s initialization routines:
1. Generate a vertex array object for a configuration of pointers you wish to use together.
Best Practices for Working with Vertex Data
Vertex Array Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
116void glGenVertexArraysAPPLE(sizei n, const uint *arrays);
n is the number of arrays you wish to create identifiers for.
arrays specifies a pointer to memory to store the array names.
glGenVertexArraysAPPLE(1,&myArrayObject);
2. Bind the vertex array object you want to configure.
void glBindVertexArrayAPPLE(uint array);
array is the identifier for an array that you received from glGenVertexArraysAPPLE.
glBindVertexArrayAPPLE(myArrayObject);
3. Call the pointer routines (glColorPointer and so forth.) that you would normally call inside your
rendering loop. When a vertex array object is bound, these calls change the currently bound vertex array
object instead of the default OpenGL state.
glBindBuffer(GL_ARRAY_BUFFER, staticBuffer);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(vertexStatic),
(void*)offsetof(vertexStatic,position));
...
4. Repeat the previous steps for each configuration of vertex pointers.
5. Inside your rendering loop, replace the calls to configure the array pointers with a call to bind the vertex
array object.
glBindVertexArrayAPPLE(myArrayObject);
glDrawArrays(...);
6. If you need to get back to the default OpenGL behavior, call glBindVertexArrayAPPLE and pass in 0.
glBindVertexArrayAPPLE(0);
Best Practices for Working with Vertex Data
Vertex Array Object
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
117Textures add realism to OpenGL objects. They help objects defined by vertex data take on the material properties
of real-world objects, such as wood, brick, metal, and fur. Texture data can originate from many sources,
including images.
Many of the same techniques your application uses on vertex data can also be used to improve texture
performance.
Figure 11-1 Textures add realism to a scene
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
118
Best Practices for Working with Texture DataTextures start as pixel data that flows through an OpenGL program, as shown in Figure 11-2.
Figure 11-2 Texture data path
Rasterization
Fragment shading
and per-fragment
operations
Per-pixel
operations
Texture
assembly
Framebuffer
Vertex shading
and per-vertex
operations
Pixel data
Vertex data
The precise route that texture data takesfrom your application to itsfinal destination can impact the performance
of your application. The purpose of this chapter is to provide techniques you can use to ensure optimal
processing of texture data in your application. This chapter
●
shows how to use OpenGL extensions to optimize performance
●
lists optimal data formats and types
● provides information on working with textures whose dimensions are not a power of two
● describes creating textures from image data
●
shows how to download textures
● discusses using double buffers for texture data
Using Extensions to Improve Texture Performance
Without any optimizations, texture data flows through an OpenGL program as shown in Figure 11-3. Data from
your application first goes to the OpenGL framework, which may make a copy of the data before handing it
to the driver. If your data is not in a native format for the hardware (see “Optimal Data Formats and Types” (page
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
119128)), the driver may also make a copy of the data to convert it to a hardware-specific format for uploading to
video memory. Video memory, in turn, can keep a copy of the data. Theoretically, there could be four copies
of your texture data throughout the system.
Figure 11-3 Data copies in an OpenGL program
GPU
VRAM
OpenGL driver
OpenGL framework
Application
Data flows at different rates through the system, as shown by the size of the arrows in Figure 11-3. The fastest
data transfer happens between VRAM and the GPU. The slowest transfer occurs between the OpenGL driver
and VRAM. Data moves between the application and the OpenGL framework, and between the framework
and the driver at the same "medium" rate. Eliminating any of the data transfers, but the slowest one in particular,
will improve application performance.
There are several extensions you can use to eliminate one or more data copies and control how texture data
travels from your application to the GPU:
● GL_ARB_pixel_buffer_object allows your application to use OpenGL buffer objectsto manage texture
and image data. As with vertex buffer objects, they allow your application to hint how a buffer is used
and to decide when data is copied to OpenGL.
● GL_APPLE_client_storage allows you to prevent OpenGL from copying your texture data into the
client. Instead, OpenGL keepsthe memory pointer you provided when creating the texture. Your application
must keep the texture data at that location until the referencing OpenGL texture is deleted.
● GL_APPLE_texture_range, along with a storage hint, either GL_STORAGE_CACHED_APPLE or
GL_STORAGE_SHARED_APPLE, allows you to specify a single block of texture memory and manage it as
you see fit.
● GL_ARB_texture_rectangle provides support for non-power of-two textures.
Here are some recommendations:
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
120●
If your application requires optimal texture upload performance, use GL_APPLE_client_storage and
GL_APPLE_texture_range together to manage your textures.
●
If your application requires optimal texture download performance, use pixel buffer objects.
●
If your application requires cross-platform techniques, use pixel buffer objects for both texture uploads
and texture downloads.
● Use GL_ARB_texture_rectangle when your source images are not aligned to a power-of-2 size.
The sections that follow describe the extensions and show how to use them.
Pixel Buffer Objects
Pixel buffer objects are a core feature of OpenGL 2.1 and also available through the
GL_ARB_pixel_buffer_object extension. The procedure for setting up a pixel buffer object is almost
identical to that of vertex buffer objects.
Using Pixel Buffer Objects to Efficiently Load Textures
1. Call the function glGenBuffers to create a new name for a buffer object.
void glGenBuffers(sizei n, uint *buffers );
n is the number of buffers you wish to create identifiers for.
buffers specifies a pointer to memory to store the buffer names.
2. Call the function glBindBuffer to bind an unused name to a buffer object. After this call, the newly
created buffer object is initialized with a memory buffer of size zero and a default state. (For the default
setting, see the OpenGL specification for ARB_vertex_buffer_object.)
void glBindBuffer(GLenum target, GLuint buffer);
target should be be set to GL_PIXEL_UNPACK_BUFFER to use the buffer as the source of pixel data.
buffer specifies the unique name for the buffer object.
3. Create and initialize the data store of the buffer object by calling the function glBufferData. Essentially,
this call uploads your data to the GPU.
void glBufferData(GLenum target, sizeiptr size,
const GLvoid *data, GLenum usage);
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
121target must be set to GL_PIXEL_UNPACK_BUFFER.
size specifies the size of the data store.
*data pointsto the source data. If thisis not NULL, the source data is copied to the data store of the buffer
object. If NULL, the contents of the data store are undefined.
usage is a constant that provides a hint as to how your application plans to use the data store. For more
details on buffer hints, see “Buffer Usage Hints” (page 110)
4. Whenever you call glDrawPixels, glTexSubImage or similar functions that read pixel data from the
application, those functions use the data in the bound pixel buffer object instead.
5. To update the data in the buffer object, your application calls glMapBuffer. Mapping the buffer prevents
the GPU from operating on the data, and gives your application a pointer to memory it can use to update
the buffer.
void *glMapBuffer(GLenum target, GLenum access);
target must be set to PIXEL_UNPACK_BUFFER.
access indicatesthe operations you plan to performon the data. You can supply READ_ONLY, WRITE_ONLY,
or READ_WRITE.
6. Modify the texture data using the pointer provided by map buffer.
7. When you have finished modifying the texture, call the function glUnmapBuffer. You should
supplyPIXEL_UNPACK_BUFFER. Once the buffer is unmapped, your application can no longer access the
buffer’s data through the pointer, and the buffer’s contents are uploaded again to the GPU.
Using Pixel Buffer Objects for Asynchronous Pixel Transfers
glReadPixels normally blocks until previous commands have completed, which includes the slow process
of copying the pixel data to the application. However, if you call glReadPixels while a pixel buffer object is
bound, the function returns immediately. It does not block until you actually map the pixel buffer object to
read its content.
1. Call the function glGenBuffers to create a new name for a buffer object.
void glGenBuffers(sizei n, uint *buffers );
n is the number of buffers you wish to create identifiers for.
buffers specifies a pointer to memory to store the buffer names.
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
1222. Call the function glBindBuffer to bind an unused name to a buffer object. After this call, the newly
created buffer object is initialized with a memory buffer of size zero and a default state. (For the default
setting, see the OpenGL specification for ARB_vertex_buffer_object.)
void glBindBuffer(GLenum target, GLuint buffer);
target should be be set to GL_PIXEL_PACK_BUFFER to use the buffer as the destination for pixel data.
buffer specifies the unique name for the buffer object.
3. Create and initialize the data store of the buffer object by calling the function glBufferData.
void glBufferData(GLenum target, sizeiptr size,
const GLvoid *data, GLenum usage);
target must be set to GL_ARRAY_BUFFER.
size specifies the size of the data store.
*data pointsto the source data. If thisis not NULL, the source data is copied to the data store of the buffer
object. If NULL, the contents of the data store are undefined.
usage is a constant that provides a hint as to how your application plans to use the data store. For more
details on buffer hints, see “Buffer Usage Hints” (page 110)
4. Call glReadPixels or a similar function. The function inserts a command to read the pixel data into the
bound pixel buffer object and then returns.
5. To take advantage of asynchronous pixel reads, your application should perform other work.
6. To retrieve the data in the pixel buffer object, your application calls glMapBuffer. This blocks OpenGL
until the previously queued glReadPixels command completes, maps the data, and provides a pointer
to your application.
void *glMapBuffer(GLenum target, GLenum access);
target must be set to GL_PIXEL_PACK_BUFFER.
access indicatesthe operations you plan to performon the data. You can supply READ_ONLY, WRITE_ONLY,
or READ_WRITE.
7. Write vertex data to the pointer provided by map buffer.
8. When you no longer need the vertex data, call the function glUnmapBuffer. You should supply
GL_PIXEL_PACK_BUFFER. Once the buffer is unmapped, the data is no longer accessible to your
application.
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
123Using Pixel Buffer Objects to Keep Data on the GPU
There is no difference between a vertex buffer object and a pixel buffer object except for the target to which
they are bound. An application can take the results in one buffer and use them as another buffer type. For
example, you could use the pixel resultsfrom a fragmentshader and reinterpret them as vertex data in a future
pass, without ever leaving the GPU:
1. Set up your first pass and submit your drawing commands.
2. Bind a pixel buffer object and call glReadPixels to fetch the intermediate results into a buffer.
3. Bind the same buffer as a vertex buffer.
4. Set up the second pass of your algorithm and submit your drawing commands.
Keeping your intermediate data inside the GPU when performing multiple passes can result in great performance
increases.
Apple Client Storage
The Apple client storage extension (APPLE_client_storage) lets you provide OpenGL with a pointer to
memory that your application allocates and maintains. OpenGL retains a pointer to your data but does not
copy the data. Because OpenGL references your data, your application must retain its copy of the data until
all referencing textures are deleted. By using this extension you can eliminate the OpenGL framework copy as
shown in Figure 11-4. Note that a texture width must be a multiple of 32 bytes for OpenGL to bypass the copy
operation from the application to the OpenGL framework.
Figure 11-4 The client storage extension eliminates a data copy
GPU
VRAM
OpenGL driver
OpenGL framework
Application
The Apple clientstorage extension defines a pixelstorage parameter, GL_UNPACK_CLIENT_STORAGE_APPLE,
that you pass to the OpenGL function glPixelStorei to specify that your application retains storage for
textures. The following code sets up client storage:
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
124glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
For detailed information, see the OpenGL specification for the Apple client storage extension.
Apple Texture Range and Rectangle Texture
The Apple texture range extension (APPLE_texture_range) lets you define a region of memory used for
texture data. Typically you specify an address range that encompasses the storage for a set of textures. This
allows the OpenGL driver to optimize memory usage by creating a single memory mapping for all of the
textures. You can also provide a hint as to how the data should be stored: cached or shared. The cached hint
specifies to cache texture data in video memory. This hint is recommended when you have textures that you
plan to use multiple times or that use linear filtering. The shared hint indicates that data should be mapped
into a region of memory that enables the GPU to access the texture data directly (via DMA) without the need
to copy it. This hint is best when you are using large images only once, perform nearest-neighbor filtering, or
need to scale down the size of an image.
The texture range extension defines the following routine for making a single memory mapping for all of the
textures used by your application:
void glTextureRangeAPPLE(GLenum target, GLsizei length, GLvoid *pointer);
target is a valid texture target, such as GL_TEXTURE_2D.
length specifies the number of bytes in the address space referred to by the pointer parameter.
*pointer points to the address space that your application provides for texture storage.
You provide the hint parameter and a parameter value to to the OpenGL function glTexParameteri. The
possible values for the storage hint parameter (GL_TEXTURE_STORAGE_HINT_APPLE) are
GL_STORAGE_CACHED_APPLE or GL_STORAGE_SHARED_APPLE.
Some hardware requires texture dimensions to be a power-of-two before the hardware can upload the data
using DMA. The rectangle texture extension (ARB_texture_rectangle) was introduced to allow texture
targets for textures of any dimensions—that is, rectangle textures (GL_TEXTURE_RECTANGLE_ARB). You need
to use the rectangle texture extension together with the Apple texture range extension to ensure OpenGL
uses DMA to access your texture data. These extensions allow you to bypass the OpenGL driver, as shown in
Figure 11-5.
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
125Note that OpenGL does not use DMA for a power-of-two texture target (GL_TEXTURE_2D). So, unlike the
rectangular texture, the power-of-two texture will incur one additional copy and performance won't be quite
as fast. The performance typically isn't an issue because games, which are the applications most likely to use
power-of-two textures, load textures at the start of a game or level and don't upload textures in real time as
often as applications that use rectangular textures, which usually play video or display images.
The next section has code examples that use the texture range and rectangle textures together with the Apple
client storage extension.
Figure 11-5 The texture range extension eliminates a data copy
GPU
VRAM
OpenGL driver
OpenGL framework
Application
For detailed information on these extensions,see the OpenGL specification for the Apple texture range extension
and the OpenGL specification for the ARB texture rectangle extension.
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
126Combining Client Storage with Texture Ranges
You can use the Apple client storage extension along with the Apple texture range extension to streamline
the texture data path in your application. When used together, OpenGL moves texture data directly into video
memory, as shown in Figure 11-6. The GPU directly accesses your data (via DMA). The set up is slightly different
for rectangular and power-of-two textures. The code examples in this section upload textures to the GPU. You
can also use these extensions to download textures, see “Downloading Texture Data” (page 136).
Figure 11-6 Combining extensions to eliminate data copies
GPU
VRAM
OpenGL driver
OpenGL framework
Application
Listing 11-1 shows how to use the extensions for a rectangular texture. After enabling the texture rectangle
extension you need to bind the rectangular texture to a target. Next, set up the storage hint. Call
glPixelStorei to set up the Apple client storage extension. Finally, call the function glTexImage2D with
a with a rectangular texture target and a pointer to your texture data.
Note: The texture rectangle extension limits what can be done with rectangular textures. To
understand the limitationsin detail, read the OpenGL extension for texture rectangles. See “Working
with Non–Power-of-Two Textures” (page 129) for an overview of the limitations and an alternative
to using this extension.
Listing 11-1 Using texture extensions for a rectangular texture
glEnable (GL_TEXTURE_RECTANGLE_ARB);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, id);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_STORAGE_HINT_APPLE,
GL_STORAGE_CACHED_APPLE);
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
Best Practices for Working with Texture Data
Using Extensions to Improve Texture Performance
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
127glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,
0, GL_RGBA, sizex, sizey, 0, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV,
myImagePtr);
Setting up a power-of-two texture to use these extensions is similar to what's needed to set up a rectangular
texture, as you can see by looking at Listing 11-2. The difference is that the GL_TEXTURE_2D texture target
replaces the GL_TEXTURE_RECTANGLE_ARB texture target.
Listing 11-2 Using texture extensions for a power-of-two texture
glBindTexture(GL_TEXTURE_2D, myTextureName);
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_STORAGE_HINT_APPLE,
GL_STORAGE_CACHED_APPLE);
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
sizex, sizey, 0, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV, myImagePtr);
Optimal Data Formats and Types
The best format and data type combinations to use for texture data are:
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV
GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV)
GL_YCBCR_422_APPLE, GL_UNSIGNED_SHORT_8_8_REV_APPLE
The combination GL_RGBA and GL_UNSIGNED_BYTE needs to be swizzled by many cards when the data is
loaded, so it's not recommended.
Best Practices for Working with Texture Data
Optimal Data Formats and Types
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
128Working with Non–Power-of-Two Textures
OpenGL is often used to process video and images, which typically have dimensionsthat are not a power-of-two.
Until OpenGL 2.0, the texture rectangle extension (ARB_texture_rectangle) provided the only option for
a rectangular texture target. This extension, however, imposesthe following restrictions on rectangular textures:
● You can't use mipmap filtering with them.
● You can use only these wrap modes: GL_CLAMP, GL_CLAMP_TO_EDGE, and GL_CLAMP_TO_BORDER.
● The texture cannot have a border.
● The texture uses non-normalized texture coordinates. (See Figure 11-7.)
OpenGL 2.0 adds another option for a rectangular texture target through the
ARB_texture_non_power_of_two extension, which supports these textures without the limitations of the
ARB_texture_rectangle extension. Before using it, you must check to make sure the functionality is available.
You'll also want to consult the OpenGL specification for the non—power-of-two extension.
Figure 11-7 Normalized and non-normalized coordinates
Normalized Non-normalized
0 1
1
0 Width
Height
If your code runs on a system that does not support either the ARB_texture_rectangle or
ARB_texture_non_power_of_two extensions you have these options for working with with rectangular
images:
● Use the OpenGL function gluScaleImage to scale the image so that it fitsin a rectangle whose dimensions
are a power of two. The image undoes the scaling effect when you draw the image from the properly
sized rectangle back into a polygon that has the correct aspect ratio for the image.
Note: This option can result in the loss of some data. But if your application runs on hardware
that doesn'tsupport the ARB_texture_rectangle extension, you may need to use this option.
Best Practices for Working with Texture Data
Working with Non–Power-of-Two Textures
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
129● Segment the image into power-of-two rectangles, as shown in Figure 11-8 by using one image buffer and
different texture pointers. Notice how the sides and corners of the image shown in Figure 11-8 are
segmented into increasingly smaller rectangles to ensure that every rectangle has dimensions that are a
power of two. Special care may be needed at the borders between each segment to avoid filtering artifacts
if the texture is scaled or rotated.
Figure 11-8 An image segmented into power-of-two tiles
Best Practices for Working with Texture Data
Working with Non–Power-of-Two Textures
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
130Creating Textures from Image Data
OpenGL on the Macintosh provides several options for creating high-quality textures from image data. OS X
supports floating-point pixel values, multiple image file formats, and a variety of color spaces. You can import
a floating-point image into a floating-point texture. Figure 11-9 shows an image used to texture a cube.
Figure 11-9 Using an image as a texture for a cube
For Cocoa, you need to provide a bitmap representation. You can create an NSBitmapImageRep object from
the contents of an NSView object. You can use the Image I/O framework (see CGImageSource Reference ). This
framework has support for many different file formats, floating-point data, and a variety of color spaces.
Furthermore, it is easy to use. You can import image data as a texture simply by supplying a CFURL object that
specifies the location of the texture. There is no need for you to convert the image to an intermediate integer
RGB format.
Creating a Texture from a Cocoa View
You can use the NSView class or a subclass of it for texturing in OpenGL. The process is to first store the image
data from an NSView object in an NSBitmapImageRep object so that the image data is in a format that can
be readily used as texture data by OpenGL. Then, after setting up the texture target, you supply the bitmap
data to the OpenGL function glTexImage2D. Note that you must have a valid, current OpenGL context set
up.
Best Practices for Working with Texture Data
Creating Textures from Image Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
131Note: You can't create an OpenGL texture from image data that's provided by a view created from
the following classes: NSProgressIndicator, NSMovieView, and NSOpenGLView. Thisis because
these views do not use the window backing store, which is what the method
initWithFocusedViewRect: reads from.
Listing 11-3 shows a routine that uses this process to create a texture from the contents of an NSView object.
A detailed explanation for each numbered line of code appears following the listing.
Listing 11-3 Building an OpenGL texture from an NSView object
-(void)myTextureFromView:(NSView*)theView
textureName:(GLuint*)texName
{
NSBitmapImageRep * bitmap = [theView bitmapImageRepForCachingDisplayInRect:
[theView visibleRect]]; // 1
int samplesPerPixel = 0;
[theView cacheDisplayInRect:[theView visibleRect] toBitmapImageRep:bitmap];
// 2
samplesPerPixel = [bitmap samplesPerPixel]; // 3
glPixelStorei(GL_UNPACK_ROW_LENGTH, [bitmap bytesPerRow]/samplesPerPixel); // 4
glPixelStorei (GL_UNPACK_ALIGNMENT, 1); // 5
if (*texName == 0) // 6
glGenTextures (1, texName);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, *texName); // 7
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 8
if(![bitmap isPlanar] &&
(samplesPerPixel == 3 || samplesPerPixel == 4)) { // 9
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,
0,
samplesPerPixel == 4 ? GL_RGBA8 : GL_RGB8,
[bitmap pixelsWide],
[bitmap pixelsHigh],
0,
Best Practices for Working with Texture Data
Creating Textures from Image Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
132samplesPerPixel == 4 ? GL_RGBA : GL_RGB,
GL_UNSIGNED_BYTE,
[bitmap bitmapData]);
} else {
// Your code to report unsupported bitmap data
}
}
Here's what the code does:
1. Allocates an NSBitmapImageRep object.
2. Initializes the NSBitmapImageRep object with bitmap data from the current view.
3. Gets the number of samples per pixel.
4. Sets the appropriate unpacking row length for the bitmap.
5. Sets the byte-aligned unpacking that's needed for bitmaps that are 3 bytes per pixel.
6. If a texture object is not passed in, generates a new texture object.
7. Binds the texture name to the texture target.
8. Sets filtering so that it does not use a mipmap, which would be redundant for the texture rectangle
extension.
9. Checks to see if the bitmap is nonplanar and is either a 24-bit RGB bitmap or a 32-bit RGBA bitmap. If so,
retrievesthe pixel data using the bitmapData method, passing it along with other appropriate parameters
to the OpenGL function for specifying a 2D texture image.
Creating a Texture from a Quartz Image Source
Quartz images (CGImageRef data type) are defined in the Core Graphics framework
(ApplicationServices/CoreGraphics.framework/CGImage.h) while the image source data type for
reading image data and creating Quartz images from an image source is declared in the Image I/O framework
(ApplicationServices/ImageIO.framework/CGImageSource.h). Quartz provides routines that read a
wide variety of image data.
To use a Quartz image as a texture source, follow these steps:
1. Create a Quartz image source by supplying a CFURL object to the function
CGImageSourceCreateWithURL.
2. Create a Quartz image by extracting an image from the image source, using the function
CGImageSourceCreateImageAtIndex.
Best Practices for Working with Texture Data
Creating Textures from Image Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
1333. Extract the image dimensions using the function CGImageGetWidth and CGImageGetHeight. You'll
need these to calculate the storage required for the texture.
4. Allocate storage for the texture.
5. Create a color space for the image data.
6. Create a Quartz bitmap graphics context for drawing. Make sure to set up the context for pre-multiplied
alpha.
7. Draw the image to the bitmap context.
8. Release the bitmap context.
9. Set the pixel storage mode by calling the function glPixelStorei.
10. Create and bind the texture.
11. Set up the appropriate texture parameters.
12. Call glTexImage2D, supplying the image data.
13. Free the image data.
Listing 11-4 shows a code fragment that performsthese steps. Note that you must have a valid, current OpenGL
context.
Listing 11-4 Using a Quartz image as a texture source
CGImageSourceRef myImageSourceRef = CGImageSourceCreateWithURL(url, NULL);
CGImageRef myImageRef = CGImageSourceCreateImageAtIndex (myImageSourceRef, 0,
NULL);
GLint myTextureName;
size_t width = CGImageGetWidth(myImageRef);
size_t height = CGImageGetHeight(myImageRef);
CGRect rect = {{0, 0}, {width, height}};
void * myData = calloc(width * 4, height);
CGColorSpaceRef space = CGColorSpaceCreateDeviceRGB();
CGContextRef myBitmapContext = CGBitmapContextCreate (myData,
width, height, 8,
width*4, space,
kCGBitmapByteOrder32Host |
kCGImageAlphaPremultipliedFirst);
CGContextSetBlendMode(myBitmapContext, kCGBlendModeCopy);
CGContextDrawImage(myBitmapContext, rect, myImageRef);
Best Practices for Working with Texture Data
Creating Textures from Image Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
134CGContextRelease(myBitmapContext);
glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &myTextureName);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, myTextureName);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, width, height,
0, GL_BGRA_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, myData);
free(myData);
For more information on using Quartz, see Quartz 2D Programming Guide , CGImage Reference , and
CGImageSource Reference .
Getting Decompressed Raw Pixel Data from a Source Image
You can use the Image I/O framework together with a Quartz data provider to obtain decompressed raw pixel
data from a source image, as shown in Listing 11-5. You can then use the pixel data for your OpenGL texture.
The data has the same format as the source image, so you need to make sure that you use a source image that
has the layout you need.
Alpha is not premultiplied for the pixel data obtained in Listing 11-5, but alpha is premultiplied for the pixel
data you get when using the code described in “Creating a Texture from a Cocoa View” (page 131) and “Creating
a Texture from a Quartz Image Source” (page 133).
Listing 11-5 Getting pixel data from a source image
CGImageSourceRef myImageSourceRef = CGImageSourceCreateWithURL(url, NULL);
CGImageRef myImageRef = CGImageSourceCreateImageAtIndex (myImageSourceRef, 0,
NULL);
CFDataRef data = CGDataProviderCopyData(CGImageGetDataProvider(myImageRef));
void *pixelData = CFDataGetBytePtr(data);
Best Practices for Working with Texture Data
Creating Textures from Image Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
135Downloading Texture Data
A texture download operation uses the same data path as an upload operation except that the data path is
reversed. Downloading transfers texture data, using direct memory access (DMA), from VRAM into a texture
that can then be accessed directly by your application. You can use the Apple client range, texture range, and
texture rectangle extensions for downloading, just as you would for uploading.
To download texture data using the Apple client storage, texture range, and texture rectangle extensions:
● Bind a texture name to a texture target.
● Set up the extensions
● Call the function glCopyTexSubImage2D to copy a texture subimage from the specified window
coordinates. This call initiates an asynchronous DMA transfer to system memory the next time you call a
flush routine. The CPU doesn't wait for this call to complete.
● Call the function glGetTexImage to transfer the texture into system memory. Note that the parameters
must match the ones that you used to set up the texture when you called the function glTexImage2D.
This call is the synchronization point; it waits until the transfer is finished.
Listing 11-6 shows a code fragment that downloads a rectangular texture that uses cached memory. Your
application processes data between the glCopyTexSubImage2D and glGetTexImage calls. How much
processing? Enough so that your application does not need to wait for the GPU.
Listing 11-6 Code that downloads texture data
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, myTextureName);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_STORAGE_HINT_APPLE,
GL_STORAGE_SHARED_APPLE);
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
sizex, sizey, 0, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV, myImagePtr);
glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB,
0, 0, 0, 0, 0, image_width, image_height);
glFlush();
// Do other work processing here, using a double or triple buffer
glGetTexImage(GL_TEXTURE_RECTANGLE_ARB, 0, GL_BGRA,
Best Practices for Working with Texture Data
Downloading Texture Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
136GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
Double Buffering Texture Data
When you use any technique that allowsthe GPU to access your texture data directly,such asthe texture range
extension, it's possible for the GPU and CPU to access the data at the same time. To avoid such a collision, you
must synchronize the GPU and the CPU. The simplest way is shown in Figure 11-10. Your application works
on the data, flushes it to the GPU and waits until the GPU is finished before working on the data again.
One technique for ensuring that the GPU is finished executing commands before your application sends more
data is to insert a token into the command stream and use that to determine when the CPU can touch the
data again, as described in “Use Fences for Finer-Grained Synchronization” (page 98). Figure 11-10 uses the
fence extension command glFinishObject to synchronize buffer updates for a stream of single-buffered
texture data. Notice that when the CPU is processing texture data, the GPU is idle. Similarly, when the GPU is
processing texture data, the CPU is idle. It's much more efficient for the GPU and CPU to work asynchronously
than to work synchronously. Double buffering data is a technique that allows you to process data asynchronously,
as shown in Figure 11-11 (page 138).
Figure
11-10
Single-buffered data
CPU
GPU
glFinishObject(..., 1) glFinishObject(..., 1)
TIME Frame 1 Frame 2
glFlush glFlush
Best Practices for Working with Texture Data
Double Buffering Texture Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
137To double buffer data, you must supply two sets of data to work on. Note in Figure 11-11 that while the GPU
is rendering one frame of data, the CPU processes the next. After the initial startup, neither processing unit is
idle. Using the glFinishObject function provided by the fence extension ensures that buffer updating is
synchronized.
Figure
11-11
Double-buffered data
CPU
GPU
glFinishObject(..., 1) glFinishObject(..., 1)
glFinishObject(..., 2) glFinishObject(..., 2)
Time Frame 1 Frame 2 Frame 3 Frame 4
glFlush glFlush glFlush glFlush
Best Practices for Working with Texture Data
Double Buffering Texture Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
138OpenGL 1.x used fixed functions to deliver a useful graphics pipeline to application developers. To configure
the various stages of the pipeline shown in Figure 12-1, applications called OpenGL functions to tweak the
calculationsthat were performed for each vertex and fragment. Complex algorithmsrequired multiple rendering
passes and dozens of function calls to configure the calculations that the programmer desired. Extensions
offered new configuration options, but did not change the complex nature of OpenGL programming.
Figure 12-1 OpenGL fixed-function pipeline
Geometry
Fragment
Framebuffer operations
Texturing
Fog
Alpha, stencil, and depth tests
Framebuffer blending
Primitive assembly
Clipping
Vertex
Application Primitives and image data
Transform and lighting
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
139
Customizing the OpenGL Pipeline with ShadersStarting with OpenGL 2.0, some stages of the OpenGL pipeline can be replaced with shaders. A shader is a
program written in a special shading language. This program is compiled by OpenGL and uploaded directly
into the graphics hardware. Figure 12-2 shows where your applications can hook into the pipeline with shaders.
Figure 12-2 OpenGL shader pipeline
Geometry
Fragment
Framebuffer operations
Fragment shaders
Alpha, stencil, and depth tests
Framebuffer blending
Geometry shaders
Clipping
Vertex
Application Primitives and image data
Vertex shaders
Shaders offer a considerable number of advantages to your application:
● Shaders give you precise control over the operations that are performed to render your images.
● Shaders allow for algorithmsto be written in a terse, expressive format. Rather than writing complex blocks
of configuration callsto implement a mathematical operation, you write code that expressesthe algorithm
directly.
● Older graphics processors implemented the fixed-function pipeline in hardware or microcode, but now
graphics processors are general-purpose computing devices. The fixed function pipeline is itself
implemented as a shader.
● Shaders allow for longer and more complex algorithms to be implemented using a single rendering pass.
Because you have extensive control over the pipeline, it is also easier to implement multipass algorithms
without requiring the data to be read back from the GPU.
● Your application can switch between different shaders with a single function call. In contrast, configuring
the fixed-function pipeline incurs significant function-call overhead.
If your application uses the fixed-function pipeline, a critical task is to replace those tasks with shaders.
Customizing the OpenGL Pipeline with Shaders
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
140If you are new to shaders, OpenGL Shading Language , by Randi J. Rost, is an excellent guide for those looking
to learn more about writing shaders and integrating them into your application. The rest of this chapter provides
some boilerplate code, briefly describe the extensions that implement shaders, and discusses tools that Apple
provides to assist you in writing shaders.
Shader Basics
OpenGL 2.0 offers vertex and fragmentshaders, to take over the processing of those two stages of the graphics
pipeline. These same capabilities are also offered by the ARB_shader_objects, ARB_vertex_shader and
ARB_fragment_shaderextensions. Vertex shading is available on all hardware running OS X v10.5 or later.
Fragment shading is available on all hardware running OS X v10.6 and the majority of hardware running OS
X v10.5.
Creating a shader program is an expensive operation compared to other OpenGL state changes. Listing 12-1
presents a typical strategy to load, compile, and verify a shader program.
Listing 12-1 Loading a Shader
/** Initialization-time for shader **/
GLuint shader, prog;
GLchar *shaderText = "... shader text ...";
// Create ID for shader
shader = glCreateShader(GL_VERTEX_SHADER);
// Define shader text
glShaderSource(shaderText);
// Compile shader
glCompileShader(shader);
// Associate shader with program
glAttachShader(prog, shader);
// Link program
glLinkProgram(prog);
// Validate program
glValidateProgram(prog);
// Check the status of the compile/link
glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLen);
if(logLen > 0)
{
// Show any errors as appropriate
glGetProgramInfoLog(prog, logLen, &logLen, log);
Customizing the OpenGL Pipeline with Shaders
Shader Basics
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
141fprintf(stderr, "Prog Info Log: %s\n", log);
}
// Retrieve all uniform locations that are determined during link phase
for(i = 0; i < uniformCt; i++)
{
uniformLoc[i] = glGetUniformLocation(prog, uniformName);
}
// Retrieve all attrib locations that are determined during link phase
for(i = 0; i < attribCt; i++)
{
attribLoc[i] = glGetAttribLocation(prog, attribName);
}
/** Render stage for shaders **/
glUseProgram(prog);
This code loads the text source for a vertex shader, compiles it, and adds it to the program. A more complex
example might also attach fragment and geometry shaders. The program islinked and validated for correctness.
Finally, the program retrieves information about the inputs to the shader and stores then in its own arrays.
When the application is ready to use the shader, it calls glUseProgram to make it the current shader.
For best performance, your application should create shaders when your application is initialized, and not
inside the rendering loop. Inside your rendering loop, you can quickly switch in the appropriate shaders by
calling glUseProgram. For best performance, use the vertex array object extension to also switch in the vertex
pointers. See “Vertex Array Object” (page 116) for more information.
Advanced Shading Extensions
In addition to the standard shader,some Macs offer additionalshading extensionsto reveal advanced hardware
capabilities. Not all of these extensions are available on all hardware,so you need to assess whether the features
of each extension are worth implementing in your application.
Transform Feedback
The EXT_transform_feedback extension is available on all hardware running OS X v10.5 or later. With the
feedback extension, you can capture the results of the vertex shader into a buffer object, which can be used
as an input to future commands. This is similar to the pixel buffer object technique described in “Using Pixel
Buffer Objects to Keep Data on the GPU” (page 124), but more directly captures the results you desire.
Customizing the OpenGL Pipeline with Shaders
Advanced Shading Extensions
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
142GPU Shader 4
The EXT_gpu_shader4 extension extends the OpenGL shading language to offer new operations, including:
● Full integer support.
● Built-in shader variable to reference the current vertex.
● Built-in shader variable to reference the current primitive. This makes it easier to use a shader to use the
same static vertex data to render multiple primitives, using a shader and uniform variables to customize
each instance of that primitive.
● Unfiltered texture fetches using integer coordinates.
● Querying the size of a texture within a shader.
● Offset texture lookups.
● Explicit gradient and LOD texture lookups.
● Depth Cubemaps.
Geometry Shaders
The EXT_geometry_shader4 extension allows your create geometry shaders. A geometry shader accepts
transformed vertices and can add or remove vertices before passing them down to the rasterizer. This allows
the application to add or remove geometry based on the calculated values in the vertex. For example, given
a triangle and its neighboring vertices, your application could emit additional vertices to better create a more
accurate appearance of a curved surface.
Uniform Buffers
The EXT_bindable_uniform extension allows your application to allocate buffer objects and use them as the
source for uniform data in your shaders. Instead of relying on a single block of uniform memory supplied by
OpenGL, your application allocates buffer objects using the same API that it uses to implement vertex buffer
objects (“Vertex Buffers” (page 107)). Instead of making a function call for each uniform variable you want to
change, you can swap all of the uniform data by binding to a different uniform buffer.
Customizing the OpenGL Pipeline with Shaders
Advanced Shading Extensions
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
143Aliasing is the bane of the digital domain. In the early days of the personal computer, jagged edges and blocky
graphics were accepted by the user simply because not much could be done to correct them. Now with faster
hardware and higher-resolution displays, there are several antialiasing techniques that can smooth edges to
achieve a more realistic scene.
OpenGL supports antialiasing that operates at the level of lines and polygons as well as at the level of the full
scene. This chapter discusses techniques for full scene antialiasing (FSAA). If your application needs point or
line antialiasing instead of full scene antialiasing, use the built in OpenGL point and line antialiasing functions.
These are described in Section 3.4.2 in the OpenGL Specification.
The three antialiasing techniques in use today are multisampling, supersampling, and alpha channel blending:
● Multisampling defines a technique for sampling pixel content at multiple locations for each pixel. This is
a good technique to use if you want to smooth polygon edges.
● Supersampling renders at a much higher resolution than what's needed for the display. Prior to drawing
the content to the display, OpenGL scales and filters the content to the appropriate resolution. This is a
good technique to use when you want to smooth texture interiors in addition to polygon edges.
● Alpha channel blending uses the alpha value of a fragment to control how to blend the fragment with
the pixel values that are already in the framebuffer. It's a good technique to use when you want to ensure
that foreground and background images are composited smoothly.
The ARB_multisample extension defines a specification for full scene antialiasing. It describes multisampling
and alpha channel sampling. The specification does not specifically mention supersampling but its wording
doesn't preclude supersampling. The antialiasing methods that are available depend on the hardware and the
actual implementation depends on the vendor. Some graphics cards support antialiasing using a mixture of
multisampling and supersampling. The methodology used to select the samples can vary as well. Your best
approach is to query the renderer to find out exactly what is supported. OpenGL lets you provide a hint to the
renderer asto which antialiasing technique you prefer. Hints are available asrenderer attributesthat you supply
when you create a pixel format object.
A smallersubset of rendererssupport the EXT_framebuffer_blit and EXT_framebuffer_multisample extensions.
These extensions allow your application to create multisampled offscreen frame buffer objects, render detailed
scenesto them, with precise control over when the multisampled renderbuffer isresolved to a single displayable
color per pixel.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
144
Techniques for Scene AntialiasingGuidelines
Keep the following in mind when you set up full scene antialiasing:
● Although a system may have enough VRAM to accommodate a multisample buffer, a large buffer can
affect the ability of OpenGL to maintain a properly working texture set. Keep in mind that the buffers
associated with the rendering context—depth and stencil—increase in size by a factor equal to number
of samples per pixel.
● The OpenGL driver allocates the memory needed for the multisample buffer; your application should not
allocate this memory.
● Any antialiasing algorithm that operates on the full scene requires additional computing resources. There
is a tradeoff between performance and quality. For that reason, you may want to provide a user interface
that allows the user to enable and disable FSAA, or to choose the level of quality for antialiasing.
● The commands glEnable(GL_MULTISAMPLE) and glDisable(GL_MULTISAMPLE) are ignored on
some hardware because some graphics cards have the feature enabled all the time. That doesn't mean
that you should not call these commands because you'll certainly need them on hardware that doesn't
ignore them.
● A hint as to the variant of sampling you want is a suggestion, not a command. Not all hardware supports
all types of antialiasing. Other hardware mixes multisampling with supersampling techniques. The driver
dictates the type of antialiasing that's actually used in your application.
● The best way to find out which sample modes are supported is to call the CGL function
CGLDescribeRenderer with the renderer property kCGLRPSampleModes or kCGLRPSampleAlpha.
You can also determine how many samples the renderer supports by calling CGLDescribeRenderer
with the renderer property kCGLRPMaxSamples.
General Approach
The general approach to setting up full scene antialiasing is as follows:
1. Check to see what's supported. Not all renderers support the ARB multisample extension, so you need to
check for this functionality (see “Detecting Functionality” (page 83)).
To find out what type of antialiasing a specific renderersupports, call the function CGLDescribeRenderer.
Supply the renderer property kCGLRPSampleModes to find out whether the renderer supports
multisampling and supersampling. Supply kCGLRPSampleAlpha to see whether the renderer supports
alpha sampling.
Techniques for Scene Antialiasing
Guidelines
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
145You can choose to exclude unsupported hardware from the pixel format search by specifying only the
hardware thatsupports multisample antialiasing. Keep in mind that if you exclude unsupported hardware,
the unsupported displays will not render anything. If you include unsupported hardware, OpenGL uses
normal aliased rendering to the unsupported displays and multisampled rendering to supported displays.
2. Include these buffer attributes in the attributes array:
● The appropriate sample buffer attribute constant (NSOpenGLPFASampleBuffers or
kCGLPFASampleBuffers) along with the number of multisample buffers. At thistime the specification
allows only one multisample buffer.
● The appropriate samples constant (NSOpenGLPFASamples or kCGLPFASamples) along with the
number ofsamples per pixel. You can supply 2, 4, 6, or more depending on what the renderersupports
and the amount of VRAM available. The value that you supply affects the quality, memory use, and
speed of the multisampling operation. For fastest performance, and to use the least amount of video
memory, specify 2 samples. When you need more quality, specify 4 or more.
● The no recovery attribute ( NSOpenGLPFANoRecovery or kCGLPFANoRecovery). Although enabling
this attribute is not mandatory, it's recommended to prevent OpenGL from using software fallback
as a renderer. Multisampled antialiasing performance is slow in the software renderer.
3. Optionally provide a hint for the type of antialiasing you want—multisampling, supersampling, or alpha
sampling. See “Hinting for a Specific Antialiasing Technique” (page 147).
4. Enable multisampling with the following command:
glEnable(GL_MULTISAMPLE);
Regardless of the enabled state, OpenGL always uses the multisample buffer if you supply the appropriate
buffer attributes when you set up the pixel format object. If you haven'tsupplied the appropriate attributes,
enabling multisampling has no effect.
When multisampling is disabled, all coverage values are set to 1, which gives the appearance of rendering
without multisampling.
Some graphics hardware leaves multisampling enabled all the time. However, don't rely on hardware to
have multisampling enabled; use glEnable to programmatically turn on this feature.
5. Optionally provide hints for the rendering algorithm. You perform this optional step only if you want
OpenGL to compute coverage values by a method other than uniformly weighting samples and averaging
them.
Some hardware supports a multisample filter hint through an OpenGL
extension—GL_NV_multisample_filter_hint. This hint allows an OpenGL implementation to use
an alternative method of resolving the color of multisampled pixels.
Techniques for Scene Antialiasing
General Approach
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
146You can specify that OpenGL usesfaster or nicer rendering by calling the OpenGL function glHint, passing
the constant GL_MULTISAMPLE_FILTER_HINT_NV asthe target parameter and GL_FASTEST or GL_NICEST
as the mode parameter. Hints allow the hardware to optimize the output if it can. There is no performance
penalty or returned error for issuing a hint that's not supported.
For more information, see the OpenGL extension registry for NV_multisample_filter_hint.
Hinting for a Specific Antialiasing Technique
When you set up your renderer and buffer attributes for full scene antialiasing, you can specify a hint to prefer
one antialiasing technique over the others. If the underlying renderer does not have sufficient resources to
support what you request, OpenGL ignores the hint. If you do not supply the appropriate buffer attributes
when you create a pixel format object, then the hint does nothing. Table 13-1 lists the hinting constants
available for the NSOpenGLPixelFormat class and CGL.
Table 13-1 Antialiasing hints
Multisampling Supersampling Alpha blending
NSOpenGLPFAMultisample NSOpenGLPFASupersample NSOpenGLPFASampleAlpha
kCGLPFAMultisample kCGLPFASupersample kCGLPFASampleAlpha
Techniques for Scene Antialiasing
Hinting for a Specific Antialiasing Technique
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
147Concurrency is the notion of multiple things happening at the same time. In the context of computers,
concurrency usually refers to executing tasks on more than one processor at the same time. By performing
work in parallel, tasks complete sooner, and applications become more responsive to the user. The good news
isthat well-designed OpenGL applications already exhibit a specific form of concurrency—concurrency between
application processing on the CPU and OpenGL processing on the GPU. Many of the techniques introduced
in “OpenGL Application Design Strategies” (page 89) are aimed specifically at creating OpenGL applications
that exhibit great CPU-GPU parallelism. However, modern computers not only contain a powerful GPU, but
also contain multiple CPUs. Sometimesthose CPUs have multiple cores, each capable of performing calculations
independently of the others. It is critical that applications be designed to take advantage of concurrency where
possible. Designing a concurrent application means decomposing the work your application performs into
subtasks and identifying which tasks can safely operate in parallel and which tasks must be executed
sequentially—that is, which tasks are dependent on either resources used by other tasks or results returned
from those tasks.
Each process in OS X is made up of one or more threads. A thread is a stream of execution that runs code for
the process. Multicore systems offer true concurrency by allowing multiple threads to execute simultaneously.
Apple offers both traditional threads and a feature called Grand CentralDispatch (GCD). Grand Central Dispatch
allows you to decompose your application into smaller tasks without requiring the application to manage
threads. GCD allocates threads based on the number of cores available on the system and automatically
schedules tasks to those threads.
At a higher level, Cocoa offers NSOperation and NSOperationQueue to provide an Objective-C abstraction
for creating and scheduling units of work. On OS X v10.6, operation queues use GCD to dispatch work; on OS
X v10.5, operation queues create threads to execute your application’s tasks.
This chapter does not attempt describe these technologiesin detail. Before you consider how to add concurrency
to your OpenGL application, you should first readConcurrency Programming Guide . If you plan on managing
threads manually, you should also read Threading Programming Guide . Regardless of which technique you
use, there are additional restrictions when calling OpenGL on multithreaded systems. This chapter helps you
understand when multithreading improves your OpenGL application’s performance, the restrictions OpenGL
places on multithreaded applications, and common design strategies you might use to implement concurrency
in an OpenGL application. Some of these design techniques can get you an improvement in just a few lines
of code.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
148
Concurrency and OpenGLIdentifying Whether an OpenGL Application Can Benefit from
Concurrency
Creating a multithreaded application requires significant effort in the design, implementation, and testing of
your application. Threads also add complexity and overhead to an application. For example, your application
may need to copy data so that it can be handed to a worker thread, or multiple threads may need to synchronize
access to the same resources. Before you attempt to implement concurrency in an OpenGL application, you
should optimize your OpenGL code in a single-threaded environment using the techniques described in
“OpenGL Application Design Strategies” (page 89). Focus on achieving great CPU-GPU parallelism first and
then assess whether concurrent programming can provide an additional performance benefit.
A good candidate has either or both of the following characteristics:
● The application performs many tasks on the CPU that are independent of OpenGL rendering. Games, for
example, simulate the game world, calculate artificial intelligence from computer-controlled opponents,
and play sound. You can exploit parallelism in thisscenario because many of these tasks are not dependent
on your OpenGL drawing code.
● Profiling your application has shown that your OpenGL rendering code spends a lot of time in the CPU.
In this scenario, the GPU is idle because your application is incapable of feeding it commands fast enough.
If your CPU-bound code has already been optimized, you may be able to improve its performance further
by splitting the work into tasks that execute concurrently.
If your application is blocked waiting for the GPU, and has no work it can perform in parallel with its OpenGL
drawing commands, then it is not a good candidate for concurrency. If the CPU and GPU are both idle, then
your OpenGL needs are probably simple enough that no further tuning is useful.
For more information on how to determine where your application spends its time, see “Tuning Your OpenGL
Application” (page 155).
OpenGL Restricts Each Context to a Single Thread
Each thread in an OS X process has a single current OpenGL rendering context. Every time your application
calls an OpenGL function, OpenGL implicitly looks up the context associated with the current thread and
modifies the state or objects associated with that context.
OpenGL is not reentrant. If you modify the same context from multiple threads simultaneously, the results are
unpredictable. Your application might crash or it might render improperly. If for some reason you decide to
set more than one thread to target the same context, then you must synchronize threads by placing a mutex
around all OpenGL calls to the context, such as gl* and CGL*. OpenGL commands that block—such as fence
commands—do not synchronize threads.
Concurrency and OpenGL
Identifying Whether an OpenGL Application Can Benefit from Concurrency
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
149GCD and NSOperationQueue objects can both execute your tasks on a thread of their choosing. They may
create a thread specifically for that task, or they may reuse an existing thread. But in either case, you cannot
guarantee which thread executes the task. For an OpenGL application, that means:
● Each task must set the context before executing any OpenGL commands.
● Your application must ensure that two tasks that access the same context are not allowed to execute
concurrently.
Strategies for Implementing Concurrency in OpenGL Applications
A concurrent OpenGL application wants to focus on CPU parallelism so that OpenGL can provide more work
to the GPU. Here are a few recommended strategies for implementing concurrency in an OpenGL application:
● Decompose your application into OpenGL and non-OpenGL tasks that can execute concurrently. Your
OpenGL rendering code executes as a single task, so it still executes in a single thread. This strategy works
best when your application has other tasks that require significant CPU processing.
●
If performance profiling reveals that your application spends a lot of CPU time inside OpenGL, you can
move some of that processing to another thread by enabling the multithreading in the OpenGL engine.
The advantage of this method is its simplicity; enabling the multithreaded OpenGL engine takes just a
few lines of code. See “Multithreaded OpenGL” (page 150).
●
If your application spends a lot of CPU time preparing data to send to openGL, you can divide the work
between tasks that prepare rendering data and tasks that submit rendering commands to OpenGL. See
“Perform OpenGL Computations in a Worker Task” (page 151)
●
If your application has multiple scenes it can render simultaneously or work it can perform in multiple
contexts, it can create multiple tasks, with an OpenGL context per task. If the contexts can share the same
resources, you can use contextsharing when the contexts are created to share surfaces or OpenGL objects:
display lists, textures, vertex and fragment programs, vertex array objects, and so on. See “Use Multiple
OpenGL Contexts” (page 153)
Multithreaded OpenGL
Whenever your application calls OpenGL, the renderer processes the parameters to put them in a format that
the hardware understands. The time required to process these commands varies depending on whether the
inputs are already in a hardware-friendly format, but there is always some overhead in preparing commands
for the hardware.
Concurrency and OpenGL
Strategies for Implementing Concurrency in OpenGL Applications
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
150If your application spends a lot of time performing calculations inside OpenGL, and you’ve already taken steps
to pick ideal data formats, your application might gain an additional benefit by enabling multithreading inside
the OpenGL engine. The multithreaded OpenGL engine automatically creates a worker thread and transfers
some of its calculationsto that thread. On a multicore system, this allowsinternal OpenGL calculations performed
on the CPU to act in parallel with your application, improving performance. Synchronizing functions continue
to block the calling thread.
Listing 14-1 shows the code required to enable the multithreaded OpenGL engine.
Listing 14-1 Enabling the multithreaded OpenGL engine
CGLError err = 0;
CGLContextObj ctx = CGLGetCurrentContext();
// Enable the multithreading
err = CGLEnable( ctx, kCGLCEMPEngine);
if (err != kCGLNoError )
{
// Multithreaded execution may not be available
// Insert your code to take appropriate action
}
Note: Enabling or disabling multithreaded execution causes OpenGL to flush previous commands
as well as incurring the overhead of setting up the additional thread. You should enable or disable
multithreaded execution in an initialization function rather than in the rendering loop.
Enabling multithreading comes at a cost—OpenGL must copy parameters to transmit them to the worker
thread. Because of this overhead, you should always test your application with and without multithreading
enabled to determine whether it provides a substantial performance improvement.
Perform OpenGL Computations in a Worker Task
Some applications perform lots of calculations on their data before passing that data down to the OpenGL
renderer. For example, the application might create new geometry or animate existing geometry. Where
possible,such calculationsshould be performed inside OpenGL. For example, vertex shaders and the transform
Concurrency and OpenGL
Perform OpenGL Computations in a Worker Task
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
151feedback extension might allow you to perform these calculations entirely within OpenGL. Thistakes advantage
of the greater parallelism available inside the GPU, and reduces the overhead of copying results between your
application and OpenGL.
The approach described in Figure 9-3 (page 92) alternates between updating OpenGL objects and executing
rendering commands that use those objects. OpenGL renders on the GPU in parallel with your application’s
updates running on the CPU. If the calculations performed on the CPU take more processing time than those
on the GPU, then the GPU spends more time idle. In this situation, you may be able to take advantage of
parallelism on systems with multiple CPUs. Split your OpenGL rendering code into separate calculation and
processing tasks, and run them in parallel. Figure 14-1 shows a clear division of labor. One task produces data
that is consumed by the second and submitted to OpenGL.
Figure 14-1 CPU processing and OpenGL on separate threads
CPU
Processing
Shared
data
Framebuffer
OpenGL
context
Texture data
Vertex data
OpenGL
state
OpenGL
surface
Thread 1 Thread 2
For best performance, your application should avoid copying data between the tasks. For example, rather than
calculating the data in one task and copying it into a vertex buffer object in the other, map the vertex buffer
object in the setup code and hand the pointer directly to the worker task.
If your application can further decompose the modifications task into subtasks, you may see better benefits.
For example, assume two or more vertex buffers, each of which needsto be updated before submitting drawing
commands. Each can be recalculated independently of the others. In this scenario, the modifications to each
buffer becomes an operation, using an NSOperationQueue object to manage the work:
1. Set the current context.
2. Map the first buffer.
3. Create an NSOperation object whose task is to fill that buffer.
4. Queue that operation on the operation queue.
Concurrency and OpenGL
Perform OpenGL Computations in a Worker Task
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
1525. Perform steps 2 through 4 for the other buffers.
6. Call waitUntilAllOperationsAreFinished on the operation queue.
7. Unmap the buffers.
8. Execute rendering commands.
On a multicore system, multiple threads of execution may allow the buffers to be filled simultaneously. Steps
7 and 8 could even be performed by a separate operation queued onto the same operation queue, provided
that operation set the proper dependencies.
Use Multiple OpenGL Contexts
If your application has multiple scenes that can be rendered in parallel, you can use a context for each scene
you need to render. Create one context for each scene and assign each context to an operation or task. Because
each task has its own context, all can submit rendering commands in parallel.
The Apple-specific OpenGL APIs also provide the option for sharing data between contexts, as shown in Figure
14-2. Shared resources are automatically set up as mutual exclusion (mutex) objects. Notice that thread 2
draws to a pixel buffer that is linked to the shared state as a texture. Thread 1 can then draw using that texture.
Figure 14-2 Two contexts on separate threads
Pbuffer
surface
Framebuffer
OpenGL context 1
OpenGL state 1
OpenGL context 2
OpenGL state 2
OpenGL
surface
Thread 1 Thread 2
OpenGL
shared state
OpenGL
shared state
OpenGL
shared state
This is the most complex model for designing an application. Changes to objects in one context must be
flushed so that other contextssee the changes. Similarly, when your application finishes operating on an object,
it must flush those commands before exiting, to ensure that all rendering commands have been submitted to
the hardware.
Concurrency and OpenGL
Use Multiple OpenGL Contexts
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
153Guidelines for Threading OpenGL Applications
Follow these guidelines to ensure successful threading in an application that uses OpenGL:
● Use only one thread per context. OpenGL commands for a specific context are not thread safe. You should
never have more than one thread accessing a single context simultaneously.
● Contexts that are on different threads can share object resources. For example, it is acceptable for one
context in one thread to modify a texture, and a second context in a second thread to modify the same
texture. The shared object handling provided by the Apple APIs automatically protects against thread
errors. And, your application is following the "one thread per context" guideline.
● When you use an NSOpenGLView object with OpenGL calls that are issued from a thread other than the
main one, you must set up mutex locking. Mutex locking is necessary because unless you override the
default behavior, the main thread may need to communicate with the view for such things as resizing.
Applications that use Objective-C with multithreading can lock contexts using the functions
CGLLockContext and CGLUnlockContext. If you want to perform rendering in a thread other than the
main one, you can lock the context that you want to access and safely execute OpenGL commands. The
locking calls must be placed around all of your OpenGL calls in all threads.
CGLLockContext blocks the thread it is on until all other threads have unlocked the same context using
the function CGLUnlockContext. You can use CGLLockContext recursively. Context-specific CGL calls
by themselves do not require locking, but you can guarantee serial processing for a group of calls by
surrounding them with CGLLockContext and CGLUnlockContext. Keep in mind that calls from the
OpenGL API (the API provided by the Khronos OpenGL Working Group) require locking.
● Keep track of the current context. When switching threadsit is easy to switch contextsinadvertently, which
causes unforeseen effects on the execution of graphic commands. You must set a current context when
switching to a newly created thread.
Concurrency and OpenGL
Guidelines for Threading OpenGL Applications
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
154After you design and implement your application, it is important that you spend some time analyzing its
performance. The key to performance tuning your OpenGL application is to successively refine the design and
implementation of your application. You do this by alternating between measuring your application, identifying
where the bottleneck is, and removing the bottleneck.
If you are unfamiliar with general performance issues on the Macintosh platform, you will want to read Getting
Started with Performance and Performance Overview. Performance Overview contains general performance
tips that are useful to all applications. It also describes most of the performance tools provided with OS X.
Next, take a close look at Instruments. Instruments consolidates many measurement tools into a single
comprehensive performance-tuning application.
There are two tools other than OpenGL Profiler that are specific for OpenGL development—OpenGL Driver
Monitor and OpenGL Shader Builder. OpenGL Driver Monitor collectsreal-time data from the hardware. OpenGL
Shader Builder provides immediate feedback on vertex and fragment programs that you write.
For more information on these tools, see:
● OpenGL Tools for Serious Graphics Development
● Optimizing with Shark: Big Payoff, Small Effort
●
Instruments User Guide
● Shark User Guide
● Real world profiling with the OpenGL Profiler
● OpenGL Driver Monitor User Guide
● OpenGL Shader Builder User Guide
The following books contain many techniques for getting the most performance from the GPU:
● GPU Gems: Programming Techniques, Tips and Tricks for Real Time Graphics, Randima Fernando. In
particular, Graphics Pipeline Performance is a critical article for understanding how to find the bottlenecks
in your OpenGL application.
● GPU Gems 2: Programming Techniques for High-Performance Graphics and General-Purpose Computation ,
Matt Pharr and Randima Fernando.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
155
Tuning Your OpenGL ApplicationThis chapter focuses on two main topics:
●
“Gathering and Analyzing Baseline Performance Data” (page 156) shows how to use top and OpenGL
Profiler to obtain and interpret baseline performance data.
●
“Identifying Bottlenecks with Shark” (page 161) discussesthe patterns of usage that the Shark performance
tool can make apparent and that indicate places in your code that you may want to improve.
Gathering and Analyzing Baseline Performance Data
Analyzing performance is a systematic process that starts with gathering baseline data. OS X provides several
applications that you can use to assess baseline performance for an OpenGL application:
● top is a command-line utility that you run in the Terminal window. You can use top to assess how much
CPU time your application consumes.
● OpenGL Profiler is an application that determines how much time an application spends in OpenGL. It
also provides function traces that you can use to look for redundant calls.
● OpenGL Driver Monitor lets you gather real-time data on the operation of the GPU and lets you look at
information (OpenGL extensions supported, buffer modes, sample modes, and so forth) for the available
renderers. For more information, see OpenGL Tools for Serious Graphics Development.
This section shows how to use top along with OpenGL Profiler to analyze where to spend your optimization
efforts—in your OpenGL code, your other application code, or in both. You'll see how to gather baseline data
and how to determine the relationship of OpenGL performance to overall application performance.
1. Launch your OpenGL application.
2. Open a Terminal window and place it side-by-side with your application window.
3. In the Terminal window, type top and press Return. You'll see output similar to that shown in Figure 15-1.
Tuning Your OpenGL Application
Gathering and Analyzing Baseline Performance Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
156The top program indicates the amount of CPU time that an application uses. The CPU time serves as a
good baseline value for gauging how much tuning your code needs. Figure 15-1 shows the percentage
of CPU time for the OpenGL application GLCarbon1C (highlighted). Note this application utilizes 31.5% of
CPU resources.
Figure 15-1 Output produced by the top application
Tuning Your OpenGL Application
Gathering and Analyzing Baseline Performance Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
1574. Open the OpenGL Profiler application, located in /Developer/Applications/Graphics Tools/. In
the window that appears, select the options to collect a trace and include backtraces, as shown in Figure
15-2.
Figure 15-2 The OpenGL Profiler window
5. Select the option “Attach to application”, then select your application from the Application list.
You may see small pauses or stutters in the application, particularly when OpenGL Profiler is collecting a
function trace. This is normal and does not significantly affect the performance statistics. The glitches are
due to the large amount of data that OpenGL Profiler is writing out.
6. Click Suspend to stop data collection.
7. Open the Statistics and Trace windows by choosing them from the Views menu.
Figure 15-3 provides an example of what the Statistics window looks like. Figure 15-4 (page 160) shows a
Trace window.
The estimated percentage of time spent in OpenGL is shown at the bottom of Figure 15-3. Note that for
this example, it is 28.91%. The higher this number, the more time the application is spending in OpenGL
and the more opportunity there may be to improve application performance by optimizing OpenGL code.
Tuning Your OpenGL Application
Gathering and Analyzing Baseline Performance Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
158You can use the amount of time spent in OpenGL along with the CPU time to calculate a ratio of the
application time versus OpenGL time. Thisratio indicates where to spend most of your optimization efforts.
Figure 15-3 A statistics window
8. In the Trace window, look for duplicate function calls and redundant or unnecessary state changes.
Look for back-to-back function calls with the same or similar data. These are areas that can typically be
optimized. Functions that are called more than necessary include glTexParameter, glPixelStore,
glEnable, and glDisable. For most applications, these functions can be called once from a setup or
state modification routine and called only when necessary.
It's generally good practice to keep state changes out of rendering loops(which can be seen in the function
trace as the same sequence of state changes and drawing over and over again) as much as possible and
use separate routines to adjust state as necessary.
Tuning Your OpenGL Application
Gathering and Analyzing Baseline Performance Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
159Look at the time value to the left of each function call to determine the cost of the call.
Figure 15-4 A Trace window
Use these to determine
the cost of a call
9. Determine what the performance gain would be if it were possible to reduce the time to execute all
OpenGL calls to zero.
For example, take the performance data from the GLCarbon1C application used in thissection to determine
the performance attributable to the OpenGL calls.
Total Application Time (from top) = 31.5%
Total Time in OpenGL (from OpenGL Profiler) = 28.91%
At first glance, you might think that optimizing the OpenGL code could improve application performance
by almost 29%, thusreducing the total application time by 29%. Thisisn't the case. Calculate the theoretical
performance increase by multiplying the total CPU time by the percentage of time spent in OpenGL. The
theoretical performance improvement for this example is:
31.5 X .2891 = 9.11%
If OpenGL took no time at all to execute, the application would see a 9.11% increase in performance. So,
if the application runs at 60 frames per second (FPS), it would perform as follows:
New FPS = previous FPS * (1 +(% performance increase)) = 60 fps *(1.0911) =
65.47 fps
The application gains almost 5.5 frames per second by reducing OpenGL from 28.91% to 0%. This shows
that the relationship of OpenGL performance to application performance is not linear. Simply reducing
the amount of time spent in OpenGL may or may not offer any noticeable benefit in application
performance.
Tuning Your OpenGL Application
Gathering and Analyzing Baseline Performance Data
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
160Using OpenGL Driver Monitor to Measure Stalls
You can use OpenGL Driver Monitor to measure how long the CPU waits for the GPU, as shown in Figure 15-5.
OpenGL Driver Monitor is useful for analyzing other parameters as well. You can choose which parameters to
monitor simply by clicking a parameter name from the drawer shown in the figure.
Figure 15-5 The graph view in OpenGL Driver Monitor
Identifying Bottlenecks with Shark
Shark is an extremely useful tool for identifying places in your code that are slow and could benefit from
optimization. Once you learn the basics, you can use it on your OpenGL applications to identify bottlenecks.
There are three issues to watch out for in Shark when using it to analyze OpenGL performance:
● Costly data conversions. If you notice the glgProcessPixels call (in the libGLImage.dylib library)
showing up in the analysis, it's an indication that the driver is not handling a texture upload optimally.
The call is used when your application makes a glTexImage or glTexSubImage call using data that is
in a nonnative format for the driver, which meansthe data must be converted before the driver can upload
it. You can improve performance by changing your data so that it is in a native format for the driver. See
“Use Optimal Data Types and Formats” (page 102).
Tuning Your OpenGL Application
Identifying Bottlenecks with Shark
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
161Note: If your data needs only to be swizzled, glgProcessPixels performs the swizzling
reasonably fast although not as fast as if the data didn't need swizzling. But non-native data
formats are converted one byte at a time and incurs a performance cost that is best to avoid.
● Time in the mach_kernel library. If you see time spent waiting for a timestamp or waiting for the driver,
it indicates that your application is waiting for the GPU to finish processing. You see this during a texture
upload, for example.
● Misleading symbols. You may see a symbol, such as glgGetString, that appears to be taking time but
shouldn't be taking time in your application. Thatsometimes happens because the underlying optimizations
performed by the system don't have any symbols attached to them on the driver side. Without a symbol
to display, Shark shows the last symbol. You need to look for the call that your application made prior to
that symbol and focus your attention there. You don't need to concern yourself with the calls that were
made "underneath" your call.
Tuning Your OpenGL Application
Identifying Bottlenecks with Shark
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
162OpenGL functionality changes with each version of the OpenGL API. This appendix describes the functionality
that was added with each version. See the official OpenGL specification for detailed information.
The functionality for each version is guaranteed to be available through the OpenGL API even if a particular
renderer does not support all of the extensions in a version. For example, a renderer that claims to support
OpenGL 1.3 might not export the GL_ARB_texture_env_combine or GL_EXT_texture_env_combine
extensions. It's important that you query both the renderer version and extension string to make sure that the
renderer supports any functionality that you want to use.
Note: It's possible for vendor and ARB extensions to provide similar functionality. As particular
functionality becomes widely adopted, it can be moved into the core OpenGL API. As a result,
functionality that you want to use could be included as an extension, as part of the core API, or both.
You should read the extensions and the core OpenGL specifications carefully to see the differences.
Furthermore, as an extension is promoted, the API associated with that functionality can change.
For more information,see “Determining the OpenGL Capabilities Supported by the Renderer” (page
83).
In the following tables, the extensions describe the feature that the core functionality is based on. The core
functionality might not be the same as the extension. For example, compare the core texture crossbar
functionality with the extension that it's based on.
Version 1.1
Table A-1 Functionality added in OpenGL 1.1
Functionality Extension
Copy texture and subtexture GL_EXT_copy_texture and GL_EXT_subtexture
Logical operation GL_EXT_blend_logic_op
Polygon offset GL_EXT_polygon_offset
Texture image formats GL_EXT_texture
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
163
Legacy OpenGL Functionality by VersionFunctionality Extension
Texture objects GL_EXT_texture_object
Texture proxies GL_EXT_texture
Texture replace environment GL_EXT_texture
Vertex array GL_EXT_vertex_array
There were a number of other minor changes outlined in Appendix C section 9 of the OpenGL specification.
See http://www.opengl.org.
Version 1.2
Table A-2 Functionality added in OpenGL 1.2
Functionality Extension
BGRA pixel formats GL_EXT_bgra
GL_SGI_color_table , GL_EXT_color_subtable,
GL_EXT_convolution,GL_HP_convolution_border_modes,
GL_SGI_color_matrix, GL_EXT_histogram,
GL_EXT_blend_minmax, and GL_EXT_blend_subtract
Imaging subset (optional)
Normal rescaling GL_EXT_rescale_normal
Packed pixel formats GL_EXT_packed_pixels
Separate specular color GL_EXT_separate_specular_color
Texture coordinate edge clamping GL_SGIS_texture_edge_clamp
Texture level of detail control GL_SGIS_texture_lod
Three-dimensional texturing GL_EXT_texture3D
Vertex array draw element range GL_EXT_draw_range_elements
Legacy OpenGL Functionality by Version
Version 1.2
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
164Note: The imaging subset might not be present on all implementations; you must verify by checking
for the ARB_imaging extension.
OpenGL 1.2.1 introduced ARB extensions with no specific core API changes.
Version 1.3
Table A-3 Functionality added in OpenGL 1.3
Functionality Extension
Compressed textures GL_ARB_texture_compression
Cube map textures GL_ARB_texture_cube_map
Multisample GL_ARB_multisample
Multitexture GL_ARB_multitexture
Texture add environment mode GL_ARB_texture_env_add
Texture border clamp GL_ARB_texture_border_clamp
Texture combine environment mode GL_ARB_texture_env_combine
Texture dot3 environment mode GL_ARB_texture_env_dot3
Transpose matrix GL_ARB_transpose_matrix
Version 1.4
Table A-4 Functionality added in OpenGL 1.4
Functionality Extension
Automatic mipmap generation GL_SGIS_generate_mipmap
Blend function separate GL_ARB_blend_func_separate
Blend squaring GL_NV_blend_square
Depth textures GL_ARB_depth_texture
Legacy OpenGL Functionality by Version
Version 1.3
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
165Functionality Extension
Fog coordinate GL_EXT_fog_coord
Multiple draw arrays GL_EXT_multi_draw_arrays
Point parameters GL_ARB_point_parameters
Secondary color GL_EXT_secondary_color
Separate blend functions GL_EXT_blend_func_separate, GL_EXT_blend_color
Shadows GL_ARB_shadow
Stencil wrap GL_EXT_stencil_wrap
Texture crossbar environment mode GL_ARB_texture_env_crossbar
Texture level of detail bias GL_EXT_texture_lod_bias
Texture mirrored repeat GL_ARB_texture_mirrored_repeat
Window raster position GL_ARB_window_pos
Version 1.5
Table A-5 Functionality added in OpenGL 1.5
Functionality Extension
Buffer objects GL_ARB_vertex_buffer_object
Occlusion queries GL_ARB_occlusion_query
Shadow functions GL_EXT_shadow_funcs
Version 2.0
Table A-6 Functionality added in OpenGL 2.0
Functionality Extension
Multiple render targets GL_ARB_draw_buffers
Legacy OpenGL Functionality by Version
Version 1.5
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
166Functionality Extension
Non–power-of-two textures GL_ARB_texture_non_power_of_two
Point sprites GL_ARB_point_sprite
Separate blend equation GL_EXT_blend_equation_separate
GL_ATI_separate_stencil
GL_EXT_stencil_two_side
Separate stencil
Shading language GL_ARB_shading_language_100
Shader objects GL_ARB_shader_objects
GL_ARB_fragment_shader
GL_ARB_vertex_shader
Shader programs
Version 2.1
Table A-7 Functionality added in OpenGL 2.1
Functionality Extension
Pixel buffer objects GL_ARB_pixel_buffer_object
sRGB textures GL_EXT_texture_sRGB
Legacy OpenGL Functionality by Version
Version 2.1
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
167The OpenGL 3.0 specification deprecated many areas of functionality defined in earlier versions of the OpenGL
specification. The OpenGL 3.2 Core profile explicitly removesthese deprecated features and adjusts other parts
of the specification to provide a streamlined, clean programming interface to OpenGL. Use this chapter to
assist you in migrating your application away from this deprecated functionality.
Removed Functionality
The features that were removed from OpenGL are described in in Appendix E of the OpenGL 3.2 Core
specification, and you should use that as the definitive guide for the changes you need to make in your
application. Here is a summary of most significant areas that changed:
●
If your application uses the fixed-function pipeline, it must be rewritten to use shaders instead.
●
If your application uses shaders, you must rewrite your shaders to use OpenGL Shading Language 1.5;
many built-in shader variables provided in earlier versions of the OpenGL Shading Language were explicitly
removed from the OpenGL Shading Language 1.5 specification. Similarly, your application may no longer
provide vertex data using the fixed-function routines; all vertex attributes are now specified as generic
vertex attributes.
● Your application must explicitly generate object names using the OpenGL API.
● Vertex data must be provided to OpenGL using buffer objects.
● The built-in matrix stack functionality from earlier versions of OpenGL has been removed; you must recreate
this functionality using shader inputs.
● Support for auxiliary and accumulation buffers has been removed; use framebuffer objects instead.
● Your application no longer fetches the list of extensions as a single string. Instead, you first fetch the
number of extensions and then separately fetch each extension string.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
168
Updating an Application to Support the OpenGL
3.2 Core SpecificationExtension Changes on OS X
OpenGL 3.2 providesfunctionality that earlier versions ofOpenGL provided through extensions.Other extensions
that were previously supported on OS X are no longer supported when your application uses the OpenGL 3.2
Core profile. Table B-1 lists extensions described elsewhere in this guide; use this table to determine whether
the extension is supported, and if not, what equivalent functionality is supported.
Table B-1 Extensions described in this guide
Extension Status
Obsolete. Use the ARB_Sync functionality provided by OpenGL 3.2
(Core).
APPLE_fence
ARB_vertex_buffer_object Functionality provided by OpenGL 3.2 (Core).
Obsolete. Use the ARB_vertex_array_object functionality provided
by OpenGL 3.2 (Core).
APPLE_vertex_array_object
Obsolete. Use the ARB_map_buffer_range functionality provided by
OpenGL 3.2 (Core).
APPLE_vertex_array_range
Obsolete. Use the ARB_map_buffer_range functionality provided by
OpenGL 3.2 (Core).
APPLE_flush_buffer_range
APPLE_client_storage Supported.
APPLE_texture_range Supported.
ARB_texture_rectangle Functionality provided by OpenGL 3.2 (Core).
ARB_shader_objects Functionality provided by OpenGL 3.2 (Core).
ARB_vertex_shader Functionality provided by OpenGL 3.2 (Core).
ARB_fragment_shader Functionality provided by OpenGL 3.2 (Core).
EXT_transform_feedback Functionality provided by OpenGL 3.2 (Core).
EXT_gpu_shader4 Obsolete. Functionality included in GLSL 1.5
EXT_geometry_shader4 Functionality provided by OpenGL 3.2 (Core).
Obsolete. Use the ARB_uniform_buffer_object functionality
provided by OpenGL 3.2 (Core).
EXT_bindable_uniform
ARB_pixel_buffer_object Functionality provided by OpenGL 3.2 (Core).
Updating an Application to Support the OpenGL 3.2 Core Specification
Extension Changes on OS X
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
169Extension Status
Obsolete. Use the ARB_framebuffer_object functionality provided
by OpenGL 3.2 (Core).
EXT_framebuffer_object
APPLE_pixel_buffer Obsolete. Use framebuffer objects instead.
Obsolete. Use multisampled renderbuffers to precisely control
multisampling.
NV_multisample_filter_hint
Updating an Application to Support the OpenGL 3.2 Core Specification
Extension Changes on OS X
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
170Function pointers to OpenGL routines allow you to deploy your application across multiple versions of OS X
regardless of whether the entry point is supported at link time or runtime. This practice also provides support
for code that needs to run cross-platform—in both OS X and Windows.
Note: If you are deploying your application only in OS X v10.4 or later, you do not need to read this
chapter. Instead, consider the alternative, which is to set the gcc attribute that allows weak linking
of symbols. Keep in mind, however, that weak linking may impact your application's performance.
For more information, see “Frameworks and Weak Linking”.
This appendix discusses the tasks needed to set up and use function pointers as entry points to OpenGL
routines:
●
“Obtaining a Function Pointer to an Arbitrary OpenGL Entry Point” (page 171)shows how to write a generic
routine that you can reuse for any OpenGL application on the Macintosh platform.
●
“Initializing Entry Points” (page 172) describes how to declare function pointer type definitions and initialize
them with the appropriate OpenGL command entry points for your application.
Obtaining a Function Pointer to an Arbitrary OpenGL Entry Point
Getting a pointer to an OpenGL entry point function is fairly straightforward from Cocoa. You can use the
Dynamic Loader function NSLookupAndBindSymbol to get the address of an OpenGL entry point.
Keep in mind that getting a valid function pointer means that the entry point is exported by the OpenGL
framework; it does not guarantee that a particular routine is supported and valid to call from within your
application. You still need to check for OpenGL functionality on a per-renderer basis as described in “Detecting
Functionality” (page 83).
Listing C-1 shows how to use NSLookupAndBindSymbol from within the function MyNSGLGetProcAddress.
When provided a symbol name, this application-defined function returns the appropriate function pointer
from the global symbol table. A detailed explanation for each numbered line of code appears following the
listing.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
171
Setting Up Function Pointers to OpenGL RoutinesListing C-1 Using NSLookupAndBindSymbol to obtain a symbol for a symbol name
#import
#import
#import
void * MyNSGLGetProcAddress (const char *name)
{
NSSymbol symbol;
char *symbolName;
symbolName = malloc (strlen (name) + 2); // 1
strcpy(symbolName + 1, name); // 2
symbolName[0] = '_'; // 3
symbol = NULL;
if (NSIsSymbolNameDefined (symbolName)) // 4
symbol = NSLookupAndBindSymbol (symbolName);
free (symbolName); // 5
return symbol ? NSAddressOfSymbol (symbol) : NULL; // 6
}
Here's what the code does:
1. Allocates storage for the symbol name plus an underscore character ('_'). The underscore character is
part of the UNIX C symbol-mangling convention, so make sure that you provide storage for it.
2. Copiesthe symbol name into the string variable,starting at the second character, to leave room for prefixing
the underscore character.
3. Copies the underscore character into the first character of the symbol name string.
4. Checks to make sure that the symbol name is defined, and if it is, looks up the symbol.
5. Frees the symbol name string because it is no longer needed.
6. Returns the appropriate pointer if successful, or NULL if not successful. Before using this pointer, you
should make sure that is it valid.
Initializing Entry Points
Listing C-2 shows how to use the MyNSGLGetProcAddress function from Listing C-1 (page 172) to obtain a
few OpenGL entry points. A detailed explanation for each numbered line of code appears following the listing.
Setting Up Function Pointers to OpenGL Routines
Initializing Entry Points
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
172Listing C-2 Using NSGLGetProcAddress to obtain an OpenGL entry point
#import "MyNSGLGetProcAddress.h" // 1
static void InitEntryPoints (void);
static void DeallocEntryPoints (void);
// Function pointer type definitions
typedef void (*glBlendColorProcPtr)(GLclampf red,GLclampf green,
GLclampf blue,GLclampf alpha);
typedef void (*glBlendEquationProcPtr)(GLenum mode);
typedef void (*glDrawRangeElementsProcPtr)(GLenum mode, GLuint start,
GLuint end,GLsizei count,GLenum type,const GLvoid *indices);
glBlendColorProcPtr pfglBlendColor = NULL; // 2
glBlendEquationProcPtr pfglBlendEquation = NULL;
glDrawRangeElementsProcPtr pfglDrawRangeElements = NULL;
static void InitEntryPoints (void) // 3
{
pfglBlendColor = (glBlendColorProcPtr) MyNSGLGetProcAddress
("glBlendColor");
pfglBlendEquation = (glBlendEquationProcPtr)MyNSGLGetProcAddress
("glBlendEquation");
pfglDrawRangeElements = (glDrawRangeElementsProcPtr)MyNSGLGetProcAddress
("glDrawRangeElements");
}
// -------------------------
static void DeallocEntryPoints (void) // 4
{
pfglBlendColor = NULL;
pfglBlendEquation = NULL;
pfglDrawRangeElements = NULL;;
}
Here's what the code does:
1. Imports the header file that contains the MyNSGLProcAddress function from Listing C-1 (page 172).
Setting Up Function Pointers to OpenGL Routines
Initializing Entry Points
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
1732. Declares function pointers for the functions of interest. Note that each function pointer uses the prefix pf
to distinguish it from the function it points to. Although using this prefix is not a requirement, it's best to
avoid using the exact function names.
3. Initializes the entry points. This function repeatedly calls the MyNSGLProcAddress function to obtain
function pointers for each of the functions of interest—glBlendColor, glBlendEquation, and
glDrawRangeElements.
4. Sets each of the function pointers to NULL when they are no longer needed.
Setting Up Function Pointers to OpenGL Routines
Initializing Entry Points
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
174This table describes the changes to OpenGL Programming Guide for Mac .
Date Notes
2012-07-23 Updated with information on supporting high-resolution displays.
2011-06-06 Added new context options.
2010-11-15 Fixed a few small errors in the texture chapter.
Updated the recommendations on when to use each texture uploading
and downloading technique.
Updated the code for creating a texture from a view’s contents to use
newer, better supported techniques.
2010-06-14 Corrected texture creation code snippets.
2010-03-24 Minor updates and clarifications.
Substantial revisions to describe behaviors for OpenGL on OS X v10.5 and
OS X v10.6. Removed information on obsolete and deprecated behaviors.
2010-02-24
Corrected errors in code listings. Pixel format attribute lists should be
terminated with 0, not NULL. One call to glTexImage2D had an incorrect
number of parameters.
2009-08-28
Updated the Cocoa OpenGL tutorial and made numerous other minor
changes.
2008-06-09
Fixed compilation errors in Listing 8-1 (page 84).
Added “Getting Decompressed Raw Pixel Data from a Source Image” (page
135).
Updated links to OpenGL extensions.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
175
Document Revision HistoryDate Notes
Made several minor edits.
2007-12-04 Corrected minor typographical and technical errors.
Added “Ensuring That Back Buffer Contents Remain the Same” (page 66).
Revised “Deprecated Attributes” (page 70).
2007-08-07 Fixed several technical issues.
2007-05-29 Fixed a broken link.
2007-05-17 Fixed a few technical inaccuracies in the code listings.
Changed attribs to attributes in Listing 6-2 (page 68).
Fixed drawRect method implementation in “Drawing to a Window or
View” (page 35).
2006-12-20 Fixed minor errors.
Added information concerning the Apple client storage extension. Fixed
a typographical error.
2006-11-07 Added information about performance issues and processor queries.
See “Determining Whether Vertex and Fragment Processing Happens on
the GPU” (page 78).
2006-10-03 Added a section on checking for GPU processing.
Added “Determining Whether Vertex and Fragment Processing Happens
on the GPU” (page 78).
Fixed a number of minor typos in the code and in the text.
2006-09-05 Fixed minor technical problems.
2006-07-24 Made minor technical and typograhical changes throughout.
Added information to “Surface Drawing Order Specifies the Position of
the OpenGL Surface Relative to the Window” (page 77).
Document Revision History
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
176Date Notes
Changed glCopyTexSubImage to glCopyTexSubImage2D in
“Downloading Texture Data” (page 136).
Made minor improvements to Listing 11-6 (page 136).
Removed information about 1-D textures.
2006-06-28 Made several minor technical corrections.
Redirected links to the OpenGL specification for the framebuffer object
extension so that they point to the SGI Open Source website, which hosts
the most up-to-date version of this specification.
Removed the logic operation blending entry from Table A-6 (page 166)
because this functionality is not available in OpenGL 2.0.
2006-05-23 First version.
This document replaces Macintosh OpenGL Programming Guide and AGL
Programming Guide .
This document incorporates information from the following Technical
Notes:
TN2007 “The CGDirectDisplay API”
TN2014 “Insights on OpenGL”
TN2080 “Understanding and Detecting OpenGL Functionality”
TN2093 “OpenGL Performance Optimization: The Basics”
This document incorporates information from the following Technical
Q&As:
Technical Q&A OGL01 “aglChoosePixelFormat, The Inside Scoop”
Technical Q&A OGL02 “Correct Setup of an AGLDrawable”
Technical Q&A QA1158 “glFlush() vs. glFinish()”
Technical Q&A QA1167 “Using Interface Builder's NSOpenGLView or
Custom View objects for an OpenGL application”
Technical Q&A QA1188 “GetProcAdress and OpenGL Entry Points”
Document Revision History
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
177Date Notes
Technical Q&A QA1209 “Updating OpenGL Contexts”
Technical Q&A QA1248 “Context Sharing Tips”
Technical Q&A QA1268 “Sharpening Full Scene Anti-Aliasing Details”
Technical Q&A QA1269 “OS X OpenGL Interfaces”
Technical Q&A QA1325 “Creating an OpenGL texture from an NSView”
Document Revision History
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
178This glossary containstermsthat are used specifically
for the Apple implementation of OpenGL and a few
terms that are common in graphics programming.
For definitions of additional OpenGL terms, see
OpenGL Programming Guide, by the Khronos
OpenGL Working Group
aliased Said of graphics whose edges appear
jagged; can be remedied by performing antialiasing
operations.
antialiasing In graphics, a technique used to
smooth and soften the jagged (or aliased) edges
that are sometimes apparent when graphical objects
such as text, line art, and images are drawn.
ARB The Khronos OpenGL Working Group, which
is the group that oversees the OpenGL specification
and extensions to it.
attach To establish a connection between two
existing objects. Compare bind.
bind To create a new object and then establish a
connection between that object and a rendering
context. Compare attach.
bitmap A rectangular array of bits.
bitplane A rectangular array of pixels.
buffer A block of memory dedicated to storing a
specific kind of data, such as depth values, green
color values, stencil index values, and color index
values.
CGL (Core OpenGL) framework The Apple
framework for using OpenGL graphics in OS X
applications that need low-level access to OpenGL.
clipping An operation that identifies the area of
drawing. Anything not in the clipping region is not
drawn.
clip coordinates The coordinate system used for
view-volume clipping. Clip coordinates are applied
after applying the projection matrix and prior to
perspective division.
color lookup table A table of values used to map
color indexes into actual color values.
completeness A state that indicates whether a
framebuffer object meets all the requirements for
drawing.
context A set of OpenGL state variables that affect
how drawing is performed for a drawable object
attached to that context. Also called a rendering
context.
culling Eliminating parts of a scene that can't be
seen by the observer.
current context The rendering context to which
OpenGL routes commands issued by your
application.
current matrix A matrix used by OpenGL to
transform coordinates in one system to those of
another system, such as the modelview matrix, the
perspective matrix, and the texture matrix. GL
shading language allows user-defined matrices.
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
179
Glossarydepth In OpenGL, refers to the z coordinate and
specifies how far a pixel lies from the observer.
depth buffer A block of memory used to store a
depth value for each pixel. The depth buffer is used
to determine whether or not a pixel can be seen by
the observer. Those that are hidden are typically
removed.
display list A list of OpenGL commands that have
an associated name and that are uploaded to the
GPU, preprocessed, and then executed at a later
time. Display lists are often used for
computing-intensive commands.
double buffering The practice of using a front and
back color buffer to achieve smooth animation. The
back buffer is not displayed, but swapped with the
front buffer.
drawable object In OS X, an object allocated
outside of OpenGL that can serve as an OpenGL
framebuffer. A drawable object can be any of the
following: a window, a view, a pixel buffer, offscreen
memory, or a full-screen graphics device. See also
framebuffer object
extension A feature of OpenGL that's not part of
the OpenGL core API and therefore not guaranteed
to be supported by every implementation of
OpenGL. The naming conventions used for
extensions indicate how widely accepted the
extension is. The name of an extension supported
only by a specific company includes an abbreviation
of the company name. If more then one company
adoptsthe extension,the extension name is changed
to include EXT instead of a company abbreviation.
If the Khronos OpenGL Working Group approves an
extension, the extension name changes to include
ARB instead of EXT or a company abbreviation.
eye coordinates The coordinate system with the
observer at the origin. Eye coordinates are produced
by the modelview matrix and passed to the
projection matrix.
fence A token used by the GL_APPLE_fence
extension to determine whether a given command
has completed or not.
filtering A process that modifies an image by
combining pixels or texels.
fog An effect achieved by fading colors to a
background color based on the distance from the
observer. Fog provides depth cues to the observer.
fragment The color and depth values for a single
pixel; can also include texture coordinate values. A
fragment is the result of rasterizing primitives.
framebuffer The collection of buffers associated
with a window or a rendering context.
framebuffer attachable image The rendering
destination for a framebuffer object.
framebuffer object An OpenGL extension that
allows rendering to a destination other than the
usual OpenGL buffers or destinations provided by
the windowing system. A framebuffer object (FBO)
contains state information for the OpenGL
framebuffer and its set of images. A framebuffer
object is similar to a drawable object, except that a
drawable object is a window-system specific object
whereas a framebuffer object is a window-agnostic
object. The context that's bound to a framebuffer
object can be bound to a window-system-provided
drawable object for the purpose of displaying the
content associated with the framebuffer object.
frustum The region of space that is seen by the
observer and that is warped by perspective division.
Glossary
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
180FSAA (full scene antialiasing) A technique that
takes multiple samples at a pixel and combinesthem
with coverage values to arrive at a final fragment.
gamma correction A function that changes color
intensity valuesto correct for the nonlinear response
of the eye or of a display.
GLU Graphics library utilities.
GL Graphics library.
GLUT Graphics Library Utilities Toolkit, which is
independent of the window system. In OS X, GLUT
is implemented on top of Cocoa.
GLX An OpenGL extension that supports using
OpenGL within a window provided by the X Window
system.
image A rectangular array of pixels.
immediatemode The practice ofOpenGL executing
commands at the time an application issues them.
To prevent commands from being issued
immediately, an application can use a display list.
interleaved data Arrays of dissimilar data that are
grouped together, such as vertex data and texture
coordinates. Interleaving can speed data retrieval.
mipmaps A set of texture maps, provided at various
resolutions, whose purpose is to minimize artifacts
that can occur when a texture is applied to a
geometric primitive whose onscreen resolution
doesn't match the source texture map. Mipmapping
derivesfromthe latin phrasemultumin parvo , which
means "many things in a small place."
modelview matrix A 4 X 4 matrix used by OpenGL
to transforms points, lines, polygons, and positions
from object coordinates to eye coordinates.
mutex A mutual exclusion object in a multithreaded
application.
NURBS (nonuniform rational basis spline) A
methodology use to specify parametric curves and
surfaces.
packing Converting pixel color components from
a buffer into the format needed by an application.
pbuffer See pixel buffer.
pixel A picture element; the smallest element that
the graphics hardware can display on the screen. A
pixel is made up of all the bits at the location x , y ,
in all the bitplanes in the framebuffer.
pixel buffer A type of drawable object that allows
the use of offscreen buffers as sources for OpenGL
texturing. Pixel buffers allow hardware-accelerated
rendering to a texture.
pixel depth The number of bits per pixel in a pixel
image.
pixel format A format used to store pixel data in
memory. The format describesthe pixel components
(that is, red, blue, green, alpha), the number and
order of components, and other relevant
information,such as whether a pixel containsstencil
and depth values.
primitives The simplest elements in
OpenGL—points, lines, polygons, bitmaps, and
images.
projection matrix A matrix that OpenGL uses to
transform points, lines, polygons, and positionsfrom
eye coordinates to clip coordinates.
rasterization The process of converting vertex and
pixel data to fragments, each of which corresponds
to a pixel in the framebuffer.
renderbuffer A rendering destination for a 2D pixel
image, used for generalized offscreen rendering, as
defined in the OpenGL specification for the
GL_EXT_framebuffer_object extension.
Glossary
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
181renderer A combination of hardware and software
that OpenGL uses to create an image from a view
and a model. The hardware portion of a renderer is
associated with a particular display device and
supports specific capabilities, such as the ability to
support a certain color depth or buffering mode. A
renderer that uses only software is called a software
renderer and is typically used as a fallback.
rendering context A container forstate information.
rendering pipeline The order of operations used
by OpenGL to transform pixel and vertex data to an
image in the framebuffer.
render-to-texture An operation that draws content
directly to a texture target.
RGBA Red, green, blue, and alpha color
components.
shader A programthat computessurface properties.
shading language A high-level language, accessible
in C, used to produce advanced imaging effects.
stencil buffer Memory used specifically for stencil
testing. A stencil test is typically used to identify
masking regions, to identify solid geometry that
needs to be capped, and to overlap translucent
polygons.
surface The internal representation of a single
buffer that OpenGL actually drawsto and readsfrom.
For windowed drawable objects, thissurface is what
the OS X window server uses to composite OpenGL
content on the desktop.
tearing A visual anomaly caused when part of the
current frame overwrites previous frame data in the
framebuffer before the current frame is fully
rendered on the screen.
tessellation An operation that reduces a surface to
a mesh of polygons, or a curve to a sequence of lines.
texel A texture element used to specify the color
to apply to a fragment.
texture Image data used to modify the color of
rasterized fragments; can be one-, two-, or threedimensional or be a cube map.
texture mapping The process of applying a texture
to a primitive.
texture matrix A 4 x 4 matrix that OpenGL uses to
transform texture coordinates to the coordinates
that are used for interpolation and texture lookup.
texture object An opaque data structure used to
store all data related to a texture. A texture object
can include such things as an image, a mipmap, and
texture parameters (width, height, internal format,
resolution, wrapping modes, and so forth).
vertex A three-dimensional point. A set of vertices
specify the geometry of a shape. Vertices can have
a number of additional attributes such as color and
texture coordinates. See vertex array.
vertex array A data structure that stores a block of
data thatspecifiessuch things as vertex coordinates,
texture coordinates, surface normals, RGBA colors,
color indices, and edge flags.
virtual screen A combination of hardware, renderer,
and pixel format that OpenGL selects as suitable for
an imaging task. When the current virtual screen
changes, the current renderer typically changes.
Glossary
2012-07-23 | © 2004, 2012 Apple Inc. All Rights Reserved.
182Apple Inc.
© 2004, 2012 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Carbon, Cocoa, iChat,
Instruments, iPhoto, Logic, Mac, Macintosh,
Objective-C, OS X, Pages, Quartz, and Xcode are
trademarks of Apple Inc., registered in the U.S.
and other countries.
OpenCL is a trademark of Apple Inc.
DEC is a trademark of Digital Equipment
Corporation.
OpenGL is a registered trademark of Silicon
Graphics, Inc.
UNIX is a registered trademark of The Open
Group.
X Window System is a trademark of the
Massachusetts Institute of Technology.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
View Programming
Guide for iOSContents
About Windows and Views 7
At a Glance 7
Views Manage Your Application’s Visual Content 7
Windows Coordinate the Display of Your Views 8
Animations Provide the User with Visible Feedback for Interface Changes 8
The Role of Interface Builder 8
See Also 9
View and Window Architecture 10
View Architecture Fundamentals 10
View Hierarchies and Subview Management 11
The View Drawing Cycle 12
Content Modes 13
Stretchable Views 15
Built-In Animation Support 16
View Geometry and Coordinate Systems 17
The Relationship of the Frame, Bounds, and Center Properties 18
Coordinate System Transformations 20
Points Versus Pixels 21
The Runtime Interaction Model for Views 23
Tips for Using Views Effectively 25
Views Do Not Always Have a Corresponding View Controller 25
Minimize Custom Drawing 26
Take Advantage of Content Modes 26
Declare Views as Opaque Whenever Possible 26
Adjust Your View’s Drawing Behavior When Scrolling 26
Do Not Customize Controls by Embedding Subviews 27
Windows 28
Tasks That Involve Windows 28
Creating and Configuring a Window 29
Creating Windows in Interface Builder 29
Creating a Window Programmatically 30
Adding Content to Your Window 30
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
2Changing the Window Level 31
Monitoring Window Changes 31
Displaying Content on an External Display 32
Handling Screen Connection and Disconnection Notifications 33
Configuring a Window for an External Display 35
Configuring the Screen Mode of an External Display 37
Views 38
Creating and Configuring View Objects 38
Creating View Objects Using Interface Builder 39
Creating View Objects Programmatically 39
Setting the Properties of a View 40
Tagging Views for Future Identification 42
Creating and Managing a View Hierarchy 42
Adding and Removing Subviews 43
Hiding Views 46
Locating Views in a View Hierarchy 47
Translating, Scaling, and Rotating Views 47
Converting Coordinates in the View Hierarchy 50
Adjusting the Size and Position of Views at Runtime 51
Being Prepared for Layout Changes 51
Handling Layout Changes Automatically Using Autoresizing Rules 52
Tweaking the Layout of Your Views Manually 54
Modifying Views at Runtime 54
Interacting with Core Animation Layers 56
Changing the Layer Class Associated with a View 56
Embedding Layer Objects in a View 57
Defining a Custom View 58
Checklist for Implementing a Custom View 58
Initializing Your Custom View 59
Implementing Your Drawing Code 60
Responding to Events 62
Cleaning Up After Your View 63
Animations 64
What Can Be Animated? 64
Animating Property Changes in a View 66
Starting Animations Using the Block-Based Methods 66
Starting Animations Using the Begin/Commit Methods 68
Nesting Animation Blocks 72
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
3
ContentsImplementing Animations That Reverse Themselves 73
Creating Animated Transitions Between Views 73
Changing the Subviews of a View 74
Replacing a View with a Different View 76
Linking Multiple Animations Together 77
Animating View and Layer Changes Together 77
Document Revision History 80
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
4
ContentsFigures, Tables, and Listings
View and Window Architecture 10
Figure 1-1 Architecture of the views in a sample application 11
Figure 1-2 Content mode comparisons 14
Figure 1-3 Stretching the background of a button 15
Figure 1-4 Coordinate system orientation in UIKit 17
Figure 1-5 Relationship between a view's frame and bounds 19
Figure 1-6 Rotating a view and its content 21
Figure 1-7 UIKit interactions with your view objects 23
Table 1-1 Screen dimensions for iOS-based devices 22
Windows 28
Listing 2-1 Registering for screen connect and disconnect notifications 33
Listing 2-2 Handling connect and disconnect notifications 34
Listing 2-3 Configuring a window for an external display 35
Views 38
Figure 3-1 Layered views in the Clock application 43
Figure 3-2 Rotating a view 45 degrees 49
Figure 3-3 Converting values in a rotated view 51
Figure 3-4 View autoresizing mask constants 53
Table 3-1 Usage of some key view properties 40
Table 3-2 Autoresizing mask constants 52
Listing 3-1 Adding a view to a window 44
Listing 3-2 Adding views to an existing view hierarchy 45
Listing 3-3 Adding a custom layer to a view 57
Listing 3-4 Initializing a view subclass 59
Listing 3-5 A drawing method 61
Listing 3-6 Implementing the dealloc method 63
Animations 64
Table 4-1 Animatable UIView properties 64
Table 4-2 Methods for configuring animation blocks 69
Listing 4-1 Performing a simple block-based animation 66
Listing 4-2 Creating an animation block with custom options 67
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
5Listing 4-3 Performing a simple begin/commit animation 69
Listing 4-4 Configuring animation parameters using the begin/commit methods 70
Listing 4-5 Nesting animations that have different configurations 72
Listing 4-6 Swapping an empty text view for an existing one 74
Listing 4-7 Changing subviews using the begin/commit methods 75
Listing 4-8 Toggling between two views in a view controller 76
Listing 4-9 Mixing view and layer animations 78
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
6
Figures, Tables, and ListingsIn iOS, you use windows and views to present your application’s content on the screen. Windows do not have
any visible content themselves but provide a basic container for your application’s views. Views define a portion
of a window that you want to fill with some content. For example, you might have views that display images,
text, shapes, or some combination thereof. You can also use views to organize and manage other views.
At a Glance
Every application has at least one window and one view for presenting its content. UIKit and other system
frameworks provide predefined viewsthat you can use to present your content. These viewsrange from simple
buttons and text labels to more complex views such as table views, picker views, and scroll views. In places
where the predefined views do not provide what you need, you can also define custom views and manage
the drawing and event handling yourself.
Views Manage Your Application’s Visual Content
A view is an instance of the UIView class (or one of its subclasses) and manages a rectangular area in your
application window. Views are responsible for drawing content, handling multitouch events, and managing
the layout of any subviews. Drawing involves using graphics technologies such as Core Graphics, OpenGL ES,
or UIKit to draw shapes, images, and text inside a view’s rectangular area. A view responds to touch events in
its rectangular area either by using gesture recognizers or by handling touch events directly. In the view
hierarchy, parent views are responsible for positioning and sizing their child views and can do so dynamically.
This ability to modify child views dynamically lets your views adjust to changing conditions, such as interface
rotations and animations.
You can think of views as building blocks that you use to construct your user interface. Rather than use one
view to present all of your content, you often use several views to build a view hierarchy. Each view in the
hierarchy presents a particular portion of your user interface and is generally optimized for a specific type of
content. For example, UIKit has views specifically for presenting images, text and other types of content.
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
7
About Windows and ViewsRelevant Chapters: “View and Window Architecture” (page 10)
“Views” (page 38)
Windows Coordinate the Display of Your Views
A window is an instance of the UIWindow class and handles the overall presentation of your application’s user
interface. Windows work with views (and their owning view controllers) to manage interactions with, and
changes to, the visible view hierarchy. For the most part, your application’s window never changes. After the
window is created, it stays the same and only the views displayed by it change. Every application has at least
one window that displays the application’s user interface on a device’s main screen. If an external display is
connected to the device, applications can create a second window to present content on that screen as well.
Relevant Chapters: “Windows” (page 28)
Animations Provide the User with Visible Feedback for Interface Changes
Animations provide users with visible feedback about changes to your view hierarchy. The system defines
standard animationsfor presenting modal views and transitioning between different groups of views. However,
many attributes of a view can also be animated directly. For example, through animation you can change the
transparency of a view, its position on the screen, its size, its background color, or other attributes. And if you
work directly with the view’s underlying Core Animation layer object, you can perform many other animations
as well.
Relevant Chapters: “Animations” (page 64)
The Role of Interface Builder
Interface Builder is an application that you use to graphically construct and configure your application’s windows
and views. Using Interface Builder, you assemble your views and place them in a nib file, which is a resource
file that stores a freeze-dried version of your views and other objects. When you load a nib file at runtime, the
objects inside it are reconstituted into actual objects that your code can then manipulate programmatically.
Interface Builder greatly simplifiesthe work you have to do in creating your application’s user interface. Because
support for Interface Builder and nib files is incorporated throughout iOS, little effort is required to incorporate
nib files into your application’s design.
About Windows and Views
The Role of Interface Builder
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
8For more information about how to use Interface Builder, see Interface Builder User Guide . For information
about how view controllers manage the nib files containing their views, see “Custom View Controllers” in View
Controller Programming Guide for iOS .
See Also
Because views are very sophisticated and flexible objects, it would be impossible to cover all of their behaviors
in one document. However, other documents are available to help you learn about other aspects of managing
views and your user interface as a whole.
● View controllers are an important part of managing your application’s views. A view controller presides
over all of the viewsin a single view hierarchy and facilitatesthe presentation of those views on the screen.
For more information about view controllers and the role they play, see View Controller Programming
Guide for iOS .
● Views are the key recipients of gesture and touch events in your application. For more information about
using gesture recognizers and handling touch events directly, see Event Handling Guide for iOS .
● Custom views must use the available drawing technologies to render their content. For information about
using these technologies to draw within your views, see Drawing and Printing Guide for iOS .
●
In places where the standard view animations are notsufficient, you can use Core Animation. For information
about implementing animations using Core Animation, see Core Animation Programming Guide .
About Windows and Views
See Also
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
9Views and windows present your application’s user interface and handle the interactions with that interface.
UIKit and other system frameworks provide a number of views that you can use as-is with little or no
modification. You can also define custom views for places where you need to present content differently than
the standard views allow.
Whether you use the system views or create your own custom views, you need to understand the infrastructure
provided by the UIView and UIWindow classes. These classes provide sophisticated facilities for managing
the layout and presentation of views. Understanding how those facilities work is important for making sure
your views behave appropriately when changes occur in your application.
View Architecture Fundamentals
Most of the things you might want to do visually are done with view objects—instances of the UIView class.
A view object defines a rectangular region on the screen and handles the drawing and touch events in that
region. A view can also act as a parent for other views and coordinate the placement and sizing of those views.
The UIView class does most of the work in managing these relationships between views, but you can also
customize the default behavior as needed.
Views work in conjunction with Core Animation layers to handle the rendering and animating of a view’s
content. Every view in UIKit is backed by a layer object (usually an instance of the CALayer class), which
manages the backing store for the view and handles view-related animations. Most operations you perform
should be through the UIView interface. However, in situations where you need more control over the rendering
or animation behavior of your view, you can perform operations through its layer instead.
To understand the relationship between views and layers, it helps to look at an example. Figure 1-1 shows the
view architecture from the ViewTransitions sample application along with the relationship to the underlying
Core Animation layers. The views in the application include a window (which is also a view), a generic UIView
object that acts as a container view, an image view, a toolbar for displaying controls, and a bar button item
(which is not a view itself but which manages a view internally). (The actual ViewTransitions sample application
includes an additional image view that is used to implement transitions. For simplicity, and because that view
is usually hidden, it is not included in Figure 1-1.) Every view has a corresponding layer object that can be
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
10
View and Window Architectureaccessed from that view’s layer property. (Because a bar button item is not a view, you cannot access its layer
directly.) Behind those layer objects are Core Animation rendering objects and ultimately the hardware buffers
used to manage the actual bits on the screen.
Figure 1-1 Architecture of the views in a sample application
UIKit views Core Animation layers
UIImageView
UIView
UIWindow
UIToolbar UIBarButtonItem
(internal view)
The use of Core Animation layer objects has important implications for performance. The actual drawing code
of a view object is called as little as possible, and when the code is called, the results are cached by Core
Animation and reused as much as possible later. Reusing already-rendered content eliminates the expensive
drawing cycle usually needed to update views. Reuse of this content is especially important during animations,
where the existing content can be manipulated. Such reuse is much less expensive than creating new content.
View Hierarchies and Subview Management
In addition to providing its own content, a view can act as a container for other views. When one view contains
another, a parent-child relationship is created between the two views. The child view in the relationship is
known asthe subview and the parent view is known asthe superview. The creation of thistype of relationship
has implications for both the visual appearance of your application and the application’s behavior.
Visually, the content of a subview obscures all or part of the content of its parent view. If the subview is totally
opaque, then the area occupied by the subview completely obscures the corresponding area of the parent. If
the subview is partially transparent, the content from the two viewsis blended together prior to being displayed
View and Window Architecture
View Architecture Fundamentals
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
11on the screen. Each superview stores its subviews in an ordered array and the order in that array also affects
the visibility of each subview. If two sibling subviews overlap each other, the one that was added last (or was
moved to the end of the subview array) appears on top of the other.
The superview-subview relationship also impacts several view behaviors. Changing the size of a parent view
has a ripple effect that can cause the size and position of any subviews to change too. When you change the
size of a parent view, you can control the resizing behavior of each subview by configuring the view
appropriately. Other changes that affect subviews include hiding a superview, changing a superview’s alpha
(transparency), or applying a mathematical transform to a superview’s coordinate system.
The arrangement of views in a view hierarchy also determines how your application responds to events. When
a touch occurs inside a specific view, the system sends an event object with the touch information directly to
that view for handling. However, if the view does not handle a particular touch event, it can pass the event
object along to its superview. If the superview does not handle the event, it passes the event object to its
superview, and so on up the responder chain. Specific views can also pass the event object to an intervening
responder object, such as a view controller. If no object handles the event, it eventually reaches the application
object, which generally discards it.
For more information about how to create view hierarchies,see “Creating and Managing a View Hierarchy” (page
42).
The View Drawing Cycle
The UIView class uses an on-demand drawing model for presenting content. When a view first appears on
the screen, the system asks it to draw its content. The system captures a snapshot of this content and uses
that snapshot as the view’s visual representation. If you never change the view’s content, the view’s drawing
code may never be called again. The snapshot image is reused for most operations involving the view. If you
do change the content, you notify the system that the view has changed. The view then repeats the process
of drawing the view and capturing a snapshot of the new results.
When the contents of your view change, you do not redraw those changes directly. Instead, you invalidate the
view using either the setNeedsDisplay or setNeedsDisplayInRect: method. These methods tell the
system that the contents of the view changed and need to be redrawn at the next opportunity. The system
waits until the end of the current run loop before initiating any drawing operations. This delay gives you a
chance to invalidate multiple views, add or remove views from your hierarchy, hide views, resize views, and
reposition views all at once. All of the changes you make are then reflected at the same time.
View and Window Architecture
View Architecture Fundamentals
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
12Note: Changing a view’s geometry does not automatically cause the system to redraw the view’s
content. The view’s contentMode property determines how changes to the view’s geometry are
interpreted. Most content modes stretch or reposition the existing snapshot within the view’s
boundaries and do not create a new one. For more information about how content modes affect
the drawing cycle of your view, see “Content Modes” (page 13).
When the time comes to render your view’s content, the actual drawing process varies depending on the view
and its configuration. System views typically implement private drawing methods to render their content.
Those same system views often expose interfaces that you can use to configure the view’s actual appearance.
For custom UIView subclasses, you typically override the drawRect: method of your view and use that
method to draw your view’s content. There are also other ways to provide a view’s content, such as setting
the contents of the underlying layer directly, but overriding the drawRect: method is the most common
technique.
For more information about how to draw content for custom views, see “Implementing Your Drawing
Code” (page 60).
Content Modes
Each view has a content mode that controls how the view recycles its content in response to changes in the
view’s geometry and whether it recycles its content at all. When a view is first displayed, it renders its content
as usual and the results are captured in an underlying bitmap. After that, changes to the view’s geometry do
not always cause the bitmap to be recreated. Instead, the value in the contentMode property determines
whether the bitmap should be scaled to fit the new bounds or simply pinned to one corner or edge of the
view.
The content mode of a view is applied whenever you do the following:
● Change the width or height of the view’s frame or bounds rectangles.
● Assign a transform that includes a scaling factor to the view’s transform property.
View and Window Architecture
View Architecture Fundamentals
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
13By default, the contentMode property for most views is set to UIViewContentModeScaleToFill, which
causes the view’s contents to be scaled to fit the new frame size. Figure 1-2 shows the results that occur for
some content modes that are available. As you can see from the figure, not all content modes result in the
view’s bounds being filled entirely, and those that do might distort the view’s content.
Figure 1-2 Content mode comparisons
UIViewContentModeScaleToFill
Distorting
Nondistorting
UIViewContentModeScaleAspectFit
UIViewContentModeScaleAspectFill
Nondistorting
Nondistorting
UIViewContentModeLeft
View and Window Architecture
View Architecture Fundamentals
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
14Content modes are good for recycling the contents of your view, but you can also set the content mode to
the UIViewContentModeRedraw value when you specifically want your custom views to redraw themselves
during scaling and resizing operations. Setting your view’s content mode to this value forces the system to
call your view’s drawRect: method in response to geometry changes. In general, you should avoid using this
value whenever possible, and you should certainly not use it with the standard system views.
For more information about the available content modes, see UIView Class Reference .
Stretchable Views
You can designate a portion of a view asstretchable so that when the size of the view changes only the content
in the stretchable portion is affected. You typically use stretchable areas for buttons or other views where part
of the view defines a repeatable pattern. The stretchable area you specify can allow for stretching along one
or both axes of the view. Of course, when stretching a view along two axes, the edges of the view must also
define a repeatable pattern to avoid any distortion. Figure 1-3 shows how this distortion manifests itself in a
view. The color from each of the view’s original pixels is replicated to fill the corresponding area in the larger
view.
Figure 1-3 Stretching the background of a button
(0,0)
(1,1)
View and Window Architecture
View Architecture Fundamentals
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
15You specify the stretchable area of a view using the contentStretch property. This property accepts a
rectangle whose values are normalized to the range 0.0 to 1.0. When stretching the view, the system multiplies
these normalized values by the view’s current bounds and scale factor to determine which pixel or pixels need
to be stretched. The use of normalized values alleviates the need for you to update the contentStretch
property every time the bounds of your view change.
The view’s content mode also plays a role in determining how the view’s stretchable area is used. Stretchable
areas are only used when the content mode would cause the view’s content to be scaled. This means that
stretchable views are supported only with the UIViewContentModeScaleToFill,
UIViewContentModeScaleAspectFit, and UIViewContentModeScaleAspectFill content modes. If
you specify a content mode that pins the content to an edge or corner (and thus does not actually scale the
content), the view ignores the stretchable area.
Note: The use of the contentStretch property isrecommended over the creation of a stretchable
UIImage object when specifying the background for a view. Stretchable views are handled entirely
in the Core Animation layer, which typically offers better performance.
Built-In Animation Support
One of the benefits of having a layer object behind every view is that you can animate many view-related
changes easily. Animations are a useful way to communicate information to the user and should always be
considered during the design of your application. Many properties of the UIView class are animatable—that
is, semiautomatic support exists for animating from one value to another. To perform an animation for one of
these animatable properties, all you have to do is:
1. Tell UIKit that you want to perform an animation.
2. Change the value of the property.
Among the properties you can animate on a UIView object are the following:
frame—Use this to animate position and size changes for the view.
bounds—Use this to animate changes to the size of the view.
center—Use this to animate the position of the view.
transform—Use this to rotate or scale the view.
alpha—Use this to change the transparency of the view.
backgroundColor—Use this to change the background color of the view.
contentStretch—Use this to change how the view’s contents stretch.
View and Window Architecture
View Architecture Fundamentals
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
16One place where animations are very important is when transitioning from one set of viewsto another. Typically,
you use a view controller to manage the animations associated with major changes between parts of your
user interface. For example, for interfaces that involve navigating from higher-level to lower-level information,
you typically use a navigation controller to manage the transitions between the views displaying each successive
level of data. However, you can also create transitions between two sets of views using animations instead of
a view controller. You might do so in places where the standard view-controller animations do not yield the
results you want.
In addition to the animations you create using UIKit classes, you can also create animations using Core Animation
layers. Dropping down to the layer level gives you much more control over the timing and properties of your
animations.
For details about how to perform view-based animations, see “Animations” (page 64). For more information
about creating animations using Core Animation, see Core Animation Programming Guide and Core Animation
Cookbook .
View Geometry and Coordinate Systems
The default coordinate system in UIKit has its origin in the top-left corner and has axes that extend down and
to the right from the origin point. Coordinate values are represented using floating-point numbers, which
allow for precise layout and positioning of content regardless of the underlying screen resolution. Figure 1-4
shows this coordinate system relative to the screen. In addition to the screen coordinate system, windows and
views define their own local coordinate systems that allow you to specify coordinates relative to the view or
window origin instead of relative to the screen.
Figure 1-4 Coordinate system orientation in UIKit
y
x
(0,0)
View and Window Architecture
View Geometry and Coordinate Systems
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
17Because every view and window defines its own local coordinate system, you need to be aware of which
coordinate system is in effect at any given time. Every time you draw into a view or change its geometry, you
do so relative to some coordinate system. In the case of drawing, you specify coordinates relative to the view’s
own coordinate system. In the case of geometry changes, you specify coordinates relative to the superview’s
coordinate system. The UIWindow and UIView classes both include methods to help you convert from one
coordinate system to another.
Important: Some iOS technologies define default coordinate systems whose origin point and orientation
differ from those used by UIKit. For example, Core Graphics and OpenGL ES use a coordinate system whose
origin lies in the lower-left corner of the view or window and whose y-axis points upward relative to the
screen. Your code must take such differences into account when drawing or creating content and adjust
coordinate values (or the default orientation of the coordinate system) as needed.
The Relationship of the Frame, Bounds, and Center Properties
A view object tracks its size and location using its frame, bounds, and center properties:
● The frame property contains the frame rectangle, which specifies the size and location of the view in its
superview’s coordinate system.
● The bounds property contains the bounds rectangle, which specifies the size of the view (and its content
origin) in the view’s own local coordinate system.
● The center property contains the known center point of the view in the superview’s coordinate system.
You use the center and frame properties primarily for manipulating the geometry of the current view. For
example, you use these properties when building your view hierarchy or changing the position or size of a
view at runtime. If you are changing only the position of the view (and not its size), the center property is
the preferred way to do so. The value in the center property is always valid, even if scaling or rotation factors
have been added to the view’s transform. The same is not true for the value in the frame property, which is
considered invalid if the view’s transform is not equal to the identity transform.
You use the bounds property primarily during drawing. The bounds rectangle is expressed in the view’s own
local coordinate system. The default origin of this rectangle is (0, 0) and its size matches the size of the frame
rectangle. Anything you draw inside this rectangle is part of the view’s visible content. If you change the origin
of the boundsrectangle, anything you draw inside the new rectangle becomes part of the view’s visible content.
View and Window Architecture
View Geometry and Coordinate Systems
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
18Figure 1-5 shows the relationship between the frame and bounds rectangles for an image view. In the figure,
the upper-left corner of the image view is located at the point (40, 40) in its superview’s coordinate system
and the size of the rectangle is 240 by 380 points. For the bounds rectangle, the origin point is (0, 0) and the
size of the rectangle is similarly 240 by 380 points.
Figure 1-5 Relationship between a view's frame and bounds
Frame rectangle
Center
(160,230)
Bounds rectangle
240
240
380 380
(40,40) (0,0)
Although you can change the frame, bounds, and center properties independent of the others, changes to
one property affect the others in the following ways:
● When you set the frame property, the size value in the bounds property changes to match the new size
of the frame rectangle. The value in the center property similarly changes to match the new center point
of the frame rectangle.
● When you set the center property, the origin value in the frame changes accordingly.
● When you set the size of the bounds property, the size value in the frame property changes to match
the new size of the bounds rectangle.
By default, a view’s frame is not clipped to its superview’s frame. Thus, any subviews that lie outside of their
superview’sframe are rendered in their entirety. You can change this behavior, though, by setting the superview’s
clipsToBounds property to YES. Regardless of whether or not subviews are clipped visually, touch events
always respect the bounds rectangle of the target view’s superview. In other words, touch events occurring in
a part of a view that lies outside of its superview’s bounds rectangle are not delivered to that view.
View and Window Architecture
View Geometry and Coordinate Systems
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
19Coordinate System Transformations
Coordinate system transformations offer a way to alter your view (or its contents) quickly and easily. An affine
transform is a mathematical matrix that specifies how points in one coordinate system map to points in a
different coordinate system. You can apply affine transforms to your entire view to change the size, location,
or orientation of the view relative to its superview. You can also use affine transforms in your drawing code to
perform the same types of manipulations to individual pieces of rendered content. How you apply the affine
transform therefore depends on context:
● To modify your entire view, modify the affine transform in the transform property of your view.
● To modify specific pieces of content in your view’s drawRect: method, modify the affine transform
associated with the active graphics context.
You typically modify the transform property of a view when you want to implement animations. For example,
you could use this property to create an animation of your view rotating around its center point. You would
not use this property to make permanent changes to your view, such as modifying its position or size a view
within its superview’s coordinate space. For that type of change, you should modify the frame rectangle of
your view instead.
Note: When modifying the transform property of your view, all transformations are performed
relative to the center point of the view.
In your view’s drawRect: method, you use affine transforms to position and orient the items you plan to
draw. Rather than fix the position of an object at some location in your view, it is simpler to create each object
relative to a fixed point, typically (0, 0), and use a transform to position the object immediately prior to drawing.
That way, if the position of the object changes in your view, all you have to do is modify the transform, which
is much faster and less expensive than recreating the object at its new location. You can retrieve the affine
transform associated with a graphics context using the CGContextGetCTM function and you can use the
related Core Graphics functions to set or modify this transform during drawing.
The current transformation matrix (CTM) is the affine transform in use at any given time. When manipulating
the geometry of your entire view, the CTM is the affine transform stored in your view’s transform property.
Inside your drawRect: method, the CTM is the affine transform associated with the active graphics context.
The coordinate system of each subview builds upon the coordinate systems of its ancestors. So when you
modify a view’s transform property, that change affects the view and all of its subviews. However, these
changes affect only the final rendering of the views on the screen. Because each view draws its content and
lays out its subviews relative to its own bounds, it can ignore its superview’s transform during drawing and
layout.
View and Window Architecture
View Geometry and Coordinate Systems
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
20Figure 1-6 demonstrates how two different rotation factors combine visually when rendered. Inside the view’s
drawRect: method, applying a 45 degree rotation factor to a shape causes that shape to appear rotated by
45 degrees. Applying a separate 45 degree rotation factor to the view then causes the shape to appear to be
rotated by 90 degrees. The shape is still rotated by only 45 degrees relative to the view that drew it, but the
view rotation makes it appear to be rotated by more.
Figure 1-6 Rotating a view and its content
No rotations Shape rotated 45˚
during drawing
Shape and view each
rotated 45˚
Important: If a view’s transform property is not the identity transform, the value of that view’s frame
property is undefined and must be ignored. When applying transforms to a view, you must use the view’s
bounds and center properties to get the size and position of the view. The frame rectangles of any
subviews are still valid because they are relative to the view’s bounds.
For information about modifying your view’s transform property at runtime, see “Translating, Scaling, and
Rotating Views” (page 47). For information about how to use transforms to position content during drawing,
see Drawing and Printing Guide for iOS .
Points Versus Pixels
In iOS, all coordinate values and distances are specified using floating-point valuesin unitsreferred to as points.
The measurable size of a point variesfrom device to device and islargely irrelevant. The main thing to understand
about points is that they provide a fixed frame of reference for drawing.
View and Window Architecture
View Geometry and Coordinate Systems
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
21Table 1-1 lists the screen dimensions (measured in points) for different types of iOS-based devices in a portrait
orientation. The width dimension is listed first, followed by the height dimension of the screen. As long as you
design your interface to these screen sizes, your views will display correctly on the corresponding type of
device.
Table 1-1 Screen dimensions for iOS-based devices
Device Screen dimensions (in points)
iPhone and iPod touch 320 x 480
iPad 768 x 1024
The point-based measuring system used for each type of device defines what is known as the user coordinate
space. This is the standard coordinate space you use for nearly all of your code. For example, you use points
and the user coordinate space when manipulating the geometry of a view or calling Core Graphics functions
to draw the contents of your view. Although coordinates in the user coordinate space sometimes map directly
to the pixels on the device’s screen, you should never assume that this is the case. Instead, you should always
remember the following:
One point does not necessarily correspond to one pixel on the screen.
At the device level, all coordinates you specify in your view must be converted to pixels atsome point. However,
the mapping of pointsin the user coordinate space to pixelsin the device coordinate space is normally handled
by the system. Both UIKit and Core Graphics use a primarily vector-based drawing model where all coordinate
values are specified using points. Thus, if you draw a curve using Core Graphics, you specify the curve using
the same values, regardless of the resolution of the underlying screen.
When you need to work with images or other pixel-based technologies such as OpenGL ES, iOS provides help
in managing those pixels. For static image files stored as resources in your application bundle, iOS defines
conventionsforspecifying your images at different pixel densities and for loading the image that best matches
the current screen resolution. Views also provide information about the current scale factor so that you can
adjust any pixel-based drawing code manually to accommodate higher-resolution screens. The techniques for
dealing with pixel-based content at different screen resolutions is described in “Supporting High-Resolution
Screens” in Drawing and Printing Guide for iOS .
View and Window Architecture
View Geometry and Coordinate Systems
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
22The Runtime Interaction Model for Views
Any time a user interacts with your user interface, or any time your own code programmatically changes
something, a complex sequence of events takes place inside of UIKit to handle that interaction. At specific
points during that sequence, UIKit calls out to your view classes and gives them a chance to respond on behalf
of your application. Understanding these callout points is important to understanding where your views fit
into the system. Figure 1-7 shows the basic sequence of events that starts with the user touching the screen
and ends with the graphics system updating the screen content in response. The same sequence of events
would also occur for any programmatically initiated actions.
Figure 1-7 UIKit interactions with your view objects
Your Application
iPhone OS
Touches
• Buffers
• Images
• Attributes
• Geometry
• Animations
touches
layoutSubviews
drawRect
Compositor Draw images, text, etc.
Touch Framework
Graphics hardware
UIKit
setNeedsDisplay
frame, alpha, etc.
setNeedsLayout
setNeedsDisplay
frame, alpha, etc.
The following steps break the event sequence in Figure 1-7 (page 23) down even further and explain what
happens at each stage and how you might want your application to react in response.
1. The user touches the screen.
2. The hardware reports the touch event to the UIKit framework.
3. The UIKit framework packages the touch into a UIEvent object and dispatches it to the appropriate view.
(For a detailed explanation of how UIKit delivers events to your views, see Event Handling Guide for iOS .)
4. The event-handling code of your view responds to the event. For example, your code might:
● Change the properties (frame, bounds, alpha, and so on) of the view or its subviews.
● Call the setNeedsLayout method to mark the view (or its subviews) as needing a layout update.
● Call the setNeedsDisplay or setNeedsDisplayInRect: method to mark the view (or itssubviews)
as needing to be redrawn.
● Notify a controller about changes to some piece of data.
View and Window Architecture
The Runtime Interaction Model for Views
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
23Of course, it is up to you to decide which of these things the view should do and which methods it should
call.
5. If the geometry of a view changed for any reason, UIKit updates its subviews according to the following
rules:
a. If you have configured autoresizing rules for your views, UIKit adjusts each view according to those
rules. For more information about how autoresizing rules work, see “Handling Layout Changes
Automatically Using Autoresizing Rules” (page 52).
b. If the view implements the layoutSubviews method, UIKit calls it.
You can override this method in your custom views and use it to adjust the position and size of any
subviews. For example, a view that provides a large scrollable area would need to use severalsubviews
as “tiles” rather than create one large view, which is not likely to fit in memory anyway. In its
implementation of this method, the view would hide any subviewsthat are now offscreen or reposition
them and use them to draw newly exposed content. As part of this process, the view’s layout code
can also invalidate any views that need to be redrawn.
6. If any part of any view was marked as needing to be redrawn, UIKit asks the view to redraw itself.
For custom viewsthat explicitly define a drawRect: method, UIKit callsthat method. Your implementation
of this method should redraw the specified area of the view as quickly as possible and nothing else. Do
not make additional layout changes at this point and do not make other changes to your application’s
data model. The purpose of this method is to update the visual content of your view.
Standard system viewstypically do not implement a drawRect: method but instead manage their drawing
at this time.
7. Any updated views are composited with the rest of the application’s visible content and sent to the graphics
hardware for display.
8. The graphics hardware transfers the rendered content to the screen.
Note: The preceding update model applies primarily to applicationsthat use standard system views
and drawing techniques. Applications that use OpenGL ES for drawing typically configure a single
full-screen view and draw directly to the associated OpenGL graphics context. In such a case, the
view would still handle touch events but, because it is full-screen, it would not need to lay out
subviews or implement a drawRect: method. For more information about using OpenGL ES, see
OpenGL ES Programming Guide for iOS .
In the preceding set of steps, the primary integration points for your own custom views are:
● The event-handling methods:
● touchesBegan:withEvent:
View and Window Architecture
The Runtime Interaction Model for Views
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
24● touchesMoved:withEvent:
● touchesEnded:withEvent:
● touchesCancelled:withEvent:
● The layoutSubviews method
● The drawRect: method
These are the most commonly overridden methods for views but you may not need to override all of them. If
you use gesture recognizersto handle events, you do not need to override any of the event-handling methods.
Similarly, if your view does not contain subviews or its size does not change, there is no reason to override the
layoutSubviews method. Finally, the drawRect: method is needed only when the contents of your view
can change at runtime and you are using native technologiessuch as UIKit or Core Graphicsto do your drawing.
It is also important to remember that these are the primary integration points but not the only ones. Several
methods of the UIView class are designed to be override points for subclasses. You should look at the method
descriptions in UIView Class Reference to see which methods might be appropriate for you to override in your
custom implementations.
Tips for Using Views Effectively
Custom views are useful for situations where you need to draw something the standard system views do not
provide, but it is your responsibility to ensure that the performance of your views is good enough. UIKit does
everything it can to optimize view-related behaviors and help you achieve good performance in your custom
views. However, you can help UIKit in this aspect by considering the following tips.
Important: Before optimizing your drawing code, you should always gather data about your view’s current
performance. Measuring the current performance lets you confirm whether there actually is a problem and,
if there is, gives you a baseline measurement against which you can compare future optimizations.
Views Do Not Always Have a Corresponding View Controller
There is rarely a one-to-one relationship between individual views and view controllers in your application. The
job of a view controller is to manage a view hierarchy, which often consists of more than one view used to
implement some self-contained feature. For iPhone applications, each view hierarchy typically fills the entire
screen, although for iPad applications a view hierarchy may fill only part of the screen.
View and Window Architecture
Tips for Using Views Effectively
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
25As you design your application’s user interface, it is important to consider the role that view controllers will
play. View controllers provide a lot of important behaviors, such as coordinating the presentation of views on
the screen, coordinating the removal of those views from the screen, releasing memory in response to
low-memory warnings, and rotating views in response to interface orientation changes. Circumventing these
behaviors could cause your application to behave incorrectly or in unexpected ways.
For more information view controllers and their role in applications, see View Controller Programming Guide
for iOS .
Minimize Custom Drawing
Although custom drawing is necessary at times, it is also something you should avoid whenever possible. The
only time you should truly do any custom drawing is when the existing system view classes do not provide
the appearance or capabilities that you need. Any time your content can be assembled with a combination of
existing views, your best bet is to combine those view objects into a custom view hierarchy.
Take Advantage of Content Modes
Content modes minimize the amount of time spent redrawing your views. By default, views use the
UIViewContentModeScaleToFill content mode, which scales the view’s existing contents to fit the view’s
frame rectangle. You can change this mode as needed to adjust your content differently, but you should avoid
using the UIViewContentModeRedraw content mode if you can. Regardless of which content mode is in
effect, you can always force your view to redraw its contents by calling setNeedsDisplay or
setNeedsDisplayInRect:.
Declare Views as Opaque Whenever Possible
UIKit uses the opaque property of each view to determine whether the view can optimize compositing
operations. Setting the value of this property to YES for a custom view tells UIKit that it does not need to render
any content behind your view. Less rendering can lead to increased performance for your drawing code and
is generally encouraged. Of course, if you set the opaque property to YES, your view must fills its bounds
rectangle completely with fully opaque content.
Adjust Your View’s Drawing Behavior When Scrolling
Scrolling can incur numerous view updates in a short amount of time. If your view’s drawing code is not tuned
appropriately, scrolling performance for your view could be sluggish. Rather than trying to ensure that your
view’s content is pristine at all times, consider changing your view’s behavior when a scrolling operation begins.
View and Window Architecture
Tips for Using Views Effectively
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
26For example, you can reduce the quality of your rendered content temporarily or change the content mode
while a scroll isin progress. When scrolling stops, you can then return your view to its previousstate and update
the contents as needed.
Do Not Customize Controls by Embedding Subviews
Although it is technically possible to add subviews to the standard system controls—objects that inherit from
UIControl—you should never customize them in this way. Controlsthatsupport customizations do so through
explicit and well-documented interfaces in the control class itself. For example, the UIButton class contains
methods for setting the title and background images for the button. Using the defined customization points
meansthat your code will always work correctly. Circumventing these methods, by embedding a custom image
view or label inside the button, might cause your application to behave incorrectly now or at some point in
the future if the button’s implementation changes.
View and Window Architecture
Tips for Using Views Effectively
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
27Every iOS application needs at least one window—an instance of the UIWindow class—and some may include
more than one window. A window object has several responsibilities:
●
It contains your application’s visible content.
●
It plays a key role in the delivery of touch events to your views and other application objects.
●
It works with your application’s view controllers to facilitate orientation changes.
In iOS, windows do not have title bars, close boxes, or any other visual adornments. A window is always just
a blank container for one or more views. Also, applications do not change their content by showing new
windows. When you want to change the displayed content, you change the frontmost views of your window
instead.
Most iOS applications create and use only one window during their lifetime. This window spans the entire
main screen of the device and is loaded from the application’s main nib file (or created programmatically) early
in the life of the application. However, if an application supports the use of an external display for video out,
it can create an additional window to display content on that external display. All other windows are typically
created by the system, and are usually created in response to specific events, such as an incoming phone call.
Tasks That Involve Windows
For many applications, the only time the application interacts with its window is when it creates the window
at startup. However, you can use your application’s window object to perform a few application-related tasks:
● Use the window object to convert points and rectangles to or from the window’s local coordinate
system. For example, if you are provided with a value in window coordinates, you might want to convert
it to the coordinate system of a specific view before trying to use it. For information on how to convert
coordinates, see “Converting Coordinates in the View Hierarchy” (page 50).
● Use window notifications to track window-related changes. Windows generate notifications when they
are shown or hidden or when they accept or resign the key status. You can use these notifications to
perform actions in other parts of your application. For more information, see “Monitoring Window
Changes” (page 31).
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
28
WindowsCreating and Configuring a Window
You can create and configure your application’s main window programmatically or using Interface Builder. In
either case, you create the window at launch time and should retain it and store a reference to it in your
application delegate object. If your application creates additional windows, have the application create them
lazily when they are needed. For example, if your application supports displaying content on an external display,
it should wait until a display is connected before creating the corresponding window.
You should always create your application’s main window at launch time regardless of whether your application
is being launched into the foreground or background. Creating and configuring a window is not an expensive
operation by itself. However, if your application is launched straight into the background, you should avoid
making the window visible until your application enters the foreground.
Creating Windows in Interface Builder
Creating your application’s main window using Interface Builder issimple because the Xcode project templates
do it for you. Every new Xcode application project includes a main nib file (usually with the name
MainWindow.xib or some variant thereof) that includes the application’s main window. In addition, these
templates also define an outlet for that window in the application delegate object. You use this outlet to access
the window object in your code.
Important: When creating your window in Interface Builder, it is recommended that you enable the Full
Screen at Launch option in the attributes inspector. If this option is not enabled and your window is smaller
than the screen of the target device, touch events will not be received by some of your views. Thisis because
windows (like all views) do not receive touch events outside of their bounds rectangle. Because views are
not clipped to the window’s bounds by default, the views still appear visible but events do not reach them.
Enabling the Full Screen at Launch option ensures that the window is sized appropriately for the current
screen.
If you are retrofitting a project to use Interface Builder, creating a window using Interface Builder is a simple
matter of dragging a window object to your nib file. Of course, you should also do the following:
● To access the window at runtime, you should connect the window to an outlet, typically one defined in your
application delegate or the File’s Owner of the nib file.
●
If your retrofit plans include making your new nib file the main nib file of your application, you must also
set the NSMainNibFile key in your application’s Info.plist file to the name of your nib file. Changing
the value of this key ensures that the nib file is loaded and available for use by the time the
application:didFinishLaunchingWithOptions: method of your application delegate is called.
For more information about creating and configuring nib files,see Interface Builder User Guide . For information
about how to load nib files into your application at runtime, see “Nib Files” in Resource Programming Guide .
Windows
Creating and Configuring a Window
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
29Creating a Window Programmatically
If you prefer to create your application’s main window programmatically, you should include code similar to
the following in the application:didFinishLaunchingWithOptions: method of your application
delegate:
self.window = [[[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]]
autorelease];
In the preceding example, self.window is assumed to be a declared property of your application delegate
that is configured to retain the window object. If you were creating a window for an external display instead,
you would assign it to a different variable and you would need to specify the bounds of the non main UIScreen
object representing that display.
When creating windows, you should always set the size of the window to the full bounds of the screen. You
should not reduce the size of the window to accommodate the status bar or any other items. The status bar
always floats on top of the window anyway, so the only thing you should shrink to accommodate the status
bar is the view you put into your window. And if you are using view controllers, the view controller should
handle the sizing of your views automatically.
Adding Content to Your Window
Each window typically has a single root view object (managed by a corresponding view controller) that contains
all of the other views representing your content. Using a single root view simplifies the process of changing
your interface; to display new content, all you have to do is replace the root view. To install a view in your
window, use the addSubview: method. For example, to install a view that is managed by a view controller,
you would use code similar to the following:
[window addSubview:viewController.view];
In place of the preceding code, you can alternatively configure the rootViewController property of the
window in your nib file. This property offers a convenient way to configure the root view of the window using
a nib file instead of programmatically. If this property is set when the window is loaded from its nib file, UIKit
automatically installsthe view from the associated view controller asthe root view of the window. This property
is used only to install the root view and is not used by the window to communicate with the view controller.
You can use any view you want for a window’s root view. Depending on your interface design, the root view
can be a generic UIView object that acts as a container for one or more subviews, the root view can be a
standard system view, or the root view can be a custom view that you define. Some standard system views
that are commonly used as root views include scroll views, table views, and image views.
Windows
Creating and Configuring a Window
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
30When configuring the root view of the window, you are responsible for setting its initial size and position
within the window. For applications that do not include a status bar, or that display a translucent status bar,
set the view size to match the size of the window. For applications that show an opaque status bar, position
your view below the status bar and reduce its size accordingly. Subtracting the status bar height from the
height of your view prevents the top portion of your view from being obscured.
Note: If the root view of your window is provided by a container view controller (such as a tab bar
controller, navigation controller, or split-view controller), you do not need to set the initial size of
the view yourself. The container view controller automatically sizes its view appropriately based on
whether the status bar is visible.
Changing the Window Level
Each UIWindow object has a configurable windowLevel property that determines how that window is
positioned relative to other windows. For the most part, you should not need to change the level of your
application’s windows. New windows are automatically assigned to the normal window level at creation time.
The normal window level indicates that the window presents application-related content. Higher window
levels are reserved for information that needs to float above the application content, such as the system status
bar or alert messages. And although you can assign windows to these levels yourself, the system usually does
this for you when you use specific interfaces. For example, when you show or hide the status bar or display an
alert view, the system automatically creates the needed windows to display those items.
Monitoring Window Changes
If you want to track the appearance or disappearance of windows inside your application, you can do so using
these window-related notifications:
● UIWindowDidBecomeVisibleNotification
● UIWindowDidBecomeHiddenNotification
● UIWindowDidBecomeKeyNotification
● UIWindowDidResignKeyNotification
These notifications are delivered in response to programmatic changes in your application’s windows. Thus,
when your application shows or hides a window, the UIWindowDidBecomeVisibleNotification and
UIWindowDidBecomeHiddenNotification notifications are delivered accordingly. These notifications are
not delivered when your application moves into the background execution state. Even though your window
is not displayed on the screen while your application is in the background, it is still considered visible within
the context of your application.
Windows
Monitoring Window Changes
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
31The UIWindowDidBecomeKeyNotification and UIWindowDidResignKeyNotification notifications
help your application keep track of which window is the key window—that is, which window is currently
receiving keyboard events and other non touch-related events. Whereas touch events are delivered to the
window in which the touch occurred, events that do not have an associated coordinate value are delivered to
the key window of your application. Only one window at a time may be key.
Displaying Content on an External Display
To display content on an external display, you must create an additional window for your application and
associate it with the screen object representing the external display. New windows are normally associated
with the main screen by default. Changing the window’s associated screen object causes the contents of that
window to be rerouted to the corresponding display. Once the window is associated with the correct screen,
you can add views to it and show it just like you do for your application’s main screen.
The UIScreen class maintains a list of screen objects representing the available hardware displays. Normally,
there is only one screen object representing the main display for any iOS-based device, but devicesthatsupport
connecting to an external display can have an additional screen object available. Devices that support an
external display include iPhone and iPod touch devices that have Retina displays and the iPad. Older devices,
such as iPhone 3GS, do not support external displays.
Note: Because external displays are essentially a video-out connection, you should not expect touch
events for views and controls in a window that is associated with an external display. In addition, it
is your application’s responsibility to update the contents of the window as needed. Thus, to mirror
the contents of your main window, your application would need to create a duplicate set of views
for the external display’s window and update them in tandem with the views in your main window.
The process for displaying content on an external display is described in the following sections. However, the
following steps summarize the basic process:
1. At application startup, register for the screen connection and disconnection notifications.
2. When it is time to display content on the external display, create and configure a window.
● Use the screens property of UIScreen to obtain the screen object for the external display.
● Create a UIWindow object and size it appropriately for the screen (or for your content).
● Assign the UIScreen object for the external display to the screen property of the window.
● Adjust the resolution of the screen object as needed to support your content.
● Add any appropriate views to the window.
Windows
Displaying Content on an External Display
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
323. Show the window and update it normally.
Handling Screen Connection and Disconnection Notifications
Screen connection and disconnection notifications are crucial for handling changes to external displays
gracefully. When the user connects or disconnects a display, the system sends appropriate notifications to
your application. You should use these notifications to update your application state and create or release the
window associated with the external display.
The important thing to remember about the connection and disconnection notificationsisthat they can come
at any time, even when your application is suspended in the background. Therefore, it is best to observe the
notifications from an object that is going to exist for the duration of your application’s runtime, such as your
application delegate. If your application is suspended, the notifications are queued until your application exits
the suspended state and starts running in either the foreground or background.
Listing 2-1 shows the code used to register for connection and disconnection notifications. This method is
called by the application delegate at initialization time but you could register for these notificationsfrom other
places in your application, too. The implementation of the handler methods is shown in Listing 2-2 (page 34).
Listing 2-1 Registering for screen connect and disconnect notifications
- (void)setupScreenConnectionNotificationHandlers
{
NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
[center addObserver:self selector:@selector(handleScreenConnectNotification:)
name:UIScreenDidConnectNotification object:nil];
[center addObserver:self selector:@selector(handleScreenDisconnectNotification:)
name:UIScreenDidDisconnectNotification object:nil];
}
If your application is active when an external display is attached to the device, itshould create a second window
for that display and fill it with some content. The content does not need to be the final content you want to
present. For example, if your application is not ready to use the extra screen, it can use the second window to
display some placeholder content. If you do not create a window for the screen, or if you create a window but
do not show it, a black field is displayed on the external display.
Windows
Displaying Content on an External Display
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
33Listing 2-2 shows how to create a secondary window and fill it with some content. In this example, the application
creates the window in the handler methods it uses to receive screen connection notifications. (For information
about registering for connection and disconnection notifications, see Listing 2-1 (page 33).) The handler
method for the connection notification creates a secondary window, associates it with the newly connected
screen and calls a method of the application’s main view controller to add some content to the window and
show it. The handler method for the disconnection notification releases the window and notifies the main
view controller so that it can adjust its presentation accordingly.
Listing 2-2 Handling connect and disconnect notifications
- (void)handleScreenConnectNotification:(NSNotification*)aNotification
{
UIScreen* newScreen = [aNotification object];
CGRect screenBounds = newScreen.bounds;
if (!_secondWindow)
{
_secondWindow = [[UIWindow alloc] initWithFrame:screenBounds];
_secondWindow.screen = newScreen;
// Set the initial UI for the window.
[viewController displaySelectionInSecondaryWindow:_secondWindow];
}
}
- (void)handleScreenDisconnectNotification:(NSNotification*)aNotification
{
if (_secondWindow)
{
// Hide and then delete the window.
_secondWindow.hidden = YES;
[_secondWindow release];
_secondWindow = nil;
// Update the main screen based on what is showing here.
[viewController displaySelectionOnMainScreen];
Windows
Displaying Content on an External Display
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
34}
}
Configuring a Window for an External Display
To display a window on an external screen, you must associate it with the correct screen object. This process
involves locating the proper UIScreen object and assigning it to the window’s screen property. You can get
the list of screen objects from the screens class method of UIScreen. The array returned by this method
always contains at least one object representing the main screen. If a second object is present, that object
represents a connected external display.
Listing 2-3 shows a method that is called at application startup to see if an external display is already attached.
If it is, the method creates a window, associatesit with the external display, and addssome placeholder content
before showing the window. In this case, the placeholder content is a white background and a label indicating
that there is no content to display. To show the window, this method changes the value of its hidden property
rather than calling makeKeyAndVisible. It does this because the window contains only static content and
is not used to handle events.
Listing 2-3 Configuring a window for an external display
- (void)checkForExistingScreenAndInitializeIfPresent
{
if ([[UIScreen screens] count] > 1)
{
// Associate the window with the second screen.
// The main screen is always at index 0.
UIScreen* secondScreen = [[UIScreen screens] objectAtIndex:1];
CGRect screenBounds = secondScreen.bounds;
_secondWindow = [[UIWindow alloc] initWithFrame:screenBounds];
_secondWindow.screen = secondScreen;
// Add a white background to the window
UIView* whiteField = [[UIView alloc] initWithFrame:screenBounds];
whiteField.backgroundColor = [UIColor whiteColor];
[_secondWindow addSubview:whiteField];
Windows
Displaying Content on an External Display
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
35[whiteField release];
// Center a label in the view.
NSString* noContentString = [NSString stringWithFormat:@""];
CGSize stringSize = [noContentString sizeWithFont:[UIFont
systemFontOfSize:18]];
CGRect labelSize = CGRectMake((screenBounds.size.width -
stringSize.width) / 2.0,
(screenBounds.size.height - stringSize.height)
/ 2.0,
stringSize.width, stringSize.height);
UILabel* noContentLabel = [[UILabel alloc] initWithFrame:labelSize];
noContentLabel.text = noContentString;
noContentLabel.font = [UIFont systemFontOfSize:18];
[whiteField addSubview:noContentLabel];
// Go ahead and show the window.
_secondWindow.hidden = NO;
}
}
Important: You should always associate a screen with a window before showing the window. While it is
possible to change screens for a window that is currently visible, doing so is an expensive operation and
should be avoided.
Assoon asthe window for an externalscreen is displayed, your application can begin updating it like any other
window. You can add and remove subviews as needed, change the contents of subviews, animate changes
to the views, and invalidate their contents as needed.
Windows
Displaying Content on an External Display
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
36Configuring the Screen Mode of an External Display
Depending on your content, you might want to change the screen mode before associating your window with
it. Many screens support multiple resolutions, some of which use different pixel aspect ratios. Screen objects
use the most common screen mode by default, but you can change that mode to one that is more suitable
for your content. For example, if you are implementing a game using OpenGL ES and your textures are designed
for a 640 x 480 pixel screen, you might change the screen mode for screens with higher default resolutions.
If you plan to use a screen mode other than the default one, you should apply that mode to the UIScreen
object before associating the screen with a window. The UIScreenMode class definesthe attributes of a single
screen mode. You can get a list of the modes supported by a screen from its availableModes property and
iterate through the list for one that matches your needs.
For more information about screen modes, see UIScreenMode Class Reference .
Windows
Displaying Content on an External Display
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
37Because view objects are the main way your application interacts with the user, they have many responsibilities.
Here are just a few:
● Layout and subview management
● A view defines its own default resizing behaviors in relation to its parent view.
● A view can manage a list of subviews.
● A view can override the size and position of its subviews as needed.
● A view can convert points in its coordinate system to the coordinate systems of other views or the
window.
● Drawing and animation
● A view draws content in its rectangular area.
● Some view properties can be animated to new values.
● Event handling
● A view can receive touch events.
● A view participates in the responder chain.
This chapter focuses on the steps for creating, managing, and drawing views and for handling the layout and
management of view hierarchies. For information about how to handle touch events (and other events) in
your views, see Event Handling Guide for iOS .
Creating and Configuring View Objects
You create views as self-contained objects either programmatically or using Interface Builder, and then you
assemble them into view hierarchies for use.
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
38
ViewsCreating View Objects Using Interface Builder
The simplest way to create viewsisto assemble them graphically using Interface Builder. From Interface Builder,
you can add views to your interface, arrange those views into hierarchies, configure each view’s settings, and
connect view-related behaviors to your code. Because Interface Builder uses live view objects—that is, actual
instances of the view classes—what you see at design time is what you get at runtime. You then save those
live objects in a nib file, which is a resource file that preserves the state and configuration of your objects.
You usually create nib filesin order to store an entire view hierarchy for one of your application’s view controllers.
The top level of the nib file usually contains a single view object that represents your view controller’s view.
(The view controller itself is typically represented by the File’s Owner object.) The top-level view should be
sized appropriately for the target device and contain all of the other views that are to be presented. It is rare
to use a nib file to store only a portion of your view controller’s view hierarchy.
When using nib files with a view controller, all you have to do is initialize the view controller with the nib file
information. The view controller handles the loading and unloading of your views at the appropriate times.
However, if your nib file is not associated with a view controller, you can load the nib file contents manually
using an NSBundle or UINib object, which use the data in the nib file to reconstitute your view objects.
For more information about how to use Interface Builder to create and configure your views, see Interface
Builder User Guide . For information about how view controllers load and manage their associated nib files, see
“Custom View Controllers” in View Controller Programming Guide for iOS . For more information about how to
load views programmatically from a nib file, see “Nib Files” in Resource Programming Guide .
Creating View Objects Programmatically
If you prefer to create views programmatically, you can do so using the standard allocation/initialization pattern.
The default initialization method for views is the initWithFrame: method, which sets the initial size and
position of the view relative to its (soon-to-be-established) parent view. For example, to create a new generic
UIView object, you could use code similar to the following:
CGRect viewRect = CGRectMake(0, 0, 100, 100);
UIView* myView = [[UIView alloc] initWithFrame:viewRect];
Views
Creating and Configuring View Objects
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
39Note: Although all views support the initWithFrame: method, some may have a preferred
initialization method that you should use instead. For information about any custom initialization
methods, see the reference documentation for the class.
After you create a view, you must add it to a window (or to another view in a window) before it can become
visible. For information on how to add viewsto your view hierarchy,see “Adding and Removing Subviews” (page
43).
Setting the Properties of a View
The UIView class hasseveral declared properties for controlling the appearance and behavior of the view. These
properties are for manipulating the size and position of the view, the view’stransparency, its background color,
and its rendering behavior. All of these properties have appropriate default values that you can change later
as needed. You can also configure many of these propertiesfrom Interface Builder using the Inspector window.
Table 3-1 lists some of the more commonly used properties (and some methods) and describes their usage.
Related properties are listed together so that you can see the options you have for affecting certain aspects
of the view.
Table 3-1 Usage of some key view properties
Properties Usage
These properties affect the opacity of the view. The alpha and hidden
properties change the view’s opacity directly.
The opaque property tells the system how it should composite your
view. Set this property to YES if your view’s content is fully opaque and
therefore does not reveal any of the underlying view’s content. Setting
this property to YES improves performance by eliminating unnecessary
compositing operations.
alpha, hidden, opaque
Views
Creating and Configuring View Objects
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
40Properties Usage
These properties affect the size and position of the view. The center
and frame properties represent the position of the view relative to its
parent view. The frame also includes the size of the view. The bounds
property defines the view’s visible content area in its own coordinate
system.
The transform property is used to animate or move the entire view
in complex ways. For example, you would use a transform to rotate or
scale the view. If the current transform is not the identity transform, the
frame property is undefined and should be ignored.
For information about the relationship between the bounds, frame,
and center properties, see “The Relationship of the Frame, Bounds,
and Center Properties” (page 18). For information about how transforms
affect a view, see “Coordinate System Transformations” (page 20).
bounds, frame, center,
transform
These properties affect the automatic resizing behavior of the view and
its subviews. The autoresizingMask property controls how a view
responds to changes in its parent view’s bounds. The
autoresizesSubviews property controls whether the current view’s
subviews are resized at all.
autoresizingMask,
autoresizesSubviews
These properties affect the rendering behavior of content inside the
view. The contentMode and contentStretch properties determine
how the content is treated when the view’s width or height changes.
The contentScaleFactor property is used only when you need to
customize the drawing behavior of your view for high-resolution screens.
For more information on how the content mode affects your view, see
“Content Modes” (page 13). For information about how the content
stretch rectangle affects your view, see “Stretchable Views” (page 15).
For information about how to handle scale factors, see “Supporting
High-Resolution Screens” in Drawing and Printing Guide for iOS .
contentMode,
contentStretch,
contentScaleFactor
These properties affect how your view processes touch events. The
gestureRecognizers property contains gesture recognizers attached
to the view. The other properties control what touch events the view
supports.
For information about how to respond to eventsin your views,see Event
Handling Guide for iOS .
gestureRecognizers,
userInteractionEnabled,
multipleTouchEnabled,
exclusiveTouch
Views
Creating and Configuring View Objects
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
41Properties Usage
These properties and methods help you manage the actual content of
your view. For simple views, you can set a background color and add
one ormore subviews. The subviews property itself contains a read-only
list of subviews, but there are several methods for adding and
rearranging subviews. For views with custom drawing behavior, you
must override the drawRect: method.
For more advanced content, you can work directly with the view’s Core
Animation layer. To specify an entirely different type of layer for the
view (such as a layer that supports OpenGL ES drawing calls), you must
override the layerClass method.
backgroundColor,
subviews, drawRect:
method, layer,
(layerClass method)
Forinformation aboutthe basic properties common to all views,seeUIViewClass Reference . Formore information
about specific properties of a view, see the reference documentation for that view.
Tagging Views for Future Identification
The UIView class contains a tag property that you can use to tag individual view objects with an integer value.
You can use tags to uniquely identify views inside your view hierarchy and to perform searches for those views
at runtime. (Tag-based searches are faster than iterating the view hierarchy yourself.) The default value for the
tag property is 0.
To search for a tagged view, use the viewWithTag: method of UIView. This method performs a depth-first
search of the receiver and its subviews. It does not search superviews or other parts of the view hierarchy.
Thus, calling this method from the root view of a hierarchy searches all views in the hierarchy but calling it
from a specific subview searches only a subset of views.
Creating and Managing a View Hierarchy
Managing view hierarchies is a crucial part of developing your application’s user interface. The organization
of your views influences both the visual appearance of your application and how your application responds
to changes and events. For example, the parent-child relationships in the view hierarchy determine which
objects might handle a specific touch event. Similarly, parent-child relationships define how each view responds
to interface orientation changes.
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
42Figure 3-1 shows an example of how the layering of views creates the desired visual effect for an application.
In the case of the Clock application, the view hierarchy is composed of a mixture of views derived from different
sources. The tab bar and navigation views are special view hierarchies provided by the tab bar and navigation
controller objects to manage portions of the overall user interface. Everything between those bars belongs to
the custom view hierarchy that the Clock application provides.
Figure 3-1 Layered views in the Clock application
Window
Tab bar view
Navigation view
Custom view hierarchy
There are several ways to build view hierarchies in iOS applications, including graphically in Interface Builder
and programmatically in your code. The following sections show you how to assemble your view hierarchies
and, having done that, how to find views in the hierarchy and convert between different view coordinate
systems.
Adding and Removing Subviews
Interface Builder is the most convenient way to build view hierarchies because you assemble your views
graphically, see the relationships between the views, and see exactly how those views will appear at runtime.
When using Interface Builder, you save your resulting view hierarchy in a nib file, which you load at runtime as
the corresponding views are needed.
If you prefer to create your views programmatically instead, you create and initialize them and then use the
following methods to arrange them into hierarchies:
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
43● To add a subview to a parent, call the addSubview: method of the parent view. This method adds the
subview to the end of the parent’s list of subviews.
● To insert a subview in the middle of the parent’s list of subviews, call any of the insertSubview:...
methods of the parent view. Inserting a subview in the middle of the list visually places that view behind
any views that come later in the list.
● To reorder existing subviewsinside their parent, callthe bringSubviewToFront:, sendSubviewToBack:,
or exchangeSubviewAtIndex:withSubviewAtIndex: methods of the parent view. Using these
methods is faster than removing the subviews and reinserting them.
● To remove a subview from its parent, call the removeFromSuperview method of the subview (not the
parent view).
When adding a subview to its parent, the subview’s current frame rectangle denotes its initial position inside
the parent view. A subview whose frame lies outside of its superview’s visible bounds is not clipped by default.
If you want yoursubview to be clipped to the superview’s bounds, you must explicitly set the clipsToBounds
property of the superview to YES.
The most common example of adding a subview to another view occurs in the
application:didFinishLaunchingWithOptions: method of almost every application. Listing 3-1 shows
a version of this method that installs the view from the application’s main view controller into the application
window. Both the window and the view controller are stored in the application’s main nib file, which is loaded
before the method is called. However, the view hierarchy managed by the view controller is not actually loaded
until the view property is accessed.
Listing 3-1 Adding a view to a window
- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
// Override point for customization after application launch.
// Add the view controller's view to the window and display.
[window addSubview:viewController.view];
[window makeKeyAndVisible];
return YES;
}
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
44Another common place where you might add subviewsto a view hierarchy isin the loadView or viewDidLoad
methods of a view controller. If you are building your views programmatically, you put your view creation code
in the loadView method of your view controller. Whether you create your views programmatically or load
them from a nib file, you could include additional view configuration code in the viewDidLoad method.
Listing 3-2 showsthe viewDidLoad method of the TransitionsViewController classfrom the UICatalog
sample application. The TransitionsViewController class manages the animations associated with
transitioning between two views. The application’s initial view hierarchy (consisting of a root view and toolbar)
is loaded from a nib file. The code in the viewDidLoad method subsequently creates the container view and
image views used to manage the transitions. The purpose of the container view is to simplify the code needed
to implement the transition animations between the two image views. The container view has no real content
of its own.
Listing 3-2 Adding views to an existing view hierarchy
- (void)viewDidLoad
{
[super viewDidLoad];
self.title = NSLocalizedString(@"TransitionsTitle", @"");
// create the container view which we will use for transition animation (centered
horizontally)
CGRect frame = CGRectMake(round((self.view.bounds.size.width - kImageWidth) /
2.0),
kTopPlacement, kImageWidth,
kImageHeight);
self.containerView = [[[UIView alloc] initWithFrame:frame] autorelease];
[self.view addSubview:self.containerView];
// The container view can represent the images for accessibility.
[self.containerView setIsAccessibilityElement:YES];
[self.containerView setAccessibilityLabel:NSLocalizedString(@"ImagesTitle",
@"")];
// create the initial image view
frame = CGRectMake(0.0, 0.0, kImageWidth, kImageHeight);
self.mainView = [[[UIImageView alloc] initWithFrame:frame] autorelease];
self.mainView.image = [UIImage imageNamed:@"scene1.jpg"];
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
45[self.containerView addSubview:self.mainView];
// create the alternate image view (to transition between)
CGRect imageFrame = CGRectMake(0.0, 0.0, kImageWidth, kImageHeight);
self.flipToView = [[[UIImageView alloc] initWithFrame:imageFrame] autorelease];
self.flipToView.image = [UIImage imageNamed:@"scene2.jpg"];
}
Important: Superviews automatically retain their subviews, so after embedding a subview it is safe to
release that subview. In fact, doing so is recommended because it prevents your application from retaining
the view one time too many and causing a memory leak later. Just remember that if you remove a subview
from its superview and intend to reuse it, you must retain the subview again. The removeFromSuperview
method autoreleases a subview before removing it from its superview. If you do not retain the view before
the next event loop cycle, the view will be released.
Formore information about Cocoamemorymanagement conventions,see AdvancedMemoryManagement
Programming Guide .
When you add a subview to another view, UIKit notifies both the parent and child views of the change. If you
implement custom views, you can intercept these notifications by overriding one or more of the
willMoveToSuperview:, willMoveToWindow:, willRemoveSubview:, didAddSubview:,
didMoveToSuperview, or didMoveToWindow methods. You can use these notifications to update any state
information related to your view hierarchy or to perform additional tasks.
After creating a view hierarchy, you can navigate it programmatically using the superview and subviews
properties of your views. The window property of each view containsthe window in which that view is currently
displayed (if any). Because the root view in a view hierarchy has no parent, its superview property is set to
nil. For views that are currently onscreen, the window object is the root view of the view hierarchy.
Hiding Views
To hide a view visually, you can either set its hidden property to YES or change its alpha property to 0.0. A
hidden view does not receive touch events from the system. However, hidden views do participate in
autoresizing and other layout operations associated with the view hierarchy. Thus, hiding a view is often a
convenient alternative to removing views from your view hierarchy, especially if you plan to show the views
again at some point soon.
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
46Important: If you hide a view that is currently the first responder, the view does not automatically resign
its first responder status. Events targeted at the first responder are still delivered to the hidden view. To
prevent this from happening, you should force your view to resign the first responder status when you hide
it. For more information about the responder chain, see Event Handling Guide for iOS .
If you want to animate a view’s transition from visible to hidden (or the reverse), you must do so using the
view’s alpha property. The hidden property is not an animatable property, so any changes you make to it
take effect immediately.
Locating Views in a View Hierarchy
There are two ways to locate views in a view hierarchy:
● Store pointers to any relevant views in an appropriate location, such as in the view controller that owns
the views.
● Assign a unique integer to each view’s tag property and use the viewWithTag: method to locate it.
Storing references to relevant views is the most common approach to locating views and makes accessing
those views very convenient. If you used Interface Builder to create your views, you can connect objects in
your nib file (including the File’s Owner object that represents the managing controller object) to one another
using outlets. For views you create programmatically, you can store referencesto those viewsin private member
variables. Whether you use outlets or private member variables, you are responsible for retaining the views as
needed and then releasing them as well. The best way to ensure objects are retained and released properly is
to use declared properties.
Tags are a useful way to reduce hard-coded dependencies and support more dynamic and flexible solutions.
Rather than storing a pointer to a view, you could locate it using its tag. Tags are also a more persistent way
of referring to views. For example, if you wanted to save the list of views that are currently visible in your
application, you would write out the tags of each visible view to a file. This is simpler than archiving the actual
view objects, especially in situations where you are tracking only which views are currently visible. When your
application is subsequently loaded, you would then re-create your views and use the saved list of tags to set
the visibility of each view, and thereby return your view hierarchy to its previous state.
Translating, Scaling, and Rotating Views
Every view has an associated affine transform that you can use to translate, scale, or rotate the view’s content.
View transforms alter the final rendered appearance of the view and are often used to implement scrolling,
animations, or other visual effects.
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
47The transform property of UIView contains a CGAffineTransform structure with the transformations to
apply. By default, this property is set to the identity transform, which does not modify the appearance of the
view. You can assign a new transform to this property at any time. For example, to rotate a view by 45 degrees,
you could use the following code:
// M_PI/4.0 is one quarter of a half circle, or 45 degrees.
CGAffineTransform xform = CGAffineTransformMakeRotation(M_PI/4.0);
self.view.transform = xform;
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
48Applying the transform in the preceding code to a view would rotate that view clockwise about its center
point. Figure 3-2 shows how this transformation would look if it were applied to an image view embedded in
an application.
Figure 3-2 Rotating a view 45 degrees
Unrotated Rotated 45˚
When applying multiple transformations to a view, the order in which you add those transformations to the
CGAffineTransform structure is significant. Rotating the view and then translating it is not the same as
translating the view and then rotating it. Even if the amounts of rotation and translation are the same in each
case, the sequence of the transformations affects the final results. In addition, any transformations you add
are applied to the view relative to its center point. Thus, applying a rotation factor rotates the view around its
center point. Scaling a view changes the width and height of the view but does not change its center point.
For more information about creating and using affine transforms, see “Transforms” in Quartz 2D Programming
Guide .
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
49Converting Coordinates in the View Hierarchy
At various times, particularly when handling events, an application may need to convert coordinate values
from one frame of reference to another. For example, touch events report the location of each touch in the
window’s coordinate system but view objects often need that information in the view’slocal coordinate system.
The UIView class defines the following methods for converting coordinates to and from the view’s local
coordinate system:
convertPoint:fromView:
convertRect:fromView:
convertPoint:toView:
convertRect:toView:
The convert...:fromView: methods convert coordinates from some other view’s coordinate system to
the local coordinate system (bounds rectangle) of the current view. Conversely, the convert...:toView:
methods convert coordinates from the current view’s local coordinate system (bounds rectangle) to the
coordinate system of the specified view. If you specify nil as the reference view for any of the methods, the
conversions are made to and from the coordinate system of the window that contains the view.
In addition to the UIView conversion methods, the UIWindow class also defines several conversion methods.
These methods are similar to the UIView versions except that instead of converting to and from a view’s local
coordinate system, these methods convert to and from the window’s coordinate system.
convertPoint:fromWindow:
convertRect:fromWindow:
convertPoint:toWindow:
convertRect:toWindow:
When converting coordinates in rotated views, UIKit converts rectangles under the assumption that you want
the returned rectangle to reflect the screen area covered by the source rectangle. Figure 3-3 shows an example
of how rotations can cause the size of the rectangle to change during a conversion. In the figure, an outer
Views
Creating and Managing a View Hierarchy
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
50parent view contains a rotated subview. Converting a rectangle in the subview’s coordinate system to the
parent’s coordinate system yields a rectangle that is physically larger. This larger rectangle is actually the
smallest rectangle in the bounds of outerView that completely encloses the rotated rectangle.
Figure 3-3 Converting values in a rotated view
Rectangle in
rotatedView
coordinate system
Rectangle converted to
outerView
coordinate system
outerView
superview
subviews
frame
rotatedView
superview
subviews
frame
Adjusting the Size and Position of Views at Runtime
Whenever the size of a view changes, the size and position of its subviews must change accordingly. The
UIView class supports both the automatic and manual layout of views in a view hierarchy. With automatic
layout, you set the rules that each view should follow when its parent view resizes, and then forget about
resizing operations altogether. With manual layout, you manually adjust the size and position of views as
needed.
Being Prepared for Layout Changes
Layout changes can occur whenever any of the following events happens in a view:
● The size of a view’s bounds rectangle changes.
● An interface orientation change occurs, which usually triggers a change in the root view’s boundsrectangle.
● The set of Core Animation sublayers associated with the view’s layer changes and requires layout.
● Your application forces layout to occur by calling the setNeedsLayout or layoutIfNeeded method of
a view.
● Your application forces layout by calling the setNeedsLayout method of the view’s underlying layer
object.
Views
Adjusting the Size and Position of Views at Runtime
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
51Handling Layout Changes Automatically Using Autoresizing Rules
When you change the size of a view, the position and size of any embedded subviews usually needs to change
to account for the new size of their parent. The autoresizesSubviews property of the superview determines
whether the subviewsresize at all. If this property isset to YES, the view usesthe autoresizingMask property
of each subview to determine how to size and position that subview. Size changes to any subviews trigger
similar layout adjustments for their embedded subviews.
For each view in your view hierarchy,setting that view’s autoresizingMask property to an appropriate value
is an important part of handling automatic layout changes. Table 3-2 lists the autoresizing options you can
apply to a given view and describes their effects during layout operations. You can combine constants using
an OR operator or just add them together before assigning them to the autoresizingMask property. If you
are using Interface Builder to assemble your views, you use the Autosizing inspector to set these properties.
Table 3-2 Autoresizing mask constants
Autoresizing mask Description
UIViewAutoresizingNone The view does not autoresize. (This is the default value.)
The view’s height changes when the superview’s height changes.
If this constant is not included, the view’s height does not change.
UIViewAutoresizingFlexibleHeight
The view’s width changes when the superview's width changes. If
this constant is not included, the view’s width does not change.
UIViewAutoresizingFlexibleWidth
The distance between the view’s left edge and the superview’s left
edge grows or shrinks as needed. If this constant is not included,
the view’s left edge remains a fixed distance from the left edge of
the superview.
UIViewAutoresizingFlexibleLeftMargin
The distance between the view’s right edge and the superview’s
right edge grows or shrinks as needed. If this constant is not
included, the view’s right edge remains a fixed distance from the
right edge of the superview.
UIViewAutoresizingFlexibleRightMargin
The distance between the view’s bottom edge and the superview’s
bottom edge grows or shrinks as needed. If this constant is not
included, the view’s bottom edge remains a fixed distance from the
bottom edge of the superview.
UIViewAutoresizingFlexibleBottomMargin
The distance between the view’s top edge and the superview’s top
edge grows or shrinks as needed. If this constant is not included,
the view’s top edge remains a fixed distance from the top edge of
the superview.
UIViewAutoresizingFlexibleTopMargin
Views
Adjusting the Size and Position of Views at Runtime
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
52Figure 3-4 shows a graphical representation of how the options in the autoresizing mask apply to a view. The
presence of a given constant indicates that the specified aspect of the view is flexible and may change when
the superview’s bounds change. The absence of a constant indicates that the view’s layout is fixed in that
aspect. When you configure a view that has more than one flexible attribute along a single axis, UIKit distributes
any size changes evenly among the corresponding spaces.
Figure 3-4 View autoresizing mask constants
UIViewAutoresizingFlexibleWidth
UIViewAutoresizingFlexibleRightMargin
UIViewAutoresizingFlexibleBottomMargin
UIViewAutoresizingFlexibleHeight
Superview
View
UIViewAutoresizingFlexibleTopMargin
UIViewAutoresizingFlexibleLeftMargin
The easiest way to configure autoresizing rulesis using the Autosizing controlsin the Size inspector of Interface
Builder. The flexible width and height constants from the preceding figure have the same behavior as the
width and size indicatorsin the Autosizing controls diagram. However, the behavior and use of margin indicators
is effectively reversed. In Interface Builder, the presence of a margin indicator means that the margin has a
fixed size and the absence of the indicator means the margin has a flexible size. Fortunately, Interface Builder
provides an animation to show you how changes to the autoresizing behaviors affect your view.
Important: If a view’s transform property does not contain the identity transform, the frame of that view
is undefined and so are the results of its autoresizing behaviors.
After the automatic autoresizing rules for all affected views have been applied, UIKit goes back and gives each
view a chance to make any necessary manual adjustments to its superview. For more information about how
to manage the layout of views manually, see “Tweaking the Layout of Your Views Manually” (page 54).
Views
Adjusting the Size and Position of Views at Runtime
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
53Tweaking the Layout of Your Views Manually
Whenever the size of a view changes, UIKit appliesthe autoresizing behaviors of that view’ssubviews and then
calls the layoutSubviews method of the view to let it make manual changes. You can implement the
layoutSubviews method in custom views when the autoresizing behaviors by themselves do not yield the
results you want. Your implementation of this method can do any of the following:
● Adjust the size and position of any immediate subviews.
● Add or remove subviews or Core Animation layers.
● Force a subview to be redrawn by calling its setNeedsDisplay or setNeedsDisplayInRect: method.
One place where applications often lay out subviews manually is when implementing a large scrollable area.
Because it is impractical to have a single large view for its scrollable content, applications often implement a
root view that contains a number of smaller tile views. Each tile represents a portion of the scrollable content.
When a scroll event happens, the root view calls its setNeedsLayout method to initiate a layout change. Its
layoutSubviews method then repositions the tile views based on the amount of scrolling that occurred. As
tiles scroll out of the view’s visible area, the layoutSubviews method moves the tiles to the incoming edge,
replacing their contents in the process.
When writing your layout code, be sure to test your code in the following ways:
● Change the orientation of your views to make sure the layout looks correct in all supported interface
orientations.
● Make sure your code responds appropriately to changes in the height of the status bar. When a phone
call is active, the status bar height increasesin size, and when the user endsthe call, the status bar decreases
in size.
For information about how autoresizing behaviors affect the size and position of your views, see “Handling
Layout Changes Automatically Using Autoresizing Rules” (page 52). For an example of how to implement
tiling, see the ScrollViewSuite sample.
Modifying Views at Runtime
As applications receive input from the user, they adjust their user interface in response to that input. An
application might modify its views by rearranging them, changing their size or position, hiding or showing
them, or loading an entirely new set of views. In iOS applications, there are several places and ways in which
you perform these kinds of actions:
●
In a view controller:
Views
Modifying Views at Runtime
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
54● A view controller has to create its views before showing them. It can load the views from a nib file or
create them programmatically. When those views are no longer needed, it disposes of them.
● When a device changes orientations, a view controller might adjust the size and position of views to
match. As part of its adjustment to the new orientation, it might hide some views and show others.
● When a view controller manages editable content, it might adjust its view hierarchy when moving to
and from edit mode. For example, it might add extra buttons and other controls to facilitate editing
various aspects of its content. This might also require the resizing of any existing viewsto accommodate
the extra controls.
●
In animation blocks:
● When you want to transition between different sets of views in your user interface, you hide some
views and show others from inside an animation block.
● When implementing special effects, you might use an animation block to modify various properties
of the view. For example, to animate changes to the size of a view, you would change the size of its
frame rectangle.
● Other ways:
● When touch events or gestures occur, your interface might respond by loading a new set of views or
changing the current set of views. For information about handling events, see Event Handling Guide
for iOS .
● When the user interacts with a scroll view, a large scrollable area might hide and show tile subviews.
For more information about supporting scrollable content, see Scroll View Programming Guide for
iOS .
● When the keyboard appears, you might reposition or resize views so that they do not lie underneath
the keyboard. For information about how to interact with the keyboard, see Text, Web, and Editing
Programming Guide for iOS .
View controllers are a common place to initiate changes to your views. Because a view controller manages the
view hierarchy associated with the content being displayed, it is ultimately responsible for everything that
happens to those views. When loading its views or handling orientation changes, the view controller can add
new views, hide or replace existing ones, and make any number of changes to make the views ready for the
display. And if you implement support for editing your view’s content, the setEditing:animated: method
in UIViewController gives you a place to transition your views to and from their editable versions.
Animation blocks are another common place to initiate view-related changes. The animation support built
into the UIView class makes it easy to animate changes to view properties. You can also use the
transitionWithView:duration:options:animations:completion: or
transitionFromView:toView:duration:options:completion: methods to swap out entire sets of
views for new ones.
Views
Modifying Views at Runtime
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
55For more information about animating views and initiating view transitions, see “Animations” (page 64). For
more information on how you use view controllers to manage view-related behaviors, see View Controller
Programming Guide for iOS .
Interacting with Core Animation Layers
Each view object has a dedicated Core Animation layer that manages the presentation and animation of the
view’s content on the screen. Although you can do a lot with your view objects, you can also work directly
with the corresponding layer objects as needed. The layer object for the view is stored in the view’s layer
property.
Changing the Layer Class Associated with a View
The type of layer associated with a view cannot be changed after the view is created. Therefore, each view
uses the layerClass class method to specify the class of its layer object. The default implementation of this
method returns the CALayer class and the only way to change this value is to subclass, override the method,
and return a different value. You might want to change this value in the following circumstances:
● Your application uses OpenGL ES for drawing, in which case, the layer must be an instance of the
CAEAGLLayer class.
● Your view uses tiling to display a large scrollable area, in which case you might want to use the
CATiledLayer class to back your view instead.
Implementation of the layerClass method should simply create the desired Class object and return it. For
example, a view that supports OpenGL ES drawing would have the following implementation for this method:
+ (Class)layerClass
{
return [CAEAGLLayer class];
}
Each view calls its layerClass method early in its initialization process and uses the returned class to create
its layer object. In addition, the view always assigns itself as the delegate of its layer object. At this point, the
view ownsitslayer and the relationship between the view and layer must not change. You must also not assign
the same view as the delegate of any other layer object. Changing the ownership or delegate relationships of
the view will cause drawing problems and potential crashes in your application.
Views
Interacting with Core Animation Layers
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
56For more information about the different types of layer objects provided by Core Animation,see Core Animation
Reference Collection .
Embedding Layer Objects in a View
If you prefer to work primarily with layer objects instead of views, you can incorporate custom layer objects
into your view hierarchy as needed. A custom layer object is any instance of CALayer that is not owned by a
view. You typically create custom layers programmatically and incorporate them using Core Animation routines.
Custom layers do not receive events or participate in the responder chain but do draw themselves and respond
to size changes in their parent view or layer according to the Core Animation rules.
Listing 3-3 shows an example of the viewDidLoad method from a view controller that creates a custom layer
object and addsit to itsroot view. The layer is used to display a static image that is animated. Instead of adding
the layer to the view itself, you add it to the view’s underlying layer.
Listing 3-3 Adding a custom layer to a view
- (void)viewDidLoad {
[super viewDidLoad];
// Create the layer.
CALayer* myLayer = [[CALayer alloc] init];
// Set the contents of the layer to a fixed image. And set
// the size of the layer to match the image size.
UIImage layerContents = [[UIImage imageNamed:@"myImage"] retain];
CGSize imageSize = layerContents.size;
myLayer.bounds = CGRectMake(0, 0, imageSize.width, imageSize.height);
myLayer = layerContents.CGImage;
// Add the layer to the view.
CALayer* viewLayer = self.view.layer;
[viewLayer addSublayer:myLayer];
// Center the layer in the view.
CGRect viewBounds = backingView.bounds;
Views
Interacting with Core Animation Layers
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
57myLayer.position = CGPointMake(CGRectGetMidX(viewBounds),
CGRectGetMidY(viewBounds));
// Release the layer, since it is retained by the view's layer
[myLayer release];
}
You can add any number of sublayers and arrange them into sublayer hierarchies, if you want. However, at
some point, those layers must be attached to the layer object of a view.
For information on how to work with layers directly, see Core Animation Programming Guide .
Defining a Custom View
If the standard system views do not do exactly what you need, you can define a custom view. Custom views
give you total control over the appearance of your application’s content and how interactions with that content
are handled.
Checklist for Implementing a Custom View
The job of a custom view is to present content and manage interactions with that content. The successful
implementation of a custom view involves more than just drawing and handling events, though. The following
checklist includes the more important methods you can override (and behaviors you can provide) when
implementing a custom view:
● Define the appropriate initialization methods for your view:
● For views you plan to create programmatically, override the initWithFrame: method or define a
custom initialization method.
● For views you plan to load from nib files, override the initWithCoder: method. Use this method
to initialize your view and put it into a known state.
●
Implement a dealloc method to handle the cleanup of any custom data.
● To handle any custom drawing, override the drawRect: method and do your drawing there.
● Set the autoresizingMask property of the view to define its autoresizing behavior.
●
If your view class manages one or more integral subviews, do the following:
● Create those subviews during your view’s initialization sequence.
● Set the autoresizingMask property of each subview at creation time.
Views
Defining a Custom View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
58●
If your subviews require custom layout, override the layoutSubviews method and implement your
layout code there.
● To handle touch-based events, do the following:
● Attach any suitable gesture recognizersto the view by using the addGestureRecognizer: method.
● For situations where you want to process the touches yourself, override the
touchesBegan:withEvent:, touchesMoved:withEvent:, touchesEnded:withEvent:, and
touchesCancelled:withEvent: methods. (Remember that you should always override the
touchesCancelled:withEvent: method, regardless of which other touch-related methods you
override.)
●
If you want the printed version of your view to look different from the onscreen version, implement the
drawRect:forViewPrintFormatter: method. For detailed information about how to support printing
in your views, see Drawing and Printing Guide for iOS .
In addition to overriding methods, remember that there is a lot you can do with the view’s existing properties
and methods. For example, the contentMode and contentStretch properties let you change the final
rendered appearance of your view and might be preferable to redrawing the content yourself. In addition to
the UIView class itself, there are many aspects of a view’s underlying CALayer object that you can configure
directly or indirectly. You can even change the class of the layer object itself (which you must do if you plan
to use OpenGL ES to draw your view’s content).
For more information about the methods and properties of the view class, see UIView Class Reference .
Initializing Your Custom View
Every new view object you define should include a custom initWithFrame: initializer method. This method
is responsible for initializing the class at creation time and putting your view object into a known state. You
use this method when creating instances of your view programmatically in your code.
Listing 3-4 shows a skeletal implementation of a standard initWithFrame: method. This method calls the
inherited implementation of the method first and then initializes the instance variables and state information
of the class before returning the initialized object. Calling the inherited implementation istraditionally performed
first so that if there is a problem, you can abort your own initialization code and return nil.
Listing 3-4 Initializing a view subclass
- (id)initWithFrame:(CGRect)aRect {
self = [super initWithFrame:aRect];
if (self) {
// setup the initial properties of the view
Views
Defining a Custom View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
59...
}
return self;
}
If you plan to load instances of your custom view class from a nib file, you should be aware that in iOS, the
nib-loading code does not use the initWithFrame: method to instantiate new view objects. Instead, it uses
the initWithCoder: method that is part of the NSCoding protocol.
Even if your view adopts the NSCoding protocol, Interface Builder does not know about your view’s custom
properties and therefore does not encode those properties into the nib file. As a result, your own
initWithCoder: method should perform whatever initialization code it can to put the view into a known
state. You can also implement the awakeFromNib method in your view class and use that method to perform
additional initialization.
Implementing Your Drawing Code
For viewsthat need to do custom drawing, you need to override the drawRect: method and do your drawing
there. Custom drawing is recommended only as a last resort. In general, if you can use other views to present
your content, that is preferred.
The implementation of your drawRect: method should do exactly one thing: draw your content. This method
is not the place to be updating your application’s data structures or performing any tasks not related to drawing.
It should configure the drawing environment, draw your content, and exit as quickly as possible. And if your
drawRect: method might be called frequently, you should do everything you can to optimize your drawing
code and draw as little as possible each time the method is called.
Before calling your view’s drawRect: method, UIKit configures the basic drawing environment for your view.
Specifically, it creates a graphics context and adjusts the coordinate system and clipping region to match the
coordinate system and visible bounds of your view. Thus, by the time your drawRect: method is called, you
can begin drawing your content using native drawing technologies such as UIKit and Core Graphics. You can
get a pointer to the current graphics context using the UIGraphicsGetCurrentContext function.
Views
Defining a Custom View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
60Important: The current graphics context is valid only for the duration of one call to your view’s drawRect:
method. UIKit might create a different graphics context for each subsequent call to this method, so you
should not try to cache the object and use it later.
Listing 3-5 shows a simple implementation of a drawRect: method that draws a 10-pixel-wide red border
around the view. Because UIKit drawing operations use Core Graphics for their underlying implementations,
you can mix drawing calls, as shown here, to get the results you expect.
Listing 3-5 A drawing method
- (void)drawRect:(CGRect)rect {
CGContextRef context = UIGraphicsGetCurrentContext();
CGRect myFrame = self.bounds;
// Set the line width to 10 and inset the rectangle by
// 5 pixels on all sides to compensate for the wider line.
CGContextSetLineWidth(context, 10);
CGRectInset(myFrame, 5, 5);
[[UIColor redColor] set];
UIRectFrame(myFrame);
}
If you know that your view’s drawing code always covers the entire surface of the view with opaque content,
you can improve system performance by setting the opaque property of your view to YES. When you mark a
view as opaque, UIKit avoids drawing content that is located immediately behind your view. This not only
reduces the amount of time spent drawing but also minimizes the work that must be done to composite your
view with other content. However, you should set this property to YES only if you know your view’s content
is completely opaque. If your view cannot guarantee that its contents are always opaque, you should set the
property to NO.
Another way to improve drawing performance, especially during scrolling, is to set the
clearsContextBeforeDrawing property of your view to NO. When this property is set to YES, UIKIt
automatically fills the area to be updated by your drawRect: method with transparent black before calling
your method. Setting this property to NO eliminates the overhead for that fill operation but puts the burden
on your application to fill the update rectangle passed to your drawRect: method with content.
Views
Defining a Custom View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
61Responding to Events
View objects are responder objects—instances of the UIResponder class—and are therefore capable of receiving
touch events. When a touch event occurs, the window dispatches the corresponding event object to the view
in which the touch occurred. If your view is not interested in an event, it can ignore it or passit up the responder
chain to be handled by a different object.
In addition to handling touch events directly, views can also use gesture recognizers to detect taps, swipes,
pinches, and other types of common touch-related gestures. Gesture recognizers do the hard work of tracking
touch events and making sure that they follow the right criteria to qualify them as the target gesture. Instead
of your application having to track touch events, you can create the gesture recognizer, assign an appropriate
target object and action method to it, and install it on your view using the addGestureRecognizer: method.
The gesture recognizer then calls your action method when the corresponding gesture occurs.
If you prefer to handle touch events directly, you can implement the following methods for your view, which
are described in more detail in Event Handling Guide for iOS :
touchesBegan:withEvent:
touchesMoved:withEvent:
touchesEnded:withEvent:
touchesCancelled:withEvent:
The default behavior for views is to respond to only one touch at a time. If the user puts a second finger down,
the system ignoresthe touch event and does not report it to your view. If you plan to track multifinger gestures
from your view’s event-handler methods, you need to enable multitouch events by setting the
multipleTouchEnabled property of your view to YES.
Some views, such as labels and images, disable event handling altogether initially. You can control whether a
view is able to receive touch events by changing the value of the view’s userInteractionEnabled property.
You might temporarily set this property to NO to prevent the user from manipulating the contents of your view
while a long operation is pending. To prevent events from reaching any of your views, you can also use the
beginIgnoringInteractionEvents and endIgnoringInteractionEvents methods of the
UIApplication object. These methods affect the delivery of events for the entire application, not just for a
single view.
Views
Defining a Custom View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
62Note: The animation methods of UIView typically disable touch events while animations are in
progress. You can override this behavior by configuring the animation appropriately. For more
information about performing animations, see “Animations” (page 64).
As it handles touch events, UIKit uses the hitTest:withEvent: and pointInside:withEvent: methods
of UIView to determine whether a touch event occurred inside a given view’s bounds. Although you rarely
need to override these methods, you could do so to implement custom touch behaviors for your view. For
example, you could override these methods to prevent subviews from handling touch events.
Cleaning Up After Your View
If your view class allocates any memory, stores references to any custom objects, or holds resources that must
be released when the view is released, you must implement a dealloc method. The system calls the dealloc
method when your view’s retain count reaches zero and it is time to deallocate the view. Your implementation
of this method should release any objects or resources held by the view and then call the inherited
implementation, as shown in Listing 3-6. You should not use this method to perform any other types of tasks.
Listing 3-6 Implementing the dealloc method
- (void)dealloc {
// Release a retained UIColor object
[color release];
// Call the inherited implementation
[super dealloc];
}
Views
Defining a Custom View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
63Animations provide fluid visual transitions between different states of your user interface. In iOS, animations
are used extensively to reposition views, change theirsize, remove them from view hierarchies, and hide them.
You might use animations to convey feedback to the user or to implement interesting visual effects.
In iOS, creating sophisticated animations does not require you to write any drawing code. All of the animation
techniques described in this chapter use the built-in support provided by Core Animation. All you have to do
is trigger the animation and let Core Animation handle the rendering of individual frames. This makes creating
sophisticated animations very easy with only a few lines of code.
What Can Be Animated?
Both UIKit and Core Animation provide support for animations, but the level of support provided by each
technology varies. In UIKit, animations are performed using UIView objects. Views support a basic set of
animations that cover many common tasks. For example, you can animate changes to properties of views or
use transition animations to replace one set of views with another.
Table 4-1 liststhe animatable properties—the propertiesthat have built-in animation support—of the UIView
class. Being animatable does not mean animations happen automatically. Changing the value of these properties
normally just updates the property (and the view) immediately without an animation. To animate such a
change, you must change the property’s value from inside an animation block, which is described in “Animating
Property Changes in a View” (page 66).
Table 4-1 Animatable UIView properties
Property Changes you can make
Modify this property to change the view’s size and position relative to its
superview’s coordinate system. (If the transform property does not contain
the identity transform, modify the bounds or center properties instead.)
frame
bounds Modify this property to change the view’s size.
Modify this property to change the view’s position relative to its superview’s
coordinate system.
center
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
64
AnimationsProperty Changes you can make
Modify this property to scale, rotate, or translate the view relative to its center
point. Transformations using this property are always performed in 2D space.
(To perform 3D transformations, you must animate the view’slayer object using
Core Animation.)
transform
alpha Modify this property to gradually change the transparency of the view.
backgroundColor Modify this property to change the view’s background color.
Modify this property to change the way the view’s contents are stretched to
fill the available space.
contentStretch
Animated view transitions are a way for you to make changes to your view hierarchy beyond those offered by
view controllers. Although you should use view controllers to manage succinct view hierarchies, there may be
times when you want to replace all or part of a view hierarchy. In those situations, you can use view-based
transitions to animate the addition and removal of your views.
In places where you want to perform more sophisticated animations, or animations not supported by the
UIView class, you can use Core Animation and the view’s underlying layer to create the animation. Because
view and layer objects are intricately linked together, changes to a view’s layer affect the view itself. Using
Core Animation, you can animate the following types of changes for your view’s layer:
● The size and position of the layer
● The center point used when performing transformations
● Transformations to the layer or its sublayers in 3D space
● The addition or removal of a layer from the layer hierarchy
● The layer’s Z-order relative to other sibling layers
● The layer’s shadow
● The layer’s border (including whether the layer’s corners are rounded)
● The portion of the layer that stretches during resizing operations
● The layer’s opacity
● The clipping behavior for sublayers that lie outside the layer’s bounds
● The current contents of the layer
● The rasterization behavior of the layer
Animations
What Can Be Animated?
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
65Note: If your view hosts custom layer objects—that is, layer objects without an associated view—you
must use Core Animation to animate any changes to them.
Although this chapter addresses a few Core Animation behaviors, it does so in relation to initiating them from
your view code. For more complete information about how to use Core Animation to animate layers, see Core
Animation Programming Guide and Core Animation Cookbook .
Animating Property Changes in a View
In order to animate changesto a property of the UIView class, you must wrap those changesinside an animation
block. The term animation block is used in the generic sense to refer to any code that designates animatable
changes. In iOS 4 and later, you create an animation block using block objects. In earlier versions of iOS, you
mark the beginning and end of an animation block using special class methods of the UIView class. Both
techniques support the same configuration options and offer the same amount of control over the animation
execution. However, the block-based methods are preferred whenever possible.
The following sections focus on the code you need in order to animate changes to view properties. For
information about how to create animated transitions between sets of views,see “Creating Animated Transitions
Between Views” (page 73).
Starting Animations Using the Block-Based Methods
In iOS 4 and later, you use the block-based class methods to initiate animations. There are several block-based
methods that offer different levels of configuration for the animation block. These methods are:
● animateWithDuration:animations:
● animateWithDuration:animations:completion:
● animateWithDuration:delay:options:animations:completion:
Because these are class methods, the animation blocks you create with them are not tied to a single view. Thus,
you can use these methods to create a single animation that involves changes to multiple views. For example,
Listing 4-1 showsthe code needed to fade in one view while fading out another over a one second time period.
When this code executes, the specified animations are started immediately on another thread so as to avoid
blocking the current thread or your application’s main thread.
Listing 4-1 Performing a simple block-based animation
[UIView animateWithDuration:1.0 animations:^{
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
66firstView.alpha = 0.0;
secondView.alpha = 1.0;
}];
The animations in the preceding example run only once using using an ease-in, ease-out animation curve. If
you want to change the default animation parameters, you must use the
animateWithDuration:delay:options:animations:completion:method to performyour animations.
This method lets you customize the following animation parameters:
● The delay to use before starting the animation
● The type of timing curve to use during the animation
● The number of times the animation should repeat
● Whether the animation should reverse itself automatically when it reaches the end
● Whether touch events are delivered to views while the animations are in progress
● Whether the animation should interrupt any in-progress animations or wait until those are complete before
starting
Another thing that both the animateWithDuration:animations:completion: and
animateWithDuration:delay:options:animations:completion: methods support is the ability to
specify a completion handler block. You might use a completion handler to signal your application that a
specific animation has finished. Completion handlers are also the way to link separate animations together.
Listing 4-2 shows an example of an animation block that uses a completion handler to initiate a new animation
after the first one finishes. The first call to
animateWithDuration:delay:options:animations:completion: sets up a fade-out animation and
configures it with some custom options. When that animation is complete, its completion handler runs and
sets up the second half of the animation, which fades the view back in after a delay.
Using a completion handler is the primary way that you link multiple animations.
Listing 4-2 Creating an animation block with custom options
- (IBAction)showHideView:(id)sender
{
// Fade out the view right away
[UIView animateWithDuration:1.0
delay: 0.0
options: UIViewAnimationOptionCurveEaseIn
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
67animations:^{
thirdView.alpha = 0.0;
}
completion:^(BOOL finished){
// Wait one second and then fade in the view
[UIView animateWithDuration:1.0
delay: 1.0
options:UIViewAnimationOptionCurveEaseOut
animations:^{
thirdView.alpha = 1.0;
}
completion:nil];
}];
}
Important: Changing the value of a property while an animation involving that property is already in
progress does not stop the current animation. Instead, the current animation continues and animates to
the new value you just assigned to the property.
Starting Animations Using the Begin/Commit Methods
If your application runs in iOS 3.2 and earlier, you must use the beginAnimations:context: and
commitAnimations class methods of UIView to define your animation blocks. These methods mark the
beginning and end of your animation block. Any animatable properties you change between these methods
are animated to their new values after you call the commitAnimations method. Execution of the animations
occurs on a secondary thread so as to avoid blocking the current thread or your application’s main thread.
Note: If you are writing an application for iOS 4 or later, you should use the block-based methods
for animating your content instead. For information on how to use those methods, see “Starting
Animations Using the Block-Based Methods” (page 66).
Listing 4-3 shows the code needed to implement the same behavior as Listing 4-1 (page 66) but using the
begin/commit methods. Asin Listing 4-1, this code fades one view out while fading another in over one second
of time. However, in this example, you must set the duration of the animation using a separate method call.
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
68Listing 4-3 Performing a simple begin/commit animation
[UIView beginAnimations:@"ToggleViews" context:nil];
[UIView setAnimationDuration:1.0];
// Make the animatable changes.
firstView.alpha = 0.0;
secondView.alpha = 1.0;
// Commit the changes and perform the animation.
[UIView commitAnimations];
By default, all animatable property changes within an animation block are animated. If you want to animate
some changes but not others, use the setAnimationsEnabled: method to disable animations temporarily,
make any changesthat you do not want animated, and then call setAnimationsEnabled: again to reenable
animations. You can determine if animations are current enabled by calling the areAnimationsEnabled
class method.
Note: Changing the value of a property while an animation involving that property is in progress
does not stop the current animation. Instead, the animation continues and animates to the new
value you just assigned to the property.
Configuring the Parameters for Begin/Commit Animations
To configure the animation parameters for a begin/commit animation block, you use any of several UIView
class methods. Table 4-2 lists these methods and describes how you use them to configure your animations.
Most of these methods should be called only from inside a begin/commit animation block but some may also
be used with block-based animations. If you do not call one of these methods from your animation block, a
default value for the corresponding attribute is used. For more information about the default value associated
with each method, see the method description in UIView Class Reference .
Table 4-2 Methods for configuring animation blocks
Method Usage
Use either of these methodsto specify when the executionsshould
begin executing. If the specified start date is in the past (or the
delay is 0), the animations begin as soon as possible.
setAnimationStartDate:
setAnimationDelay:
Use this method to set the period of time over which to execute
the animations.
setAnimationDuration:
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
69Method Usage
Use this method to set the timing curve of the animations. This
controls whether animations execute linearly or change speed at
certain times.
setAnimationCurve:
Use these methods to set the number of times the animation
repeats and whether the animation runs in reverse at the end of
each complete cycle. For more information about using these
methods, see “Implementing Animations That Reverse
Themselves” (page 73).
setAnimationRepeatCount:
setAnimationRepeatAutoreverses:
Use these methods to execute code immediately before or after
the animations. For more information about using a delegate,see
“Configuring an Animation Delegate” (page 71).
setAnimationDelegate:
setAnimationWillStartSelector:
setAnimationDidStopSelector:
Use this method to stop all previous animations immediately and
start the new animations from the stopping point. If you pass NO
to this method, instead of YES, the new animations do not begin
executing until the previous animations stop.
setAnimationBeginsFromCurrentState:
Listing 4-4 shows the code needed to implement the same behavior as the code in Listing 4-2 (page 67) but
using the begin/commit methods. As before, this code fades out a view, waits one second, and then fades it
back in. In order to implement the second part of the animation, the code sets up an animation delegate and
implements a did-stop handler method. That handler method then sets up the second half of the animations
and runs them.
Listing 4-4 Configuring animation parameters using the begin/commit methods
// This method begins the first animation.
- (IBAction)showHideView:(id)sender
{
[UIView beginAnimations:@"ShowHideView" context:nil];
[UIView setAnimationCurve:UIViewAnimationCurveEaseIn];
[UIView setAnimationDuration:1.0];
[UIView setAnimationDelegate:self];
[UIView
setAnimationDidStopSelector:@selector(showHideDidStop:finished:context:)];
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
70// Make the animatable changes.
thirdView.alpha = 0.0;
// Commit the changes and perform the animation.
[UIView commitAnimations];
}
// Called at the end of the preceding animation.
- (void)showHideDidStop:(NSString *)animationID finished:(NSNumber *)finished
context:(void *)context
{
[UIView beginAnimations:@"ShowHideView2" context:nil];
[UIView setAnimationCurve:UIViewAnimationCurveEaseOut];
[UIView setAnimationDuration:1.0];
[UIView setAnimationDelay:1.0];
thirdView.alpha = 1.0;
[UIView commitAnimations];
}
Configuring an Animation Delegate
If you want to execute code immediately before or after an animation, you must associate a delegate object
and a start or stop selector with your begin/commit animation block. You set your delegate object using the
setAnimationDelegate: class method of UIView and you set your start and stop selectors using the
setAnimationWillStartSelector: and setAnimationDidStopSelector: class methods. During the
animation, the animation system calls your delegate methods at the appropriate times to give you a chance
to perform your code.
The signatures of your animation delegate methods need to be similar to the following:
- (void)animationWillStart:(NSString *)animationID context:(void *)context;
- (void)animationDidStop:(NSString *)animationID finished:(NSNumber *)finished
context:(void *)context;
The animationID and context parameters for both methods are the same parameters that you passed to
the beginAnimations:context: method at the beginning of the animation block:
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
71● animationID—An application-supplied string used to identify the animation.
● context—An application-supplied object that you can use to pass additional information to the delegate.
The setAnimationDidStopSelector: selector method has an additional parameter—a Boolean value that
is YES if the animation ran to completion. If the value of this parameter is NO, the animation was either canceled
or stopped prematurely by another animation.
Note: Although animation delegates can be used in the block-based methods, there is generally
no need to use them there. Instead, place any code you want to run before the animations at the
beginning of your block and place any code you want to run after the animationsfinish in a completion
handler.
Nesting Animation Blocks
You can assign different timing and configuration options to parts of an animation block by nesting additional
animation blocks. As the name implies, a nested animation block is a new animation block created inside an
existing animation block. Nested animations are started at the same time as any parent animations but run
(for the most part) with their own configuration options. By default, nested animations do inherit the parent’s
duration and animation curve but even those options can be overridden as needed.
Listing 4-5 shows an example of how a nested animation is used to change the timing, duration, and behavior
of some animations in the overall group. In this case, two views are being faded to total transparency, but the
transparency of the anotherView object is changed back and forth several times before it is finally hidden.
The UIViewAnimationOptionOverrideInheritedCurve and
UIViewAnimationOptionOverrideInheritedDuration keys used in the nested animation block allow
the curve and duration values from the first animation to be modified for the second animation. If these keys
were not present, the duration and curve of the outer animation block would be used instead.
Listing 4-5 Nesting animations that have different configurations
[UIView animateWithDuration:1.0
delay: 1.0
options:UIViewAnimationOptionCurveEaseOut
animations:^{
aView.alpha = 0.0;
// Create a nested animation that has a different
// duration, timing curve, and configuration.
Animations
Animating Property Changes in a View
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
72[UIView animateWithDuration:0.2
delay:0.0
options: UIViewAnimationOptionOverrideInheritedCurve |
UIViewAnimationOptionCurveLinear |
UIViewAnimationOptionOverrideInheritedDuration |
UIViewAnimationOptionRepeat |
UIViewAnimationOptionAutoreverse
animations:^{
[UIView setAnimationRepeatCount:2.5];
anotherView.alpha = 0.0;
}
completion:nil];
}
completion:nil];
If you are using the begin/commit methods to create your animations, nesting works in much the same way
as with the block-based methods. Each successive call to beginAnimations:context: within an already
open animation block creates a new nested animation block that you can configure as needed. Any configuration
changes you make apply to the most recently opened animation block. All animation blocks must be closed
with a call to commitAnimations before the animations are submitted and executed.
Implementing Animations That Reverse Themselves
When creating reversible animations in conjunction with a repeat count, consider specifying a non integer
value for the repeat count. For an autoreversing animation, each complete cycle of the animation involves
animating from the original value to the new value and back again. If you want your animation to end on the
new value, adding 0.5 to the repeat count causes the animation to complete the extra half cycle needed to
end at the new value. If you do not include this half step, your animation will animate to the original value and
then snap quickly to the new value, which may not be the visual effect you want.
Creating Animated Transitions Between Views
View transitions help you hide sudden changes associated with adding, removing, hiding, or showing views
in your view hierarchy. You use view transitions to implement the following types of changes:
Animations
Creating Animated Transitions Between Views
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
73● Change the visible subviews of an existing view. You typically choose this option when you want to
make relatively small changes to an existing view.
● Replace one view in your view hierarchy with a different view. You typically choose this option when
you want to replace a view hierarchy that spans all or most of the screen.
Important: View transitions should not be confused with transitions initiated by view controllers, such as
the presentation of modal view controllers or the pushing of new view controllers onto a navigation stack.
View transitions affect the view hierarchy only, whereas view-controller transitions change the active view
controller as well. Thus, for view transitions, the view controller that was active when you initiated the
transition remains active when the transition finishes.
For more information about how you can use view controllers to present new content, see View Controller
Programming Guide for iOS .
Changing the Subviews of a View
Changing the subviews of a view allows you to make moderate changes to the view. For example, you might
add or remove subviews to toggle the superview between two different states. By the time the animations
finish, the same view is displayed but its contents are now different.
In iOS 4 and later, you use the transitionWithView:duration:options:animations:completion:
method to initiate a transition animation for a view. In the animations block passed to this method, the only
changesthat are normally animated are those associated with showing, hiding, adding, or removing subviews.
Limiting animations to this set allows the view to create a snapshot image of the before and after versions of
the view and animate between the two images, which is more efficient. However, if you need to animate other
changes, you can include the UIViewAnimationOptionAllowAnimatedContent option when calling the
method. Including that option prevents the view from creating snapshots and animates all changes directly.
Listing 4-6 is an example of how to use a transition animation to make it seem as if a new text entry page has
been added. In this example, the main view contains two embedded text views. The text views are configured
identically, but one is always visible while the other is always hidden. When the user taps the button to create
a new page, this method toggles the visibility of the two views, resulting in a new empty page with an empty
text view ready to accept text. After the transition is complete, the view saves the text from the old page using
a private method and resets the now hidden text view so that it can be reused later. The view then arranges
its pointers so that it can be ready to do the same thing if the user requests yet another new page.
Listing 4-6 Swapping an empty text view for an existing one
- (IBAction)displayNewPage:(id)sender
{
Animations
Creating Animated Transitions Between Views
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
74[UIView transitionWithView:self.view
duration:1.0
options:UIViewAnimationOptionTransitionCurlUp
animations:^{
currentTextView.hidden = YES;
swapTextView.hidden = NO;
}
completion:^(BOOL finished){
// Save the old text and then swap the views.
[self saveNotes:temp];
UIView* temp = currentTextView;
currentTextView = swapTextView;
swapTextView = temp;
}];
}
If you need to perform view transitions in iOS 3.2 and earlier, you can use the
setAnimationTransition:forView:cache: method to specify the parameters for the transition. The
view you pass to that method is the same one you would pass in as the first parameter to the
transitionWithView:duration:options:animations:completion: method. Listing 4-7 shows the
basic structure of the animation block you need to create. Note that to implement the completion block shown
in Listing 4-6 (page 74), you would need to configure an animation delegate with a did-stop handler as
described in “Configuring an Animation Delegate” (page 71).
Listing 4-7 Changing subviews using the begin/commit methods
[UIView beginAnimations:@"ToggleSiblings" context:nil];
[UIView setAnimationTransition:UIViewAnimationTransitionCurlUp forView:self.view
cache:YES];
[UIView setAnimationDuration:1.0];
// Make your changes
[UIView commitAnimations];
Animations
Creating Animated Transitions Between Views
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
75Replacing a View with a Different View
Replacing views is something you do when you want your interface to be dramatically different. Because this
technique swaps only views (and not view controllers), you are responsible for designing your application’s
controller objects appropriately. This technique is simply a way of presenting new views quickly using some
standard transitions.
In iOS 4 and later, you use the transitionFromView:toView:duration:options:completion: method
to transition between two views. This method actually removes the first view from your hierarchy and inserts
the other, so you should make sure you have a reference to the first view if you want to keep it. If you want to
hide views instead of remove them from your view hierarchy, pass the
UIViewAnimationOptionShowHideTransitionViews key as one of the options.
Listing 4-8 shows the code needed to swap between two main views managed by a single view controller. In
this example, the view controller’s root view always displays one of two child views (primaryView or
secondaryView). Each view presents the same content but does so in a different way. The view controller
uses the displayingPrimary member variable (a Boolean value) to keep track of which view is displayed
at any given time. The flip direction changes depending on which view is being displayed.
Listing 4-8 Toggling between two views in a view controller
- (IBAction)toggleMainViews:(id)sender {
[UIView transitionFromView:(displayingPrimary ? primaryView : secondaryView)
toView:(displayingPrimary ? secondaryView : primaryView)
duration:1.0
options:(displayingPrimary ? UIViewAnimationOptionTransitionFlipFromRight
:
UIViewAnimationOptionTransitionFlipFromLeft)
completion:^(BOOL finished) {
if (finished) {
displayingPrimary = !displayingPrimary;
}
}];
}
Animations
Creating Animated Transitions Between Views
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
76Note: In addition to swapping out views, your view controller code needs to manage the loading
and unloading of both the primary and secondary views. For information on how views are loaded
and unloaded by a view controller, see View Controller Programming Guide for iOS .
Linking Multiple Animations Together
The UIView animation interfaces provide support for linking separate animation blocks so that they perform
sequentially instead of at the same time. The process for linking animation blocks depends on whether you
are using the block-based animation methods or the begin/commit methods:
● For block-based animations, use the completion handler supported by the
animateWithDuration:animations:completion: and
animateWithDuration:delay:options:animations:completion: methods to execute any
follow-on animations.
● For begin/commit animations, associate a delegate object and a did-stop selector with the animation. For
information about how to associate a delegate with your animations, see “Configuring an Animation
Delegate” (page 71).
An alternative to linking animations together is to use nested animations with different delay factors so as to
start the animations at different times. For more information on how to nest animations,see “Nesting Animation
Blocks” (page 72).
Animating View and Layer Changes Together
Applications can freely mix view-based and layer-based animation code as needed but the process for
configuring your animation parameters depends on who owns the layer. Changing a view-owned layer is the
same as changing the view itself, and any animations you apply to the layer’s properties respect the animation
parameters of the current view-based animation block. The same is not true for layers that you create yourself.
Custom layer objects ignore view-based animation block parameters and use the default Core Animation
parameters instead.
If you want to customize the animation parametersfor layers you create, you must use Core Animation directly.
Typically, animating layers using Core Animation involves creating a CABasicAnimation object orsome other
concrete subclass of CAAnimation. You then add that animation to the corresponding layer. You can apply
the animation from either inside or outside a view-based animation block.
Animations
Linking Multiple Animations Together
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
77Listing 4-9 shows an animation that modifies a view and a custom layer at the same time. The view in this
example contains a custom CALayer object at the center of its bounds. The animation rotatesthe view counter
clockwise while rotating the layer clockwise. Because the rotations are in opposite directions, the layer maintains
its original orientation relative to the screen and does not appear to rotate significantly. However, the view
beneath that layerspins 360 degrees and returnsto its original orientation. This example is presented primarily
to demonstrate how you can mix view and layer animations. Thistype of mixing should not be used in situations
where precise timing is needed.
Listing 4-9 Mixing view and layer animations
[UIView animateWithDuration:1.0
delay:0.0
options: UIViewAnimationOptionCurveLinear
animations:^{
// Animate the first half of the view rotation.
CGAffineTransform xform =
CGAffineTransformMakeRotation(DEGREES_TO_RADIANS(-180));
backingView.transform = xform;
// Rotate the embedded CALayer in the opposite direction.
CABasicAnimation* layerAnimation = [CABasicAnimation
animationWithKeyPath:@"transform"];
layerAnimation.duration = 2.0;
layerAnimation.beginTime = 0; //CACurrentMediaTime() + 1;
layerAnimation.valueFunction = [CAValueFunction
functionWithName:kCAValueFunctionRotateZ];
layerAnimation.timingFunction = [CAMediaTimingFunction
functionWithName:kCAMediaTimingFunctionLinear];
layerAnimation.fromValue = [NSNumber numberWithFloat:0.0];
layerAnimation.toValue = [NSNumber
numberWithFloat:DEGREES_TO_RADIANS(360.0)];
layerAnimation.byValue = [NSNumber
numberWithFloat:DEGREES_TO_RADIANS(180.0)];
[manLayer addAnimation:layerAnimation forKey:@"layerAnimation"];
}
completion:^(BOOL finished){
// Now do the second half of the view rotation.
[UIView animateWithDuration:1.0
Animations
Animating View and Layer Changes Together
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
78delay: 0.0
options: UIViewAnimationOptionCurveLinear
animations:^{
CGAffineTransform xform =
CGAffineTransformMakeRotation(DEGREES_TO_RADIANS(-359));
backingView.transform = xform;
}
completion:^(BOOL finished){
backingView.transform = CGAffineTransformIdentity;
}];
}];
Note: In Listing 4-9 (page 78), you could also create and apply the CABasicAnimation object
outside of the view-based animation block to achieve the same results. All of the animations ultimately
rely on Core Animation for their execution. Thus, if they are submitted at approximately the same
time, they run together.
If precise timing between your view and layer based animations is required, it is recommended that you create
all of the animations using Core Animation. You may find that some animations are easier to perform using
Core Animation anyway. For example, the view-based rotation in Listing 4-9 (page 78) requires a multistep
sequence for rotations of more than 180 degrees, whereas the Core Animation portion uses a rotation value
function that rotates from start to finish through a middle value.
For more information about how to create and configure animations using Core Animation,see Core Animation
Programming Guide and Core Animation Cookbook .
Animations
Animating View and Layer Changes Together
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
79This table describes the changes to View Programming Guide for iOS .
Date Notes
2011-03-08 Reorganized and expanded the content of the document.
Added information on how to create view-based animations.
Incorporated information on how to display content on an external display.
Added information about how to work with high-resolution screens.
New document describing the creation and management of views,
windows, and other visual interface elements.
2010-05-17
2011-03-08 | © 2011 Apple Inc. All Rights Reserved.
80
Document Revision HistoryApple Inc.
© 2011 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, iPad, iPhone, iPod,
iPod touch, Quartz, and Xcode are trademarks of
Apple Inc., registered in the U.S. and other
countries.
Retina is a trademark of Apple Inc.
OpenGL is a registered trademark of Silicon
Graphics, Inc.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Stream Programming
GuideContents
Introduction to Stream Programming Guide for Cocoa 4
Organization of This Document 4
See Also 4
Cocoa Streams 6
Reading From Input Streams 8
Preparing the Stream Object 8
Handling Stream Events 9
Disposing of the Stream Object 11
Writing To Output Streams 12
Preparing the Stream Object 12
Handling Stream Events 13
Disposing of the Stream Object 15
Polling Versus Run-Loop Scheduling 17
Handling Stream Errors 20
Setting Up Socket Streams 22
Basic Procedure 22
Securing and Configuring the Connection 23
Initiating an HTTP Request 24
For More Information 25
Document Revision History 26
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
2Figures and Listings
Cocoa Streams 6
Figure 1 Sources and destinations of stream objects 6
Reading From Input Streams 8
Listing 1 Creating and initializing an NSInputStream object 8
Listing 2 Handling a bytes-available event 10
Listing 3 Closing and releasing the NSInputStream object 11
Writing To Output Streams 12
Listing 1 Creating and initializing an NSOutputStream object for memory 13
Listing 2 Handling a space-available event 14
Listing 3 Closing and releasing the NSInputStream object 15
Polling Versus Run-Loop Scheduling 17
Listing 1 Writing to an output stream using polling 17
Handling Stream Errors 20
Listing 1 Handling stream errors 20
Setting Up Socket Streams 22
Listing 1 Setting up a network socket stream 22
Listing 2 Making an HTTP GET request 24
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
3A stream is a fundamental abstraction in programming: a sequence of bits transmitted serially from one point
to another point. Cocoa provides three classes to represent streams and facilitate their use in your programs:
NSStream, NSInputStream, and NSOutputStream. With the instances of these classes you can read data from,
and write data to, files and application memory. You can also use these objects in socket-based connections
to exchange data with remote hosts. You can also subclass the stream classes to obtain specialized stream
behavior.
Organization of This Document
This document includes the following articles:
●
“Cocoa Streams” (page 6) gives an overview of the Cocoa stream classes, describing architecture,
capabilities, and general usage.
●
“Reading From Input Streams” (page 8) explains how to create and prepare a (non-socket) input-stream
object. It also describes how to handle stream events generated by all types of NSInputStream objects.
●
“Writing To Output Streams” (page 12) explains how to create and prepare a (non-socket) output-stream
object. It also describes how to handle stream events generated by all types of NSOutputStream objects.
●
“Polling Versus Run-Loop Scheduling” (page 17) discusses the relative merits of the two techniques used
to avoid blocking when reading and writing to streams. It also illustrates how to poll for stream data using
the API of the stream classes.
●
“Handling Stream Errors” (page 20) describes how to handle errors that occur in stream processing.
●
“Setting Up Socket Streams” (page 22) explains how to set up stream objects used to communicate with
remote hosts via sockets.
See Also
You may find the following external resources helpful if you are implementing socket-based network streams:
● OpenSSL — http://www.openssl.org/
● Apache SSL — http://www.apache-ssl.org/
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
4
Introduction to Stream Programming Guide for
Cocoa● SOCKS — http://tools.ietf.org/html/rfc1928
Introduction to Stream Programming Guide for Cocoa
See Also
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
5Streams provide an easy way for a program to exchange data with a variety of media in a device-independent
way. A stream is a contiguous sequence of bits transmitted serially over a communications path. It is
unidirectional and hence, from the perspective of a program, a stream can be an input (or read) stream or an
output (or write) stream. Except for ones that are file-based, streams are non-seekable; once stream data has
been provided or consumed, it cannot be retrieved again from the stream.
Cocoa includes three stream-related classes: NSStream, NSInputStream, and NSOutputStream. NSStream
is an abstract classthat definesthe fundamental interface and propertiesfor allstream objects. NSInputStream
and NSOutputStream are subclasses of NSStream and implement default input-stream and output-stream
behavior. You can create NSOutputStream instances for stream data located in memory or written to a file
or C buffer; you can create NSInputStream instances for stream data read from an NSData object or a file.
You can also have NSInputStream and NSOutputStream objects at the end points of a socket-based network
connection and you can use stream objects without loading all of the stream data into memory at once. Figure
1 illustrates the types of input-stream and output-stream objects in terms of their sources or destinations.
Figure 1 Sources and destinations of stream objects
NSOutputStream
Buffer
Memory
(NSData)
Network
socket
Data
(NSData)
Network
socket
Client program
NSInputStream
File File
Because they deal with such a basic computing abstraction (streams), NSStream and itssubclasses are intended
for lower-level programming tasks. If there is a higher-level Cocoa API that is more suited for a particular task
(for example, NSURL or NSFileHandle) use it instead.
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
6
Cocoa StreamsStream objects have properties associated with them. Most properties have to do with network security and
configuration, namely secure-socket (SSL) levels and SOCKS proxy information. Two important additional
properties are NSStreamDataWrittenToMemoryStreamKey, which permits retrieval of data written to
memory for an output stream, and NSStreamFileCurrentOffsetKey, which allows you to manipulate the
current read or write position in file-based streams.
A stream object also has a delegate associated with it. If a delegate is not explicitly set, the stream object itself
becomesthe delegate (a useful convention for custom subclasses). A stream object invokesthe sole delegation
method stream:handleEvent: for each stream-related event it handles. Of particular importance are the
events that indicate when bytes are available to read from an input stream and when an output stream signals
that it’s ready to accept bytes. For these two events, the delegate sends the stream the appropriate
message—read:maxLength: or write:maxlength:, depending on type of stream—to get the bytes from
the stream or to put bytes on the stream.
NSStream is built on the CFStream layer of Core Foundation. This close relationship means that the concrete
subclasses of NSStream, NSOutputStream and NSInputStream, are toll-free bridged with their Core
Foundation counterparts CFWriteStream and CFReadStream. Although there are strong similarities between
the Cocoa and Core Foundation stream APIs, their implementations are not exactly coincident. The Cocoa
stream classes use the delegation model for asynchronous behavior (assuming run-loop scheduling) while
Core Foundation uses client callbacks. The Core Foundation stream types sets the client (termed a context in
Core Foundation) differently than the NSStream setsthe delegate; callsto set the delegate should not be mixed
with calls to set the context. Otherwise you can freely intermix calls from the two APIs in your code.
Despite their strong similarities, NSStream does give you a major advantage over CFStream. Because of its
Objective-C underpinnings, it is extensible. You can subclass NSStream, NSInputStream, or NSOutputStream
to customize stream attributes and behavior. For example, you could create an input stream that maintains
statistics on the bytes it reads; or you could make a NSStream subclass whose instances can seek through
their stream, putting back bytes that have been read. NSStream has its own set of required overrides, as do
NSInputStream and NSOutputStream. See the reference documentation for NSStream, NSInputStream,
and NSOutputStream for details on subclassing these classes.
Cocoa Streams
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
7In Cocoa, reading from an NSInputStream instance consists of several steps:
1. Create and initialize an instance of NSInputStream from a source of data.
2. Schedule the stream object on a run loop and open the stream.
3. Handle the events that the stream object reports to its delegate.
4. When there is no more data to read, dispose of the stream object.
The following discussion goes into each of these steps in more detail.
Note: The examples in this document show the strategy of scheduling stream objects on run loops
and setting a delegate to handle stream events. You may use polling instead of run-loop scheduling
if you prefer that approach. However, run-loop scheduling with delegation isthe preferred approach
for various reasons (described in “Polling Versus Run-Loop Scheduling” (page 17)), and that is why
it is highlighted in this document.
Preparing the Stream Object
To begin using an NSInputStream object you must have (after first locating, if necessary) a source of data
for the stream. The source of data can be a file, an NSData object, or a network socket.
Note: The procedure for initializing input-stream objects from network sockets is different from the
procedure for the other two data sources, and is not covered in this article. To learn about initializing
an NSInputStream instance for a network connection, see “Setting Up Socket Streams” (page 22).
The initializers and factory methods for NSInputStream allow you to create and initialize the instance from an
NSData or file. Listing 1 shows an NSInputStream instance created from a file.
Listing 1 Creating and initializing an NSInputStream object
- (void)setUpStreamForFile:(NSString *)path {
// iStream is NSInputStream instance variable
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
8
Reading From Input StreamsiStream = [[NSInputStream alloc] initWithFileAtPath:path];
[iStream setDelegate:self];
[iStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[iStream open];
}
As this example shows, after you create the object you should set the delegate (more often than not to self).
The delegate receives stream:handleEvent: messages from the NSInputStream object when that object is
scheduled on the run loop and hasstream-related eventsto report,such as when there are bytes on the stream
to be read.
Before you open the stream to begin the streaming of data,send a scheduleInRunLoop:forMode: message
to the stream object to schedule it to receive stream events on a run loop. By doing this, you are helping the
delegate to avoid blocking when there is no data on the stream to read. If streaming is taking place on another
thread, be sure to schedule the stream object on that thread’s run loop. You should never attempt to access
a scheduled stream from a thread different than the one owning the stream’s run loop. Finally, send the
NSInputStream instance an open message to start the streaming of data from the input source.
Handling Stream Events
After a stream object is sent open, you can find out about its status, whether it has bytes available to read,
and the nature of any error with the following messages:
streamStatus
hasBytesAvailable
streamError
The returned status is an NSStreamStatus constant indicating that the stream is opening, reading, at the
end of the stream, and so on. The returned error is an NSError object encapsulating information about any
error that took place. (See the reference documentation for NSStream for descriptions of NSStreamStatus
and other stream types.)
More importantly, once the streamobject has been opened, it keepssending stream:handleEvent:messages
to its delegate until it encounters the end of the stream. These messages include a parameter with an
NSStreamEvent constant that indicates the type of event. For NSInputStream objects, the most common
types of events are NSStreamEventOpenCompleted, NSStreamEventHasBytesAvailable, and
Reading From Input Streams
Handling Stream Events
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
9NSStreamEventEndEncountered. The delegate is typically most interested in
NSStreamEventHasBytesAvailable events. Listing 2 illustrates a good approach for handling this type of
event.
Listing 2 Handling a bytes-available event
- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
switch(eventCode) {
case NSStreamEventHasBytesAvailable:
{
if(!_data) {
_data = [[NSMutableData data] retain];
}
uint8_t buf[1024];
unsigned int len = 0;
len = [(NSInputStream *)stream read:buf maxLength:1024];
if(len) {
[_data appendBytes:(const void *)buf length:len];
// bytesRead is an instance variable of type NSNumber.
[bytesRead setIntValue:[bytesRead intValue]+len];
} else {
NSLog(@"no buffer!");
}
break;
}
// continued
In this implementation of stream:handleEvent: the delegate uses a switch statement to identify the
passed-in NSStreamEvent constant. If the constant is NSStreamEventHasBytesAvailable, the delegate
first lazily creates(if necessary) an NSMutableData object (_data) to hold the retrieved bytes. Then it declares
a buffer of a certain size (1024 bytes, in this case) and invokes the stream object’s read:maxLength: method,
which fills up the buffer with the specified number of bytes. If the read operation successfully fetched bytes
from the stream, the delegate appends these bytes to the NSMutableData object.
Reading From Input Streams
Handling Stream Events
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
10There is no firm guideline on how many bytes to read at one time. Although it may be possible to read all the
data in the stream in one event, this depends on the length of the stream (that is, the number of bytes in it)
as well as the behavior of the kernel, including device and socket characteristics. The best approach is to use
some reasonable buffer size, such as 512 bytes, one kilobyte (as in the example above), or a page size (four
kilobytes).
When the NSInputStream object experiences errors processing the stream, it stops streaming and notifies
its delegate with a NSStreamEventErrorOccurred. The delegate should handle the error in its
stream:handleEvent: method as described in “Handling Stream Errors” (page 20).
Disposing of the Stream Object
When an NSInputStream object reaches the end of a stream, it sends the delegate a
NSStreamEventEndEncountered event in a stream:handleEvent: message. The delegate should dispose
of the object by doing the mirror-opposite of what it did to prepare the object. In other words, it should first
close the stream object, remove it from the run loop, and finally release it. Listing 3 gives an example of how
you might do this.
Listing 3 Closing and releasing the NSInputStream object
- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode
{
switch(eventCode) {
case NSStreamEventEndEncountered:
{
[stream close];
[stream removeFromRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[stream release];
stream = nil; // stream is ivar, so reinit it
break;
}
// continued ...
}
}
Reading From Input Streams
Disposing of the Stream Object
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
11Using an NSOutputStream instance to write to an output stream requires several steps:
1. Create and initialize an instance of NSOutputStream with a repository for the written data. Also set a
delegate.
2. Schedule the stream object on a run loop and open the stream.
3. Handle the events that the stream object reports to its delegate.
4. If the stream object has written data to memory, obtain the data by requesting the
NSStreamDataWrittenToMemoryStreamKey property.
5. When there is no more data to write, dispose of the stream object.
The following discussion goes into each of these steps in more detail.
Note: The examples in this document show the strategy of scheduling stream objects on run loops
and setting a delegate to handle stream events. You may use polling instead of run-loop scheduling
if you prefer that approach. However, run-loop scheduling with delegation isthe preferred approach
for various reasons (described in “Polling Versus Run-Loop Scheduling” (page 17)), and that is why
it is highlighted in this document.
Preparing the Stream Object
To begin using an NSOutputStream object you must specify a destination for the data written to the stream.
The destination for an output-stream object can be a file, a C buffer, application memory, or a network socket.
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
12
Writing To Output StreamsNote: The procedure for initializing output-stream objects from network sockets is different from
the procedure for the other data destinations, and is not covered in this article. To learn about
initializing an NSOutputStream instance for a network connection, see “Setting Up Socket
Streams” (page 22).
The initializers and factory methods for NSOutputStream allow you to create and initialize the instance with
a file, a buffer, or memory. Listing 1 shows the creation of an NSOutputStream instance that will write data
to application memory.
Listing 1 Creating and initializing an NSOutputStream object for memory
- (void)createOutputStream {
NSLog(@"Creating and opening NSOutputStream...");
// oStream is an instance variable
oStream = [[NSOutputStream alloc] initToMemory];
[oStream setDelegate:self];
[oStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[oStream open];
}
As the code in Listing 1 shows, after you create the object you should set the delegate (more often than not
to self). The delegate receives stream:handleEvent: messages from the NSOutputStream object when
that object has stream-related events to report, such as when the stream has space for bytes.
Before you open the stream to begin the streaming of data,send a scheduleInRunLoop:forMode: message
to the stream object to schedule it to receive stream events on a run loop. By doing this, you are helping the
delegate to avoid blocking when the stream is unable to accept more bytes. If streaming is taking place on
another thread, be sure to schedule the stream object on that thread’s run loop. You should never attempt to
access a scheduled stream from a thread different than the one owning the stream’s run loop. Finally, send
the NSOutputStream instance an open message to start the streaming of data to the output container.
Handling Stream Events
After a stream object is sent open, you can find out about its status, whether it has space for writing data, and
the nature of any error with the following messages:
streamStatus
Writing To Output Streams
Handling Stream Events
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
13hasSpaceAvailable
streamError
The returned status is an NSStreamStatus constant indicating that the stream is opening, writing, at the end
of the stream, and so on. The returned error is an NSError object encapsulating information about any error
that took place. (See the reference documentation for NSStream for descriptions of NSStreamStatus and
other stream types.)
More importantly, once the streamobject has been opened, it keepssending stream:handleEvent:messages
to its delegate (as long as the delegate continues to put bytes on the stream) until it encounters the end of
the stream. These messages include a parameter with an NSStreamEvent constant that indicates the type of
event. For NSOutputStream objects, the most common types of events are NSStreamEventOpenCompleted,
NSStreamEventHasSpaceAvailable, and NSStreamEventEndEncountered. The delegate is typically
most interested in NSStreamEventHasSpaceAvailable events. Listing 2 illustrates one approach you could
take to handle this type of event.
Listing 2 Handling a space-available event
- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode
{
switch(eventCode) {
case NSStreamEventHasSpaceAvailable:
{
uint8_t *readBytes = (uint8_t *)[_data mutableBytes];
readBytes += byteIndex; // instance variable to move pointer
int data_len = [_data length];
unsigned int len = ((data_len - byteIndex >= 1024) ?
1024 : (data_len-byteIndex));
uint8_t buf[len];
(void)memcpy(buf, readBytes, len);
len = [stream write:(const uint8_t *)buf maxLength:len];
byteIndex += len;
break;
}
// continued ...
}
}
Writing To Output Streams
Handling Stream Events
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
14In this implementation of stream:handleEvent: the delegate uses a switch statement to identify the
passed-in NSStreamEvent constant. If the constant is NSStreamEventHasSpacesAvailable, the delegate
gets the bytes held by a NSMutableData object (_data) and advances the pointer for the current write
operation. It next determines the byte capacity of the impending write operation (1024 or the remaining bytes
to write), declares a buffer of that size, and copies that amount of data to the buffer. Next the delegate invokes
the output-stream object’s write:maxLength: method to put the buffer’s contents onto the output stream.
Finally it advances the index used to advance the readBytes pointer for the next operation.
If the delegate receives an NSStreamEventHasSpaceAvailable event and does not write anything to the
stream, it does not receive further space-available events from the run loop until the NSOutputStream object
receives more bytes. When this happens, the run loop is restarted for space-available events. If this scenario
is likely in your implementation, you can have the delegate set a flag when it doesn’t write to the stream upon
receiving an NSStreamEventHasSpaceAvailable event. Later, when your program has more bytesto write,
it can check this flag and, if set, write to the output-stream instance directly.
There is no firm guideline on how many bytes to write at one time. Although it may be possible to write all
the data to the stream in one event, this depends on external factors, such as the behavior of the kernel and
device and socket characteristics. The best approach is to use some reasonable buffer size, such as 512 bytes,
one kilobyte (as in the example above), or a page size (four kilobytes).
When the NSOutputStream object experiences errors writing to the stream, it stops streaming and notifies
its delegate with a NSStreamEventErrorOccurred. The delegate should handle the error in its
stream:handleEvent: method as described in “Handling Stream Errors” (page 20).
Disposing of the Stream Object
When an NSOutputStream object concludes writing data to an output stream, it sends the delegate a
NSStreamEventEndEncountered event in a stream:handleEvent: message. At this point the delegate
should dispose of the stream object by doing the mirror-opposite of what it did to prepare the object. In other
words, it should first close the stream object, remove it from the run loop, and finally release it. Furthermore,
if the destination for the NSOutputStream object is application memory (that is, you created the instance
using initToMemory or the factory method outputStreamToMemory), you might now want to retrieve the
data held in memory. Listing 3 illustrates how you might do all of these things.
Listing 3 Closing and releasing the NSInputStream object
- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode
{
switch(eventCode) {
case NSStreamEventEndEncountered:
Writing To Output Streams
Disposing of the Stream Object
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
15{
NSData *newData = [oStream propertyForKey:
NSStreamDataWrittenToMemoryStreamKey];
if (!newData) {
NSLog(@"No data written to memory!");
} else {
[self processData:newData];
}
[stream close];
[stream removeFromRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[stream release];
oStream = nil; // oStream is instance variable
break;
}
// continued ...
}
}
You get the stream data written to memory by sending the NSOutputStream object a propertyForKey:
message, specifying a key of NSStreamDataWrittenToMemoryStreamKey The stream object returns the
data in an NSData object.
Writing To Output Streams
Disposing of the Stream Object
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
16A potential problem with stream processing is blocking. A thread that is writing to or reading from a stream
might have to wait indefinitely until there is (respectively) space on the stream to put bytes or bytes on the
stream that can be read. In effect, the thread is at the mercy of the stream, and that can spell trouble for an
application. Blocking can especially be a problem with socketstreams because they are dependent on responses
from a remote host.
With Cocoa streams you have two ways to handle stream events:
● Run-loop scheduling. You schedule a stream object on a run loop so that the delegate receives messages
reporting stream-related events only when blocking is unlikely to take place. For read and write operations,
the pertinent NSStreamEvent constants are NSStreamHasBytesAvailable and
NSStreamHasSpaceAvailable.
● Polling. In a closed loop broken only at the end of the stream or upon error, you keep asking the stream
object if it has (for read streams) bytes available to read or (for write streams) space available for writing.
The pertinent methods are hasBytesAvailable (NSInputStream) and hasSpaceAvailable
(NSOutputStream).
Run-loop scheduling is almost always preferable over polling, and that is why the code examples in “Reading
From Input Streams” (page 8) and “Writing To Output Streams” (page 12) exclusively show the use of run
loops. With polling, your program is locked in a tight loop, waiting for stream events that might or might not
be imminent. With run-loop scheduling, your program can go off and do other things, knowing that it will be
notified when there is a stream event to handle. Moreover, run loops save you from having to manage state
and are more efficient than polling. Polling is also CPU-intensive; there are other things you can be doing with
your processing time.
That said, there can be situations where polling is a viable option. For example, if you are porting legacy code,
you might choose to use polling because it is better suited the threading model in the legacy code. Listing 1
illustrates a method that writes data to an output stream using polling.
Listing 1 Writing to an output stream using polling
- (void)createNewFile {
oStream = [[NSOutputStream alloc] initToMemory];
[oStream open];
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
17
Polling Versus Run-Loop Schedulinguint8_t *readBytes = (uint8_t *)[data mutableBytes];
uint8_t buf[1024];
int len = 1024;
while (1) {
if (len == 0) break;
if ( [oStream hasSpaceAvailable] ) {
(void)strncpy(buf, readBytes, len);
readBytes += len;
if ([oStream write:(const uint8_t *)buf maxLength:len] == -1) {
[self handleError:[oStream streamError]];
break;
}
[bytesWritten setIntValue:[bytesWritten intValue]+len];
len = (([data length] - [bytesWritten intValue] >= 1024) ? 1024 :
[data length] - [bytesWritten intValue]);
}
}
NSData *newData = [oStream propertyForKey:
NSStreamDataWrittenToMemoryStreamKey];
if (!newData) {
NSLog(@"No data written to memory!");
} else {
[self processData:newData];
}
[oStream close];
[oStream release];
oStream = nil;
}
It should be pointed out that neither the polling nor run-loop scheduling approaches are airtight defenses
against blocking. If the NSInputStream hasBytesAvailable method or the NSOutputStream
hasSpaceAvailable method returns NO, it means in both cases that the stream definitely has no available
bytes or space. However, if either of these methods returns YES, it can mean that there is available bytes or
Polling Versus Run-Loop Scheduling
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
18space or that the only way to find out isto attempt a read or a write operation (which could lead to a momentary
block). The NSStreamEventHasBytesAvailable and NSStreamEventHasSpaceAvailable stream events
have identical semantics.
Polling Versus Run-Loop Scheduling
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
19Occasionally, and especially with sockets, streams can experience errors that prevent further processing of
stream data. Generally, errors indicate the absence of something at one end of a stream, such as the crash of
a remote host or the deletion of a file being streamed. There is a little that a client of a stream can do when
most errors occur except report the error to the user. Although a stream object that has reported an error can
be queried for state before it is closed, it cannot be reused for read or write operations.
The NSStream and NSOutputStream classes inform you if an error occurred in several ways:
●
If the stream object is scheduled on a run loop, the object reports a NSStreamEventErrorOccurred
event to its delegate in a stream:handleEvent: message.
● At any time, the client can send a streamStatus message to a stream object and see if it returns
NSStreamStatusError.
●
If you attempt to write to an NSOutputStream object by sending it write:maxLength: and it returns
-1, a write error has occurred.
Once you have determined that a stream object experienced an error, you can query the object with a
streamError message to get more information about the error (in the form of an NSError object). Next,
inform the user about the error. Listing 1 shows how the delegate of a run loop-scheduled stream object might
handle an error.
Listing 1 Handling stream errors
- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
NSLog(@"stream:handleEvent: is invoked...");
switch(eventCode) {
case NSStreamEventErrorOccurred:
{
NSError *theError = [stream streamError];
NSAlert *theAlert = [[NSAlert alloc] init];
[theAlert setMessageText:@"Error reading stream!"];
[theAlert setInformativeText:[NSString stringWithFormat:@"Error %i:
%@",
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
20
Handling Stream Errors[theError code], [theError localizedDescription]]];
[theAlert addButtonWithTitle:@"OK"];
[theAlert beginSheetModalForWindow:[NSApp mainWindow]
modalDelegate:self
didEndSelector:@selector(alertDidEnd:returnCode:contextInfo:)
contextInfo:nil];
[stream close];
[stream release];
break;
}
// continued ....
}
}
For some errors, you can attempt to do more than inform the user. For example, if you try to set an SSL security
level on a socket connection but the remote host is not secure, the stream object will report an error. You can
then release the old stream object and create a new one for a non-secure socket connection.
Handling Stream Errors
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
21You can use the CFStream API to establish a socket connection and, with the stream object (or objects) created
as a result,send data to and receive data from a remote host. You can also configure the connection forsecurity.
Basic Procedure
The NSStream class does notsupport connecting to a remote host on iOS. CFStream does support this behavior,
however, and once you have created your streams with the CFStream API, you can take advantage of the
toll-free bridge between CFStream and NSStream to cast your CFStreams to NSStreams. Just call the
CFStreamCreatePairWithSocketToHost function, providing a host name and a port number, to receive
both a CFReadStreamRef and a CFWriteStreamRef for the given host. You can then cast these objects to
an NSInputStream and an NSOutputStream and proceed.
Listing 1 illustrates the use of CFStreamCreatePairWithSocketToHost. This example shows the creation
of both a CFReadStreamRef object and a CFWriteStreamRef object. If you want to receive only one of
these objects, just specify NULL as the parameter value for the unwanted object.
Listing 1 Setting up a network socket stream
- (IBAction)searchForSite:(id)sender
{
NSString *urlStr = [sender stringValue];
if (![urlStr isEqualToString:@""]) {
NSURL *website = [NSURL URLWithString:urlStr];
if (!website) {
NSLog(@"%@ is not a valid URL");
return;
}
CFReadStreamRef readStream;
CFWriteStreamRef writeStream;
CFStreamCreatePairWithSocketToHost(NULL, (CFStringRef)[website host], 80,
&readStream, &writeStream);
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
22
Setting Up Socket StreamsNSInputStream *inputStream = (__bridge_transfer NSInputStream *)readStream;
NSOutputStream *outputStream = (__bridge_transfer NSOutputStream
*)writeStream;
[inputStream setDelegate:self];
[outputStream setDelegate:self];
[inputStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[outputStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[inputStream open];
[outputStream open];
/* Store a reference to the input and output streams so that
they don't go away.... */
...
}
}
If you pass in invalid parameters, one or both of the requested CFReadStreamRef and CFWriteStreamRef
objects are NULL. Once you have cast the CFStreams to NSStreams, set the delegate, schedule the stream on a
run loop, and open the stream as usual. The delegate should begin to receive stream-event messages
(stream:handleEvent:). See “Reading From Input Streams” (page 8) and “Writing To Output Streams” (page
12) for more information.
Securing and Configuring the Connection
Before you open a stream object, you might want to set security and other features for the connection to the
remote host (which might be, for example, an HTTPS server). NSStream defines properties that affect the
security of TCP/IP socket connections in two ways:
● Secure Socket Layer (SSL).
A security protocol using digital certificates to provide data encryption, server authentication, message
integrity, and (optionally) client authentication for TCP/IP connections.
● SOCKS proxy server.
Setting Up Socket Streams
Securing and Configuring the Connection
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
23A server that sits between a client application and a real server over a TCP/IP connection. It intercepts
requests to the real server and, if it cannot fulfill them from a cache of recently requested files, forwards
them to the real server. SOCKS proxy servers help improve performance over a network and can also be
used to filter requests.
For SSL security, NSStream defines various security-level properties (for example,
NSStreamSocketSecurityLevelSSLv2). You set these properties by sending setProperty:forKey: to
the stream object using the key NSStreamSocketSecurityLevelKey, as in this sample message:
[inputStream setProperty:NSStreamSocketSecurityLevelTLSv1
forKey:NSStreamSocketSecurityLevelKey];
You must set the property before you open the stream. Once it opens, it goes through a handshake protocol
to find out what level of SSL security the other side of the connection is using. If the security level is not
compatible with the specified property, the stream object generates an error event. However, if you request
a negotiated security level (NSStreamSocketSecurityLevelNegotiatedSSL), the security level becomes
the highest that both sides of the connection can implement. Still, if you try to set an SSL security level when
the remote host is not secure, an error is generated.
To configure a SOCKS proxy server for a connection, you need to construct a dictionary with keys of the form
NSStreamSOCKSProxyNameKey (for example, NSStreamSOCKSProxyHostKey). The value of each key is
the SOCKS proxy setting that Name refers to. Then using setProperty:forKey:, set the dictionary as the
value of the NSStreamSOCKSProxyConfigurationKey.
Initiating an HTTP Request
If you are opening a connection to an HTTP server (that is, a website), then you may have to initiate a transaction
with that server by sending it an HTTP request. A good time to make this request is when the delegate of the
NSOutputStream objectreceives a NSStreamEventHasSpaceAvailable event via a stream:handleEvent:
message. “Making an HTTP GET request” shows the delegate creating an HTTP GET request and writing it to
the output stream, after which it immediately closes the stream object.
Listing 2 Making an HTTP GET request
- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
NSLog(@"stream:handleEvent: is invoked...");
switch(eventCode) {
Setting Up Socket Streams
Initiating an HTTP Request
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
24case NSStreamEventHasSpaceAvailable:
{
if (stream == oStream) {
NSString * str = [NSString stringWithFormat:
@"GET / HTTP/1.0\r\n\r\n"];
const uint8_t * rawstring =
(const uint8_t *)[str UTF8String];
[oStream write:rawstring maxLength:strlen(rawstring)];
[oStream close];
}
break;
}
// continued ...
}
}
For More Information
To learn more about using streams for networking, read Networking Overview.
Setting Up Socket Streams
For More Information
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
25This table describes the changes to Stream Programming Guide .
Date Notes
2012-09-19 Clarified behavior of CFStreamCreatePairWithSocketToHost.
2009-12-16 Updated code listings in the Setting Up Socket Streams chapter.
2009-08-28 Added links to related concepts.
2009-05-06 Added a missing comment to a code sample.
2008-10-15 Fixed broken links.
2006-10-03 Fixed a broken link.
Changed event in code listing on writing to a network stream to
NSStreamEventHasSpaceAvailable.
2006-04-04
2005-07-07 Fixed bugs and changed title from "Streams."
2004-07-21 Fixed bug in code example (Radar 3597799).
2004-02-20 First version of Streams.
2012-09-19 | © 2004, 2012 Apple Inc. All Rights Reserved.
26
Document Revision HistoryApple Inc.
© 2004, 2012 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, Mac, Objective-C,
and Spaces are trademarks of Apple Inc.,
registered in the U.S. and other countries.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
URL Loading System
Programming GuideContents
Introduction 5
Organization of This Document 5
See Also 6
URL Loading System Overview 7
URL Loading 7
Cache Management 9
Authentication and Credentials 9
Cookie Storage 10
Protocol Support 11
Using NSURLConnection 12
Creating a Connection 12
Controlling Response Caching 15
Estimating Upload Progress 16
Downloading Data Synchronously 17
Using NSURLDownload 18
Downloading to a Predetermined Destination 18
Downloading a File Using the Suggested Filename 20
Displaying Download Progress 22
Resuming Downloads 24
Decoding Encoded Files 24
Handling Redirects and Other Request Changes 26
Authentication Challenges 28
Deciding How to Respond to an Authentication Challenge 28
Responding to an Authentication Challenge 29
Providing Credentials 29
Continuing Without Credentials 30
Canceling the Connection 30
Understanding Cache Access 32
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
2Using the Cache for a Request 32
Cache Use Semantics for the http Protocol 33
Document Revision History 34
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
3Figures and Listings
URL Loading System Overview 7
Figure 1 The URL loading system class hierarchy 7
Using NSURLConnection 12
Listing 1 Creating a connection using NSURLConnection 12
Listing 2 Example connection:didReceiveResponse: implementation 13
Listing 3 Example connection:didReceiveData: implementation 14
Listing 4 Example connectionDidFailWithError: implementation 14
Listing 5 Example connectionDidFinishLoading: implementation 15
Listing 6 Example connection:withCacheResponse: implementation 16
Using NSURLDownload 18
Listing 1 Using NSURLDownload with a predetermined destination file location 18
Listing 2 Using NSURLDownload with a filename derived from the download 20
Listing 3 Logging the finalized filename using download:didCreateDestination: 22
Listing 4 Displaying the download progress 22
Listing 5 Example implementation of download:shouldDecodeSourceDataOfMIMEType: method. 24
Handling Redirects and Other Request Changes 26
Listing 1 Example of an implementation of connection:willSendRequest:redirectResponse:
26
Authentication Challenges 28
Listing 1 An example of using the connection:didReceiveAuthenticationChallenge: delegate
method 30
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
4This guide describes the Foundation framework classes available for interacting with URLs and communicating
with servers using standard Internet protocols. Together these classes are referred to asthe URL loading system.
The NSURL class provides the ability to manipulate URLs and the resources they refer to.
The Foundation framework also provides a rich collection of classes that include support for URL loading,
cookie storage, response caching, credentialstorage and authentication, and writing custom protocol extensions.
The URL loading system provides support for accessing resources using the following protocols:
● File Transfer Protocol (ftp://)
● Hypertext Transfer Protocol (http://)
● Secure 128-bit Hypertext Transfer Protocol (https://)
● Local file URLs (file:///)
It also transparently supports both proxy servers and SOCKS gateways using the user’s system preferences.
Organization of This Document
This guide includes the following articles:
●
“URL Loading System Overview” (page 7) describes the classes of the URL loading system and their
interaction.
●
“Using NSURLConnection” (page 12) describes using NSURLConnection for asynchronous connections.
●
“Using NSURLDownload” (page 18) describes using NSURLDownload to download files asynchronously
to disk.
●
“Handling Redirects and Other Request Changes” (page 26) describesthe options you have for responding
to a change to your URL request.
●
“Authentication Challenges” (page 28) describes the process for authenticating your connection against
a secure server.
●
“Understanding Cache Access” (page 32) describes how a connection uses the cache during a request.
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
5
IntroductionSee Also
The following sample code is available through Apple Developer Connection:
● SpecialPictureProtocol implements a custom NSURLProtocol that creates jpeg images in memory as
data is downloaded.
● AutoUpdater demonstrates how to check for, and download, an application update using
NSURLConnection and NSURLDownload.
Introduction
See Also
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
6The URL loading system is a set of classes and protocols that provide the underlying capability for an application
to access the data specified by a URL.
These classes fall into five categories: URL loading, cache management, authentication and credentials, cookie
storage, and protocol support.
Figure 1 The URL loading system class hierarchy
NSObject
URL Loading
NSURLConnection
NSURLRequest NSMutableURLRequest
NSURLResponse NSHTTPURLResponse
NSURLDownload
Cache Management
NSCacheURLRequest
NSURLCache
Cookie Storage
NSHTTPCookie
NSHTTPCookieStorage
Protocol Support
NSURLProtocolClient
NSURLProtocol
Authentication and Credentials
NSURLCredential
NSURLCredentialStorage
NSURLProtectionSpace
NSURLAuthenticationChallenge
NSURLAuthenticationChallengeSender
URL Loading
The most commonly used classes in the URL loading system allow an application to create a request for the
content of a URL and download it from the source.
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
7
URL Loading System OverviewA request for the contents of a URL is represented by an NSURLRequest object. The NSURLRequest class
encapsulates a URL and any protocol-specific properties, in a protocol-independent manner. It also provides
an interface to set the timeout for a connection and specifiesthe policy regarding the use of any locally cached
data. The NSMutableURLRequest classis a mutable subclass of NSURLRequest that allows a client application
to alter an existing request.
Note: When a client application initiates a connection or download using an instance of
NSMutableURLRequest, a deep copy is made of the request. Changes made to the initiating request
have no effect once a download has been initialized.
Protocols,such as HTTP, thatsupport protocol-specific properties must create categories on the NSURLRequest
and NSMutableURLRequest classesto provide accessorsfor those properties. As an example, the HTTP protocol
adds methods to NSURLRequest to return the HTTP request body, headers, and transfer method. It also adds
methodsto NSMutableURLRequest to set the corresponding values. Methodsforsetting and getting property
values in those accessors are exposed in the NSURLProtocol class.
The response from a server to a request can be viewed as two parts: metadata describing the contents and
the URL content data. The metadata that is common to most protocolsis encapsulated by the NSURLResponse
class and consists of the MIME type, expected content length, text encoding (where applicable), and the URL
that provided the response. Protocols can create subclasses of NSURLResponse to store protocol-specific
metadata. NSHTTPURLResponse, for example, stores the headers and the status code returned by the web
server.
Note: It’s important to remember that only the metadata for the response is stored in an
NSURLResponse object. An NSCachedURLResponse instance is used to encapsulate an
NSURLResponse, the URL content data, and any application-provided information. See “Cache
Management” (page 9) for details.
The NSURLConnection and NSURLDownload classes provide the interface to make a connection specified
by an NSURLRequest object and download the contents. An NSURLConnection object provides data to the
delegate as it is received from the originating source, whereas an NSURLDownload object writes the request
data directly to disk. Both classes provide extensive delegate support for responding to redirects, authentication
challenges, and error conditions.
The NSURLConnection class provides a delegate method that allows an application to control the caching
of a response on a per-request basis. Downloads initiated by an NSURLDownload instance are not cached.
URL Loading System Overview
URL Loading
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
8Cache Management
The URL loading system provides a composite on-disk and in-memory cache allowing an application to reduce
its dependence on a network connection and provide faster turnaround for previously cached responses. The
cache is stored on a per-application basis.
The cache is queried by NSURLConnection according to the cache policy specified by the initiating
NSURLRequest.
The NSURLCache class provides methods to configure the cache size and its location on disk. It also provides
methods to manage the collection of NSCachedURLResponse objects that contain the cached responses.
An NSCachedURLResponse object encapsulates the NSURLResponse and the URL content data.
NSCachedURLResponse also provides a user info dictionary that can be used by an application to cache any
custom data.
Not all protocol implementations support response caching. Currently only http and https requests are
cached, and https requests are never cached to disk.
An NSURLConnection can control whether a response is cached and whether the response should be cached
only in memory by implementing the connection:willCacheResponse: delegate method.
Authentication and Credentials
Some servers restrict access to certain content, requiring a user to authenticate with a valid user name and
password in order to gain access. In the case of a web server, restricted content is grouped together into a
realm that requires a single set of credentials.
The URL loading system provides classesthat model credentials and protected areas as well as providing secure
credential persistence. Credentials can be specified to persist for a single request, for the duration of an
application’s launch, or permanently in the user’s keychain.
Note: Credentials stored in persistent storage are kept in the user's keychain and shared among all
applications.
The NSURLCredential class encapsulates a credential consisting of the user name, password, and the type
of persistence to use. The NSURLProtectionSpace classrepresents an area that requires a specific credential.
A protection space can be limited to a single URL, encompass a realm on a web server, or refer to a proxy.
URL Loading System Overview
Cache Management
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
9A shared instance of the NSURLCredentialStorage class manages credential storage and provides the
mapping of an NSURLCredential object to the corresponding NSURLProtectionSpace object for which
it provides authentication.
The NSURLAuthenticationChallenge class encapsulates the information required by an NSURLProtocol
implementation to authenticate a request: a proposed credential, the protection space involved, the error or
response that the protocol used to determine that authentication isrequired, and the number of authentication
attemptsthat have been made. An NSURLAuthenticationChallenge instance also specifiesthe object that
initiated the authentication. The initiating object, referred to as the sender, must conform to the
NSURLAuthenticationChallengeSender protocol.
NSURLAuthenticationChallenge instances are used by NSURLProtocol subclasses to inform the URL
loading system that authentication is required. They are also provided to the delegate methods of
NSURLConnection and NSURLDownload that facilitate customized authentication handling.
Cookie Storage
Due to the stateless nature of the HTTP protocol, cookies are often used to provide persistent storage of data
across URL requests. The URL loading system provides interfaces to create and manage cookies as well as
sending and receiving cookies from web servers.
The NSHTTPCookie class encapsulates a cookie, providing accessors for many of the common cookie attributes.
It also provides methods to convert HTTP cookie headers to NSHTTPCookie instances and convert an
NSHTTPCookie instance to headers suitable for use with an NSURLRequest. The URL loading system
automatically sends any stored cookies appropriate for an NSURLRequest. unless the request specifies not to
send cookies. Likewise, cookies returned in an NSURLResponse are accepted in accordance with the current
cookie acceptance policy.
The NSHTTPCookieStorage class provides the interface for managing the collection of NSHTTPCookie
objects shared by all applications.
iOS Note: Cookies are not shared by applications in iOS.
NSHTTPCookieStorage allows an application to specify a cookie acceptance policy. The cookie acceptance
policy controls whether cookies should always be accepted, never be accepted, or accepted only from the
same domain as the main document URL.
URL Loading System Overview
Cookie Storage
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
10Note: Changing the cookie acceptance policy in an application affectsthe cookie acceptance policy
for all other running applications.
When another application changesthe cookie storage or the cookie acceptance policy, NSHTTPCookieStorage
notifies an application by posting the NSHTTPCookieStorageCookiesChangedNotification and
NSHTTPCookieStorageAcceptPolicyChangedNotification notifications.
Protocol Support
The URL loading system design allows a client application to extend the protocols that are supported for
transferring data. The URL loading system natively supports http, https, file, and ftp protocols.
Custom protocols are implemented by subclassing NSURLProtocol and then registering the new class with
the URL loading system using the NSURLProtocol class method registerClass:. When an
NSURLConnection or NSURLDownload object initiates a connection for an NSURLRequest, the URL loading
system consults each of the registered classes in the reverse order of their registration. The first class that
returns YES for a canInitWithRequest: message is used to handle the request.
The URL loading system is responsible for creating and releasing NSURLProtocol instances when connections
start and complete. An application should never create an instance of NSURLProtocol directly.
When an NSURLProtocol subclass is initialized by the URL loading system, it is provided a client object that
conforms to the NSURLProtocolClient protocol. The NSURLProtocol subclass sends messages from the
NSURLProtocolClient protocol to the client object to inform the URL loading system of its actions as it creates
a response, receives data, redirectsto a new URL, requires authentication, and completesthe load. If the custom
protocolsupports authentication, then it must conform to the NSURLAuthenticationChallengeSender protocol.
URL Loading System Overview
Protocol Support
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
11NSURLConnection provides the most flexible method of downloading the contents of a URL. It provides a
simple interface for creating and canceling a connection, and supports a collection of delegate methods that
provide feedback and control of many aspects of the connection. These classes fall into five categories: URL
loading, cache management, authentication and credentials, cookie storage, and protocol support.
Creating a Connection
In order to download the contents of a URL, an application needsto provide a delegate object that, at a minimum,
implements the following delegate methods: connection:didReceiveResponse:,
connection:didReceiveData:, connection:didFailWithError: and
connectionDidFinishLoading:.
The example in Listing 1 initiates a connection for a URL. It begins by creating an NSURLRequest instance for
the URL, specifying the cache access policy and the timeout interval for the connection. It then creates an
NSURLConnection instance,specifying the request and a delegate. If NSURLConnection can’t create a connection
for the request, initWithRequest:delegate: returns nil. If the connection is successful, an instance of
NSMutableData is created to store the data that is provided to the delegate incrementally.
Listing 1 Creating a connection using NSURLConnection
// Create the request.
NSURLRequest *theRequest=[NSURLRequest requestWithURL:[NSURL
URLWithString:@"http://www.apple.com/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:60.0];
// create the connection with the request
// and start loading the data
NSURLConnection *theConnection=[[NSURLConnection alloc] initWithRequest:theRequest
delegate:self];
if (theConnection) {
// Create the NSMutableData to hold the received data.
// receivedData is an instance variable declared elsewhere.
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
12
Using NSURLConnectionreceivedData = [[NSMutableData data] retain];
} else {
// Inform the user that the connection failed.
}
The download starts immediately upon receiving the initWithRequest:delegate: message. It can be
canceled any time before the delegate receives a connectionDidFinishLoading: or
connection:didFailWithError: message by sending the connection a cancel message.
When the server has provided sufficient data to create an NSURLResponse object, the delegate receives a
connection:didReceiveResponse: message. The delegate method can examine the provided
NSURLResponse and determine the expected content length of the data, MIME type, suggested filename and
other metadata provided by the server.
You should be prepared for your delegate to receive the connection:didReceiveResponse: message
multiple times for a single connection. This message can be sent due to server redirects, or in rare cases
multi-part MIME documents. Each time the delegate receives the connection:didReceiveResponse:
message, it should reset any progress indication and discard all previously received data. The example
implementation in Listing 2 simply resets the length of the received data to 0 each time it is called.
Listing 2 Example connection:didReceiveResponse: implementation
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse
*)response
{
// This method is called when the server has determined that it
// has enough information to create the NSURLResponse.
// It can be called multiple times, for example in the case of a
// redirect, so each time we reset the data.
// receivedData is an instance variable declared elsewhere.
[receivedData setLength:0];
}
The delegate is periodically sent connection:didReceiveData: messages as the data is received. The
delegate implementation is responsible for storing the newly received data. In the example implementation
in Listing 3, the new data is appended to the NSMutableData object created in Listing 1.
Using NSURLConnection
Creating a Connection
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
13Listing 3 Example connection:didReceiveData: implementation
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data
{
// Append the new data to receivedData.
// receivedData is an instance variable declared elsewhere.
[receivedData appendData:data];
}
You can also use the connection:didReceiveData: method to provide an indication of the connection’s
progress to the user.
If an error is encountered during the download, the delegate receives a connection:didFailWithError:
message. The NSError object passed as the parameter specifies the details of the error. It also provides the URL
of the request that failed in the user info dictionary using the key NSURLErrorFailingURLStringErrorKey.
After the delegate receives a message connection:didFailWithError:, it receives no further delegate
messages for the specified connection.
The example in Listing 4 releases the connection, as well as any received data, and logs the error.
Listing 4 Example connectionDidFailWithError: implementation
- (void)connection:(NSURLConnection *)connection
didFailWithError:(NSError *)error
{
// release the connection, and the data object
[connection release];
// receivedData is declared as a method instance elsewhere
[receivedData release];
// inform the user
NSLog(@"Connection failed! Error - %@ %@",
[error localizedDescription],
[[error userInfo] objectForKey:NSURLErrorFailingURLStringErrorKey]);
}
Using NSURLConnection
Creating a Connection
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
14Finally, if the connection succeeds in downloading the request, the delegate receives the
connectionDidFinishLoading: message. The delegate will receive no further messagesfor the connection
and the NSURLConnection object can be released.
The example implementation in Listing 5 logsthe length of the received data and releases both the connection
object and the received data.
Listing 5 Example connectionDidFinishLoading: implementation
- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
// do something with the data
// receivedData is declared as a method instance elsewhere
NSLog(@"Succeeded! Received %d bytes of data",[receivedData length]);
// release the connection, and the data object
[connection release];
[receivedData release];
}
This represents the simplest implementation of a client using NSURLConnection. Additional delegate methods
provide the ability to customize the handling of server redirects, authorization requests and caching of the
response.
Controlling Response Caching
By default the data for a connection is cached according to the support provided by the NSURLProtocolsubclass
that handles the request. An NSURLConnection delegate can further refine that behavior by implementing
connection:willCacheResponse:.
This delegate method can examine the provided NSCachedURLResponse object and change how the response
is cached, for example restricting its storage to memory only or preventing it from being cached altogether.
It is also possible to insert objects in an NSCachedURLResponse’s user info dictionary, causing them to be
stored in the cache as part of the response.
Using NSURLConnection
Controlling Response Caching
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
15Note: The delegate receives connection:willCacheResponse: messages only for protocols
that support caching.
The example in Listing 6 prevents the caching of https responses. It also adds the current date to the user
info dictionary for responses that are cached.
Listing 6 Example connection:withCacheResponse: implementation
-(NSCachedURLResponse *)connection:(NSURLConnection *)connection
willCacheResponse:(NSCachedURLResponse *)cachedResponse
{
NSCachedURLResponse *newCachedResponse = cachedResponse;
if ([[[[cachedResponse response] URL] scheme] isEqual:@"https"]) {
newCachedResponse = nil;
} else {
NSDictionary *newUserInfo;
newUserInfo = [NSDictionary dictionaryWithObject:[NSCalendarDate date]
forKey:@"Cached Date"];
newCachedResponse = [[[NSCachedURLResponse alloc]
initWithResponse:[cachedResponse response]
data:[cachedResponse data]
userInfo:newUserInfo
storagePolicy:[cachedResponse storagePolicy]]
autorelease];
}
return newCachedResponse;
}
Estimating Upload Progress
You can estimate the progress of an HTTP POST upload with the
connection:didSendBodyData:totalBytesWritten:totalBytesExpectedToWrite: delegatemethod.
Note that this is not an exact measurement of upload progress, because the connection may fail or the
connection may encounter an authentication challenge.
Using NSURLConnection
Estimating Upload Progress
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
16Downloading Data Synchronously
NSURLConnection provides support for downloading the contents of an NSURLRequest in a synchronous
manner using the class method sendSynchronousRequest:returningResponse:error:. Using this
method is not recommended, because it has severe limitations:
● The client application blocks until the data has been completely received, an error is encountered, or the
request times out.
● Minimal support is provided for requests that require authentication.
● There is no means of modifying the default behavior of response caching or accepting server redirects.
If the download succeeds, the contents of the request are returned as an NSData object and an NSURLResponse
for the request is returned by reference. If NSURLConnection is unable to download the URL, the method
returns nil and any available NSError instance by reference in the appropriate parameter.
If the request requires authentication in order to make the connection, valid credentials must already be
available in the NSURLCredentialStorage, or must be provided as part of the requested URL. If the credentials
are not available or fail to authenticate, the URL loading system responds by sending the NSURLProtocol
subclass handling the connection a continueWithoutCredentialForAuthenticationChallenge:
message.
When a synchronous connection attempt encounters a server redirect, the redirect is always honored. Likewise
the response data is stored in the cache according to the default support provided by the protocol
implementation.
Using NSURLConnection
Downloading Data Synchronously
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
17NSURLDownload provides an application the ability to download the contents of a URL directly to disk. It
provides an interface similar to NSURLConnection, adding an additional method forspecifying the destination
of the file. NSURLDownload can also decode commonly used encoding schemes such as MacBinary, BinHex
and gzip. Unlike NSURLConnection, data downloaded using NSURLDownload is notstored in the cache system.
If your application is not restricted to using Foundation classes, the WebKit framework includes WebDownload,
a subclass of NSURLDownload that provides a user interface for authentication.
iOS Note: The NSURLDownload class is not available in iOS, because downloading directly to the
file system is discouraged. Use the NSURLConnection class instead. See “Using
NSURLConnection” (page 12) for more information.
Downloading to a Predetermined Destination
One usage pattern for NSURLDownload is downloading a file to a predetermined filename on disk. If the
application knows the destination of the download, it can set it explicitly using
setDestination:allowOverwrite:. Multiple setDestination:allowOverwrite: messages to an
NSURLDownload instance are ignored.
The download starts immediately upon receiving the initWithRequest:delegate: message. It can be
canceled any time before the delegate receives a downloadDidFinish: or download:didFailWithError:
message by sending the download a cancel message.
The example in Listing 1 sets the destination, and thus requires the delegate only implement the
download:didFailWithError: and downloadDidFinish: methods.
Listing 1 Using NSURLDownload with a predetermined destination file location
- (void)startDownloadingURL:sender
{
// Create the request.
NSURLRequest *theRequest = [NSURLRequest requestWithURL:[NSURL
URLWithString:@"http://www.apple.com"]
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
18
Using NSURLDownloadcachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:60.0];
// Create the connection with the request and start loading the data.
NSURLDownload *theDownload = [[NSURLDownload alloc] initWithRequest:theRequest
delegate:self];
if (theDownload) {
// Set the destination file.
[theDownload setDestination:@"/tmp" allowOverwrite:YES];
} else {
// inform the user that the download failed.
}
}
- (void)download:(NSURLDownload *)download didFailWithError:(NSError *)error
{
// Release the connection.
[download release];
// Inform the user.
NSLog(@"Download failed! Error - %@ %@",
[error localizedDescription],
[[error userInfo] objectForKey:NSURLErrorFailingURLStringErrorKey]);
}
- (void)downloadDidFinish:(NSURLDownload *)download
{
// Release the connection.
[download release];
// Do something with the data.
NSLog(@"%@",@"downloadDidFinish");
}
Using NSURLDownload
Downloading to a Predetermined Destination
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
19Additional methods can be implemented by the delegate to customize the handling of authentication, server
redirects and file decoding.
Downloading a File Using the Suggested Filename
Sometimesthe application must derive the destination filename from the downloaded data itself. Thisrequires
you to implement the delegate method download:decideDestinationWithSuggestedFilename: and
call setDestination:allowOverwrite: with the suggested filename. The example in Listing 2 saves the
downloaded file to the desktop using the suggested filename.
Listing 2 Using NSURLDownload with a filename derived from the download
- (void)startDownloadingURL:sender
{
// Create the request.
NSURLRequest *theRequest = [NSURLRequest requestWithURL:[NSURL
URLWithString:@"http://www.apple.com/index.html"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:60.0];
// Create the download with the request and start loading the data.
NSURLDownload *theDownload = [[NSURLDownload alloc] initWithRequest:theRequest
delegate:self];
if (!theDownload) {
// Inform the user that the download failed.
}
}
- (void)download:(NSURLDownload *)download
decideDestinationWithSuggestedFilename:(NSString *)filename
{
NSString *destinationFilename;
NSString *homeDirectory = NSHomeDirectory();
destinationFilename = [[homeDirectory stringByAppendingPathComponent:@"Desktop"]
stringByAppendingPathComponent:filename];
Using NSURLDownload
Downloading a File Using the Suggested Filename
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
20[download setDestination:destinationFilename allowOverwrite:NO];
}
- (void)download:(NSURLDownload *)download didFailWithError:(NSError *)error
{
// Release the download.
[download release];
// Inform the user.
NSLog(@"Download failed! Error - %@ %@",
[error localizedDescription],
[[error userInfo] objectForKey:NSURLErrorFailingURLStringErrorKey]);
}
- (void)downloadDidFinish:(NSURLDownload *)download
{
// Release the download.
[download release];
// Do something with the data.
NSLog(@"%@",@"downloadDidFinish");
}
The downloaded file is stored on the user's desktop with the name index.html, which was derived from the
downloaded content. Passing NO to setDestination:allowOverwrite: prevents an existing file from
being overwritten by the download. Instead a unique filename is created by inserting a sequential number
after the filename, for example, index-1.html.
The delegate is informed when a file is created on disk if it implements the
download:didCreateDestination: method. This method also gives the application the opportunity to
determine the finalized filename with which the download is saved.
The example in Listing 3 logs the finalized filename.
Using NSURLDownload
Downloading a File Using the Suggested Filename
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
21Listing 3 Logging the finalized filename using download:didCreateDestination:
-(void)download:(NSURLDownload *)download didCreateDestination:(NSString *)path
{
// path now contains the destination path
// of the download, taking into account any
// unique naming caused by -setDestination:allowOverwrite:
NSLog(@"Final file destination: %@",path);
}
This message is sent to the delegate after it has been given an opportunity to respond to the
download:shouldDecodeSourceDataOfMIMEType: and
download:decideDestinationWithSuggestedFilename: messages.
Displaying Download Progress
The progress of the download can be determined by implementing the delegate methods
download:didReceiveResponse: and download:didReceiveDataOfLength:.
The download:didReceiveResponse: method provides the delegate an opportunity to determine the
expected content length from the NSURLResponse. The delegate should reset the progress each time this
message is received.
The example implementation in Listing 4 demonstrates using these methods to provide progress feedback to
the user.
Listing 4 Displaying the download progress
- (void)setDownloadResponse:(NSURLResponse *)aDownloadResponse
{
[aDownloadResponse retain];
// downloadResponse is an instance variable defined elsewhere.
[downloadResponse release];
downloadResponse = aDownloadResponse;
}
Using NSURLDownload
Displaying Download Progress
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
22- (void)download:(NSURLDownload *)download didReceiveResponse:(NSURLResponse
*)response
{
// Reset the progress, this might be called multiple times.
// bytesReceived is an instance variable defined elsewhere.
bytesReceived = 0;
// Retain the response to use later.
[self setDownloadResponse:response];
}
- (void)download:(NSURLDownload *)download didReceiveDataOfLength:(unsigned)length
{
long long expectedLength = [[self downloadResponse] expectedContentLength];
bytesReceived = bytesReceived + length;
if (expectedLength != NSURLResponseUnknownLength) {
// If the expected content length is
// available, display percent complete.
float percentComplete = (bytesReceived/(float)expectedLength)*100.0;
NSLog(@"Percent complete - %f",percentComplete);
} else {
// If the expected content length is
// unknown, just log the progress.
NSLog(@"Bytes received - %d",bytesReceived);
}
}
The delegate receives a download:didReceiveResponse: message before it begins receiving
download:didReceiveDataOfLength: messages.
Using NSURLDownload
Displaying Download Progress
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
23Resuming Downloads
In some cases, you can resume a download that was canceled or that failed while in progress. To do so, first
make sure your original download doesn’t delete its data upon failure by passing NO to the download’s
setDeletesFileUponFailure: method. If the original download fails, you can obtain its data with the
resumeData method. You can then initialize a new download with the
initWithResumeData:delegate:path: method. When the download resumes, the download’s delegate
receives the download:willResumeWithResponse:fromByte: message.
You can resume a download only if both the protocol of the connection and the MIME type of the file being
downloaded support resuming. You can determine whether your file’s MIME type is supported with the
canResumeDownloadDecodedWithEncodingMIMEType: method.
Decoding Encoded Files
NSURLDownload provides support for decoding selected file formats: MacBinary, BinHex and gzip. If
NSURLDownload determines that a file is encoded in a supported format, it attempts to send the delegate a
download:shouldDecodeSourceDataOfMIMEType: message. If the delegate implements this method, it
should examine the passed MIME type and return YES if the file should be decoded.
The example in Listing 5 compares the MIME type of the file and allows decoding of MacBinary and BinHex
encoded content.
Listing 5 Example implementation of download:shouldDecodeSourceDataOfMIMEType: method.
- (BOOL)download:(NSURLDownload *)download
shouldDecodeSourceDataOfMIMEType:(NSString *)encodingType;
{
BOOL shouldDecode = NO;
if ([encodingType isEqual:@"application/macbinary"]) {
shouldDecode = YES;
} else if ([encodingType isEqual:@"application/binhex"]) {
shouldDecode = YES;
} else if ([encodingType isEqual:@"application/gzip"]) {
shouldDecode = NO;
}
return shouldDecode;
Using NSURLDownload
Resuming Downloads
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
24}
Using NSURLDownload
Decoding Encoded Files
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
25A server may redirect a request for one URL to another URL. The delegates for NSURLConnection and
NSURLDownload can be notified when this occurs for their connection.
To handle a redirect for an instance of NSURLConnection, implement the
connection:willSendRequest:redirectResponse: delegate method (for NSURLDownload, implement
download:willSendRequest:redirectResponse:). If the delegate implements this method, it can
examine the new request and the response that caused the redirect, and respond in one of four ways:
● The delegate can allow the redirect by simply returning the provided request.
● The delegate can create a new request, pointing to a different URL, and return that request.
● The delegate can reject the redirect and receive any existing data from the connection by returning nil.
● The delegate can cancel both the redirect and the connection by sending the cancelmessage to the
NSURLConnection or NSURLDownload.
The delegate also receives the connection:willSendRequest:redirectResponse: message if the
NSURLProtocol subclass that handles the request has changed the NSURLRequest in order to standardize
its format, for example, changing a request for http://www.apple.com to http://www.apple.com/. This
occurs because the standardized, or canonical, version of the request is used for cache management. In this
special case, the response passed to the delegate is nil and the delegate should simply return the provided
request.
The example implementation in Listing 1 allows canonical changes and denies all server redirects.
Listing 1 Example of an implementation of connection:willSendRequest:redirectResponse:
-(NSURLRequest *)connection:(NSURLConnection *)connection
willSendRequest:(NSURLRequest *)request
redirectResponse:(NSURLResponse *)redirectResponse
{
NSURLRequest *newRequest = request;
if (redirectResponse) {
newRequest = nil;
}
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
26
Handling Redirects and Other Request Changesreturn newRequest;
}
If the delegate doesn't implement connection:willSendRequest:redirectResponse:, all canonical
changes and server redirects are allowed.
Handling Redirects and Other Request Changes
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
27An NSURLRequest object often encounters an authentication challenge, or a request for credentials from the
server it is connecting to. The delegates for NSURLConnection and NSURLDownload can be notified when
their request encounters an authentication challenge, so that they can act accordingly.
Deciding How to Respond to an Authentication Challenge
If an NSURLRequest object requires authentication, the delegate of the NSURLConnection (or NSURLDownload)
object associated with the request first receives a
connection:canAuthenticateAgainstProtectionSpace: (or
download:canAuthenticateAgainstProtectionSpace:) message. This allows the delegate to analyze
properties of the server, including its protocol and authentication method, before attempting to authenticate
against it. If your delegate is not prepared to authenticate against the server’s protection space, you can return
NO, and the system attempts to authenticate with information from the user’s keychain.
Note: If your delegate does not implement the
connection:canAuthenticateAgainstProtectionSpace: method and the protection space
uses client certificate authentication or server trust authentication, the system behaves as if you
returned NO. The system behaves as if you returned YES for all other authentication methods.
If your delegate returns YES from connection:canAuthenticateAgainstProtectionSpace: or doesn’t
implement it, and there are no valid credentials available, either as part of the requested URL or in the shared
NSURLCredentialStorage,the delegate receives a connection:didReceiveAuthenticationChallenge:
message. In order for the connection to continue, the delegate has three options:
● Provide authentication credentials
● Attempt to continue without credentials
● Cancel the authentication challenge
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
28
Authentication ChallengesTo help determine the correct course of action, the NSURLAuthenticationChallenge instance passed to
the method contains information about what triggered the authentication challenge, how many attempts
were made for the challenge, any previously attempted credentials, the NSURLProtectionSpace that requires
the credentials, and the sender of the challenge.
If the authentication challenge has tried to authenticate previously and failed, you can obtain the attempted
credentials by calling proposedCredential on the authentication challenge. The delegate can then use
these credentials to populate a dialog that it presents to the user.
Calling previousFailureCount on the authentication challenge returns the total number of previous
authentication attempts, including those from different authentication protocols. The delegate can provide
this information to the end user, to determine whether the credentials it supplied previously are failing, or to
limit the maximum number of authentication attempts.
Responding to an Authentication Challenge
The following are the three ways you can respond to the
connection:didReceiveAuthenticationChallenge: delegate method.
Providing Credentials
To attempt to authenticate, the application should create an NSURLCredential object with authentication
information of the form expected by the server. You can determine the server’s authentication method by
calling authenticationMethod on the protection space of the provided authentication challenge. Some
authentication methods supported by NSURLCredential are:
HTTP Basic Authentication (NSURLAuthenticationMethodHTTPBasic)
The basic authentication method requires a user name and password. Prompt the user for the necessary
information and create an NSURLCredential object with
credentialWithUser:password:persistence:.
HTTP Digest Authentication (NSURLAuthenticationMethodHTTPDigest)
Like basic authentication, digest authentication just requires a user name and password (the digest is
generated automatically). Prompt the user for the necessary information and create an NSURLCredential
object with credentialWithUser:password:persistence:.
Client Certificate Authentication (NSURLAuthenticationMethodClientCertificate)
Client certificate authentication requires the system identity and all certificates needed to authenticate
with the server. Create an NSURLCredential object with
credentialWithIdentity:certificates:persistence:.
Authentication Challenges
Responding to an Authentication Challenge
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
29Server Trust Authentication (NSURLAuthenticationMethodServerTrust)
Server trust authentication requires a trust provided by the protection space of the authentication
challenge. Create an NSURLCredential object with credentialForTrust:.
After you’ve created the NSURLCredential object, pass it to the authentication challenge’s sender with
useCredential:forAuthenticationChallenge:.
Continuing Without Credentials
If the delegate chooses not to provide a credential for the authentication challenge, it can attempt to continue
without one by calling continueWithoutCredentialsForAuthenticationChallenge: on [challenge
sender]. Depending on the protocol implementation, continuing without credentials may either cause the
connection to fail, resulting in a connectionDidFailWithError: message, or return alternate URL contents
that don’t require authentication.
Canceling the Connection
The delegate may also choose to cancel the authentication challenge by calling
cancelAuthenticationChallenge: on [challenge sender]. The delegate receives a
connection:didCancelAuthenticationChallenge: message, providing the opportunity to give the
user feedback.
Para
The implementation shown in Listing 1 attempts to authenticate the challenge by creating an
NSURLCredential instance with a user name and password supplied by the application’s preferences. If the
authentication has failed previously, it cancels the authentication challenge and informs the user.
Listing 1 An example of using the connection:didReceiveAuthenticationChallenge: delegate method
-(void)connection:(NSURLConnection *)connection
didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
{
if ([challenge previousFailureCount] == 0) {
NSURLCredential *newCredential;
newCredential = [NSURLCredential credentialWithUser:[self preferencesName]
password:[self preferencesPassword]
persistence:NSURLCredentialPersistenceNone];
[[challenge sender] useCredential:newCredential
Authentication Challenges
Responding to an Authentication Challenge
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
30forAuthenticationChallenge:challenge];
} else {
[[challenge sender] cancelAuthenticationChallenge:challenge];
// inform the user that the user name and password
// in the preferences are incorrect
[self showPreferencesCredentialsAreIncorrectPanel:self];
}
}
If the delegate doesn’t implement connection:didReceiveAuthenticationChallenge: and the request
requires authentication, valid credentials must already be available in the URL credential storage or must be
provided as part of the requested URL. If the credentials are not available or if they fail to authenticate, a
continueWithoutCredentialForAuthenticationChallenge: message is sent by the underlying
implementation.
Authentication Challenges
Responding to an Authentication Challenge
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
31The URL loading system provides a composite on-disk and in-memory cache of responses to requests. This
cache allows an application to reduce its dependency on a network connection and increase its performance.
Using the Cache for a Request
An NSURLRequest instance specifies how the local cache is used by setting the cache policy to one of the
NSURLRequestCachePolicy values: NSURLRequestUseProtocolCachePolicy,
NSURLRequestReloadIgnoringCacheData, NSURLRequestReturnCacheDataElseLoad, or
NSURLRequestReturnCacheDataDontLoad.
The default cache policy for an NSURLRequest instance is NSURLRequestUseProtocolCachePolicy. The
NSURLRequestUseProtocolCachePolicy behavior is protocol specific and is defined as being the best
conforming policy for the protocol.
Setting the cache policy to NSURLRequestReloadIgnoringCacheData causes the URL loading system to
load the data from the originating source, ignoring the cache completely.
The NSURLRequestReturnCacheDataElseLoad cache policy will cause the URL loading system to use
cached data ignoring its age or expiration date, if it exists, and load the data from the originating source only
if there is no cached version.
The NSURLRequestReturnCacheDataDontLoad policy allows an application to specify that only data in the
cache should be returned. Attempting to create an NSURLConnection or NSURLDownload instance with this
cache policy returns nil immediately if the response is not in the local cache. This is similar in function to an
“offline” mode and never brings up a network connection.
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
32
Understanding Cache AccessNote: Currently, only responsesto http and https requests are cached. The ftp and file protocols
attempt to access the originating source as allowed by the cache policy. Custom NSURLProtocol
classes can provide caching if they choose.
Cache Use Semantics for the http Protocol
The most complicated cache use situation is when a request uses the http protocol and has set the cache
policy to NSURLRequestUseProtocolCachePolicy.
If an NSCachedURLResponse does not exist for the request, then the data isfetched from the originating source.
If there is a cached response for the request, the URL loading system checks the response to determine if it
specifies that the contents must be revalidated. If the contents must be revalidated a connection is made to
the originating source to see if it has changed. If it has not changed, then the response is returned from the
local cache. If it has changed, the data is fetched from the originating source.
If the cached response doesn’t specify that the contents must be revalidated, the maximum age or expiration
specified in the response is examined. If the cached response is recent enough, then the response is returned
from the local cache. If the response is determined to be stale, the originating source is checked for newer
data. If newer data is available, the data is fetched from the originating source, otherwise it is returned from
the cache.
RFC 2616, Section 13 (http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13) specifies the semantics
involved in detail.
Understanding Cache Access
Cache Use Semantics for the http Protocol
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
33This table describes the changes to URL Loading System Programming Guide .
Date Notes
2010-09-01 Fixed typos and removed deprecated symbols from code examples.
Restructured content and added discussions of new authentication
functionality.
2010-03-24
2009-08-14 Added links to Cocoa Core Competencies.
2008-05-20 Updated to include content about NSURLDownload availability in iOS.
2008-05-06 Made minor editorial changes.
2007-07-10 Corrected minor typos.
2006-05-23 Added links to sample code.
2006-03-08 Updated sample code.
2005-09-08 Corrected connectionDidFinishLoading: method signature.
2005-04-08 Added accessor method to sample code. Corrected minor typos.
2004-08-31 Corrected minor typos.
Corrected table of contents ordering.
Corrected willSendRequest:redirectResponse: method signature
throughout topic.
2003-07-03
Added additional article outlining differences in behavior between
NSURLDownload and NSURLConnection.
2003-06-11
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
34
Document Revision HistoryDate Notes
First release of conceptual and task material covering the usage of new
classes in Mac OS X v10.2 with Safari 1.0 for downloading content from
the Internet.
2003-06-06
Document Revision History
2010-09-01 | © 2003, 2010 Apple Inc. All Rights Reserved.
35Apple Inc.
© 2003, 2010 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, Mac, Mac OS, OS
X, and Safari are trademarks of Apple Inc.,
registered in the U.S. and other countries.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
External Accessory
Programming TopicsContents
About External Accessories 4
At a Glance 4
Including the External Accessory Framework in Your Project 4
Declaring the Protocols Your App Supports 5
Communicating with an Accessory 5
See Also 5
Connecting to an Accessory 6
Monitoring Accessory-Related Events 9
Document Revision History 10
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
2Listings
Connecting to an Accessory 6
Listing 1 Creating a communications session for an accessory 6
Listing 2 Processing stream events 8
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
3The External Accessory framework (ExternalAccessory.framework) provides a conduit for communicating
with accessories attached to any iOS-based device. App developers can use this conduit to integrate
accessory-level features into their apps.
Communicating with an external accessory requires you to work closely with the accessory manufacturer to
understand the services provided by that accessory. Manufacturers must build explicit support into their
accessory hardware for communicating with iOS. As part of this support, an accessory must support at least
one command protocol, which is a custom scheme for sending data back and forth between the accessory
and an attached app. Apple does not maintain a registry of protocols; it is up to the manufacturer to decide
which protocols to support and whether to use custom protocols or standard protocols supported by other
manufacturers.
As part of your communication with the accessory manufacturer, you must find out what protocols a given
accessory supports. To prevent namespace conflicts, protocol names are specified as reverse-DNS strings of
the form com.apple.myProtocol. This allows each manufacturer to define as many protocols as needed to
support their line of accessories.
Note: If you are interested in becoming a developer of accessories for iPad, iPhone, or iPod touch,
you can find information about how to do so on http://developer.apple.com.
At a Glance
Communicating with accessories requires information about the accessory itself, which you must obtain from
the hardware manufacturer. From there, you use the classes of the External Accessory framework to create the
bridge between the hardware and your app.
Including the External Accessory Framework in Your Project
To use the features of the External Accessory framework, you must add ExternalAccessory.framework
to your Xcode project and link against it in any relevant targets. To access the classes and headers of the
framework, include an #import statement at the top of
any relevant source files.
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
4
About External AccessoriesDeclaring the Protocols Your App Supports
Appsthat are able to communicate with an external accessory must declare the protocolsthey support in their
Info.plist file. Declaring support for specific protocols lets the system know that your app can be launched
when that accessory is connected. If no app supports the connected accessory, the system may choose to
launch the App Store and point out apps that do.
To declare the protocols your app supports, you must include the
UISupportedExternalAccessoryProtocols key in your app’s Info.plist file. This key contains an array
ofstringsthat identify the communications protocolsthat your app supports. Your app can include any number
of protocols in this list and the protocols can be in any order. The system does not use this list to determine
which protocol your app should choose; it uses it only to determine if your app is capable of communicating
with the accessory. It is up to your code to choose an appropriate communications protocol when it begins
talking to the accessory.
For more information about the keys you put into your app’s Info.plist file, see Information Property List
Key Reference .
Communicating with an Accessory
An app communicates with an accessory by creating an EASession object for managing the accessory
interactions. Session objects work with the underlying system to transfer data packetsto and from the accessory.
Data transfer in your app occurs through NSInputStream and NSOutputStream objects, which are vended
by the session object once the connection is made. To receive data from the accessory, monitor the input
stream using a custom delegate object. To send data to the accessory, write data packets to the output stream.
The format of the incoming and outgoing data packetsis determined by the protocol you use to communicate
with the accessory.
Relevant Article: “Connecting to an Accessory” (page 6), “Monitoring Accessory-Related
Events” (page 9)
See Also
For information about the classes of the External Accessory framework, see External Accessory Framework
Reference
About External Accessories
See Also
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
5Accessories are not visible through the External Accessory framework until they have been connected by the
system and made ready for use. When an accessory does become visible, your app can get the appropriate
accessory object and open a session using one or more of the protocols supported by the accessory.
The shared EAAccessoryManager object provides the main entry point for apps looking to communicate
with accessories. This class contains an array of already connected accessory objects that you can enumerate
to see if there is one your app supports. Most of the information in an EAAccessory object (such asthe name,
manufacturer, and model information) is intended for display purposes only. To determine whether your app
can connect to an accessory, you must look at the accessory’s protocols and see if there is one your app
supports.
Note: It is possible for more than one accessory object to support the same protocol. If that happens,
your code is responsible for choosing which accessory object to use.
For a given accessory object, only one session at a time is allowed for a specific protocol. The protocolStrings
property of each EAAccessory object contains a dictionary whose keys are the supported protocols. If you
attempt to create a session using a protocol that is already in use, the External Accessory framework closes
the existing session before opening the new one.
Listing 1 shows a method that checks the list of connected accessories and grabs the first one that the app
supports. It creates a session for the designated protocol and configures the input and output streams of the
session. By the time this method returnsthe session object, it is connected to the accessory and ready to begin
sending and receiving data.
Listing 1 Creating a communications session for an accessory
- (EASession *)openSessionForProtocol:(NSString *)protocolString
{
NSArray *accessories = [[EAAccessoryManager sharedAccessoryManager]
connectedAccessories];
EAAccessory *accessory = nil;
EASession *session = nil;
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
6
Connecting to an Accessoryfor (EAAccessory *obj in accessories)
{
if ([[obj protocolStrings] containsObject:protocolString])
{
accessory = obj;
break;
}
}
if (accessory)
{
session = [[EASession alloc] initWithAccessory:accessory
forProtocol:protocolString];
if (session)
{
[[session inputStream] setDelegate:self];
[[session inputStream] scheduleInRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[[session inputStream] open];
[[session outputStream] setDelegate:self];
[[session outputStream] scheduleInRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
[[session outputStream] open];
[session autorelease];
}
}
return session;
}
After the input and output streams are configured, the final step is to process the stream-related data. Listing
2 shows the fundamental structure of a delegate’s stream processing code. This method responds to events
from both input and output streams of the accessory. As the accessory sends data to your app an event arrives
indicating there are bytes available to be read. Similarly, when the accessory is ready to receive data from your
app, events arrive indicating that fact. (Of course, your app does not always have to wait for an event to arrive
Connecting to an Accessory
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
7before it can write bytes to the stream. It can also call the stream’s hasBytesAvailable method to see if the
accessory is still able to receive data.) For more information on streams and handling stream-related events,
see Stream Programming Guide .
Listing 2 Processing stream events
// Handle communications from the streams.
- (void)stream:(NSStream*)theStream handleEvent:(NSStreamEvent)streamEvent
{
switch (streamEvent)
{
case NSStreamHasBytesAvailable:
// Process the incoming stream data.
break;
case NSStreamEventHasSpaceAvailable:
// Send the next queued command.
break;
default:
break;
}
}
Connecting to an Accessory
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
8The External Accessory framework is capable of sending notifications whenever a hardware accessory is
connected or disconnected. Although it is capable, it does not do so automatically. Your app must specifically
request that notifications be generated by calling the registerForLocalNotifications method of the
EAAccessoryManager class. When an accessory is connected, authenticated, and ready to interact with your
app, the framework sends an EAAccessoryDidConnectNotification notification. When an accessory is
disconnected, it sends an EAAccessoryDidDisconnectNotification notification. You can register to
receive these notifications using the default NSNotificationCenter, and both notifications include
information about which accessory was affected.
In addition to receiving notificationsthrough the default notification center, an app that is currently interacting
with an accessory can assign a delegate to the corresponding EAAccessory object and be notified of changes.
Delegate objects must conform to the EAAccessoryDelegateprotocol, which currently contains the optional
accessoryDidDisconnect: method. You can use this method to receive disconnection notices without
first setting up a notification observer.
If your app is suspended in the background when an accessory notification arrives, that notification is put in
a queue. When your app begins running again (either in the foreground or background), notifications in the
queue are delivered to your app. Notifications are also coalesced and filtered wherever possible to eliminate
any irrelevant events. For example, if an accessory was connected and subsequently disconnected while your
app was suspended, your app would ultimately not receive any indication that such events took place.
For more information about how to register to receive notifications, see Notification Programming Topics.
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
9
Monitoring Accessory-Related EventsThis table describes the changes to External Accessory Programming Topics.
Date Notes
2012-02-24 Clarified that protocols must be declared in an app's Info.plist file.
Corrected information about what happens when you connect to an
existing session.
2011-09-22
2010-05-26 New document describing how to attach to external hardware devices.
2012-02-24 | © 2012 Apple Inc. All Rights Reserved.
10
Document Revision HistoryApple Inc.
© 2012 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, iPad, iPhone, iPod, iPod
touch, and Xcode are trademarks of Apple Inc.,
registered in the U.S. and other countries.
App Store is a service mark of Apple Inc.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Multimedia
Programming GuideContents
About Audio and Video 4
Organization of This Document 4
Using Audio 5
The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions 6
iOS Hardware and Software Audio Codecs 7
Audio Sessions 9
Playing Audio 11
Playing Audio Items with iPod Library Access 12
Playing UI Sound Effects or Invoking Vibration Using System Sound Services 12
Playing Sounds Easily with the AVAudioPlayer Class 15
Playing Sounds with Control Using Audio Queue Services 17
Playing Sounds with Positioning Using OpenAL 21
Recording Audio 21
Recording with the AVAudioRecorder Class 22
Recording with Audio Queue Services 24
Parsing Streamed Audio 25
Audio Unit Support in iOS 26
Best Practices for iOS Audio 27
Tips for Using Audio 27
Preferred Audio Formats in iOS 28
Using Video 30
Recording and Editing Video 30
Playing Video Files 31
Document Revision History 34
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
2Figures, Tables, and Listings
Using Audio 5
Figure 1-1 Using iPod library access 12
Table 1-1 Audio playback formats and codecs 7
Table 1-2 Audio recording formats and codecs 8
Table 1-3 Features provided by the audio session APIs 9
Table 1-4 Handling audio interruptions 11
Table 1-5 System-supplied audio units 26
Table 1-6 Audio tips 27
Listing 1-1 Creating a sound ID object 13
Listing 1-2 Playing a system sound 14
Listing 1-3 Triggering vibration 14
Listing 1-4 Configuring an AVAudioPlayer object 15
Listing 1-5 Implementing an AVAudioPlayer delegate method 16
Listing 1-6 Controlling an AVAudioPlayer object 17
Listing 1-7 Creating an audio queue object 18
Listing 1-8 Setting the playback level directly 20
Listing 1-9 The AudioQueueLevelMeterState structure 21
Listing 1-10 Setting up the audio session and the sound file URL 22
Listing 1-11 A record/stop method using the AVAudioRecorder class 23
Using Video 30
Figure 2-1 Media player interface with transport controls 31
Listing 2-1 Playing full-screen movies 31
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
3Whether multimedia features are central or incidental to your application, iPhone, iPod touch, and iPad users
expect high quality. When presenting video content, take advantage of the device’s high-resolution screen
and high frame rates. When designing the audio portion of your application, keep in mind that compelling
sound adds immeasurably to a user’s overall experience.
You can take advantage of the iOS multimedia frameworks for adding features like:
● High-quality audio recording, playback, and streaming
●
Immersive game sounds
● Live voice chat
● Playback of content from a user’s iPod library
● Video playback and recording on supported devices
In iOS 4.0 and later, the AV Foundation framework gives you fine-grained control over inspecting, editing, and
presenting audio-visual assets.
Organization of This Document
This document contains the following chapters:
●
“Using Audio” (page 5) shows how to use the system’s audio technologies to play and record audio.
●
“Using Video” (page 30) shows how to use the system’s video technologies to play and capture video.
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
4
About Audio and VideoImportant: This document contains information that used to be in iOS App Programming Guide . The
information in this document has not been updated specifically for iOS 4.0.
iOS offers a rich set of toolsfor working with sound in your application. These tools are arranged into frameworks
according to the features they provide, as follows:
● Use the Media Player framework to play songs, audio books, or audio podcasts from a user’s iPod library.
For details, see Media Player Framework Reference , iPod Library Access Programming Guide , and the
AddMusic sample code project.
● Use the AV Foundation framework to play and record audio using a simple Objective-C interface. For
details, see AV Foundation Framework Reference and the avTouch sample code project.
● Use the Audio Toolbox framework to play audio with synchronization capabilities, access packets of
incoming audio, parse audio streams, convert audio formats, and record audio with access to individual
packets. For details, see Audio Toolbox Framework Reference and the SpeakHere sample code project.
● Use the Audio Unit framework to connect to and use audio processing plug-ins. For details, see Audio
Unit Hosting Guide for iOS .
● Use the OpenAL framework to provide positional audio playback in games and other applications. iOS
supports OpenAL 1.1. For information on OpenAL, see the OpenAL website, OpenAL FAQ for iPhone OS ,
and the oalTouch sample code project.
To allow your code to use the features of an audio framework, add that framework to your Xcode project, link
against it in any relevant targets, and add an appropriate #import statement near the top of relevant source
files. For example, to provide access to the AV Foundation framework in a source file, add a #import
statement near the top of the file. For detailed information on how to
add frameworks to your project, see “Files in Projects” in Xcode Project Management Guide .
Important: To use the features of the Audio Unit framework, add the Audio Toolbox framework to your
Xcode project and link against it in any relevant targets. Then add a #import
statement near the top of relevant source files.
This section on sound provides a quick introduction to implementing iOS audio features, as listed here:
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
5
Using Audio● To play songs, audio podcasts, and audio books from a user’s iPod library, see “Playing Audio Items with
iPod Library Access” (page 12).
● To play and record audio in the fewest lines of code, use the AV Foundation framework. See “Playing
Sounds Easily with the AVAudioPlayer Class” (page 15) and “Recording with the AVAudioRecorder
Class” (page 22).
● To provide full-featured audio playback including stereo positioning, level control, and simultaneous
sounds, use OpenAL. See “Playing Sounds with Positioning Using OpenAL” (page 21).
● To provide lowest latency audio, especially when doing simultaneous input and output (such as for a VoIP
application), use the I/O unit or the Voice Processing I/O unit. See “Audio Unit Support in iOS” (page 26).
● To play sounds with the highest degree of control, including support forsynchronization, use Audio Queue
Services. See “Playing Sounds with Control Using Audio Queue Services” (page 17). Audio Queue Services
also supports recording and provides access to incoming audio packets, as described in “Recording with
Audio Queue Services” (page 24).
● To parse audio streamed from a network connection, use Audio File Stream Services. See “Parsing Streamed
Audio” (page 25).
● To play user-interface sound effects, or to invoke vibration on devicesthat provide that feature, use System
Sound Services. See “Playing UI Sound Effects or Invoking Vibration Using System Sound Services” (page
12).
Be sure to read the nextsection,“The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions” (page
6), for critical information on how audio works in iOS. Also read “Best Practices for iOS Audio” (page 27),
which offers guidelines and liststhe audio and file formatsto use for best performance and best user experience.
When you’re ready to dig deeper, the iOS Dev Center contains guides, reference books, sample code, and
more. For tips on how to perform common audio tasks, see Audio & Video Coding How-To's. For in-depth
explanations of audio development in iOS, see Core Audio Overview, Audio Session Programming Guide , Audio
Queue Services Programming Guide , Audio Unit Hosting Guide for iOS , and iPod Library Access Programming
Guide .
The Basics: Audio Codecs, Supported Audio Formats, and Audio
Sessions
To get oriented toward iOS audio development, it’s important to understand a few critical things about the
hardware and software architecture of iOS devices—described in this section.
Using Audio
The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
6iOS Hardware and Software Audio Codecs
To ensure optimum performance and quality, you need to pick the right audio format and audio codec type.
Starting in iOS 3.0, most audio formats can use software-based encoding (for recording) and decoding (for
playback). Software codecs support simultaneous playback of multiple sounds, but may entail significant CPU
overhead.
Hardware-assisted decoding provides excellent performance—but does not support simultaneous playback
of multiple sounds. If you need to maximize video frame rate in your application, minimize the CPU impact of
your audio playback by using uncompressed audio or the IMA4 format, or use hardware-assisted decoding of
your compressed audio assets.
For best-practice advice on picking an audio format, see “Preferred Audio Formats in iOS” (page 28).
Table 1-1 describes the playback audio codecs available on iOS devices.
Table 1-1 Audio playback formats and codecs
Hardware-assisted Software-based decoding
decoding
Audio decoder/playback format
AAC (MPEG-4 Advanced Audio Coding) Yes Yes, starting in iOS 3.0
ALAC (Apple Lossless) Yes Yes, starting in iOS 3.0
HE-AAC (MPEG-4 High Efficiency AAC) Yes -
iLBC (internet Low Bitrate Codec, another format - Yes
for speech)
IMA4 (IMA/ADPCM) - Yes
Linear PCM (uncompressed, linear pulse-code - Yes
modulation)
MP3 (MPEG-1 audio layer 3) Yes Yes, starting in iOS 3.0
µ-law and a-law - Yes
When using hardware-assisted decoding, the device can play only a single instance of one of the supported
formats at a time. For example, if you are playing a stereo MP3 sound using the hardware codec, a second
simultaneous MP3 sound will use software decoding. Similarly, you cannot simultaneously play an AAC and
an ALAC sound using hardware. If the iPod application is playing an AAC or MP3 sound in the background, it
has claimed the hardware codec; your application then plays AAC, ALAC, and MP3 audio using software
decoding.
Using Audio
The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
7To play multiple sounds with best performance, or to efficiently play sounds while the iPod is playing in the
background, use linear PCM (uncompressed) or IMA4 (compressed) audio.
To learn how to check at runtime which hardware and software codecs are available on a device, read the
discussion for the kAudioFormatProperty_HardwareCodecCapabilities constant in Audio Format
Services Reference and read Technical Q&A QA1663, “Determining the availability of the AAC hardware encoder
at runtime.”
To summarize how iOS supports audio formats for single or multiple playback:
● Linear PCM and IMA4 (IMA/ADPCM) You can play multiple linear PCM or IMA4 sounds simultaneously
in iOS without incurring CPU resource problems. The same is true for the iLBC speech-quality format, and
for the µ-law and a-law compressed formats. When using compressed formats, check the sound quality
to ensure it meets your needs.
● AAC, HE-AAC, MP3, and ALAC (Apple Lossless) Playback for AAC, HE-AAC, MP3, and ALAC sounds can
use efficient hardware-assisted decoding on iOS devices, but these codecs all share a single hardware
path. The device can play only a single instance of one of these formats at a time using hardware-assisted
decoding.
The single hardware path for AAC, HE-AAC, MP3, and ALAC playback has implications for “play along” style
applications, such as a virtual piano. If the user is playing a song in one of these three formats in the iPod
application, then your application—to play along over that audio—will employ software decoding.
Table 1-2 describes the recording audio codecs available on iOS devices.
Table 1-2 Audio recording formats and codecs
Audio encoder/recording format Hardware-assisted encoding Software-based encoding
Yes, starting in iOS 4.0 for
iPhone 3GS and iPod
touch (2nd generation)
Yes, starting in iOS 3.1 for
iPhone 3GS and iPod touch
(2nd generation)
Yes, starting in iOS 3.2 for
iPad
AAC (MPEG-4 Advanced Audio Coding)
ALAC (Apple Lossless) - Yes
iLBC (internet Low Bitrate Codec, for - Yes
speech)
IMA4 (IMA/ADPCM) - Yes
Linear PCM (uncompressed, linear - Yes
pulse-code modulation)
Using Audio
The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
8Audio encoder/recording format Hardware-assisted encoding Software-based encoding
µ-law and a-law - Yes
Audio Sessions
The iOS audio session APIs let you define your application’s general audio behavior and design it to work well
within the larger audio context of the device it’s running on. These APIs are described in Audio Session Services
Reference and AVAudioSession Class Reference . Using these APIs, you can specify such behaviors as:
● Whether or not your audio should be silenced by the Silent switch (on iPhone, this is called the Ring/Silent
switch )
● Whether or not your audio should stop upon screen lock
● Whether other audio, such as from the iPod, should continue playing or be silenced when your audio
starts
The audio session APIs also let you respond to user actions, such as the plugging in or unplugging of headsets,
and to events that use the device’s sound hardware, such as Clock and Calendar alarms and incoming phone
calls.
The audio session APIs provide three programmatic features, described in Table 1-3.
Table 1-3 Features provided by the audio session APIs
Audio session feature Description
A category is a key that identifies a set of audio behaviorsfor your application.
By setting a category, you indicate your audio intentions to iOS, such as
whether your audio should continue when the screen locks. There are six
categories, described in “Audio Session Categories”. You can fine-tune the
behavior of some categories, as explained in “Fine-Tuning the Category” in
Audio Session Programming Guide .
Setting categories
Your audio session posts messages when your audio is interrupted, when an
interruption ends, and when the hardware audio route changes. These
messages let you respond gracefully to changes in the larger audio
environment—such as an interruption due to an incoming phone call. For
details, see “Handling Audio Hardware Route Changes” and “Handling Audio
Interruptions”.
Handling interruptions
and route changes
You can query the audio session to discover characteristics of the device your
application isrunning on,such as hardware sample rate, number of hardware
channels, and whether audio input is available. For details, see “Optimizing
for Device Hardware”.
Optimizing for
hardware
characteristics
Using Audio
The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
9There are two interfaces for working with the audio session:
● A streamlined, objective-C interface that gives you accessto the core audio session features and is described
in AVAudioSession Class Reference and AVAudioSessionDelegate Protocol Reference .
● A C-based interface that provides comprehensive access to all basic and advanced audio session features
and is described in Audio Session Services Reference .
You can mix and match audio session code from AV Foundation and Audio Session Services—the interfaces
are completely compatible.
An audio session comes with some default behavior that you can use to get started in development. However,
except for certain special cases, the default behavior is unsuitable for a shipping application that uses audio.
For example, when using the default audio session, audio in your application stops when the Auto-Lock period
times out and the screen locks. If you want to ensure that playback continues with the screen locked, include
the following lines in your application’s initialization code:
NSError *setCategoryErr = nil;
NSError *activationErr = nil;
[[AVAudioSession sharedInstance]
setCategory: AVAudioSessionCategoryPlayback
error: &setCategoryErr];
[[AVAudioSession sharedInstance]
setActive: YES
error: &activationErr];
The AVAudioSessionCategoryPlayback category ensures that playback continues when the screen locks.
Activating the audio session puts the specified category into effect.
How you handle the interruption caused by an incoming phone call or Clock or Calendar alarm depends on
the audio technology you are using, as shown in Table 1-4.
Using Audio
The Basics: Audio Codecs, Supported Audio Formats, and Audio Sessions
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
10Table 1-4 Handling audio interruptions
Audio technology How interruptions work
The AVAudioPlayer and AVAudioRecorder classes provide delegate
methods for interruption start and end. Implement these methods to
update your user interface and optionally, after interruption ends, to
resume paused playback. The system automatically pauses playback or
recording upon interruption, and reactivates your audio session when
you resume playback or recording.
If you want to save and restore playback position between application
launches,save playback position on interruption as well as on application
quit.
AV Foundation framework
These technologies put your application in control of handling
interruptions. You are responsible for saving playback or recording
position and reactivating your audio session after interruption ends.
Implement the AVAudioSession interruption delegate methods or
write an interruption listener callback function.
Audio Queue Services,
I/O audio unit
When using OpenAL for playback, implement the AVAudioSession
interruption delegate methods or write an interruption listener callback
function—as when using Audio Queue Services. However, the delegate
or callback must additionally manage the OpenAL context.
OpenAL
Sounds played using System Sound Services go silent when an
interruption starts. They can automatically be used again if the
interruption ends. Applications cannotinfluence the interruption behavior
for sounds that use this playback technology.
System Sound Services
Every iOS application—with rare exception—should actively manage its audio session. For a complete
explanation of how to do this,read Audio Session ProgrammingGuide . To ensure that your application conforms
to Apple recommendations for audio session behavior, read “Sound” in iOS Human Interface Guidelinesin iOS
Human Interface Guidelines.
Playing Audio
This section introduces you to playing sounds in iOS using iPod library access, System Sound Services, Audio
Queue Services, the AV Foundation framework, and OpenAL.
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
11Playing Audio Items with iPod Library Access
Starting in iOS 3.0, iPod library accesslets your application play a user’ssongs, audio books, and audio podcasts.
The API design makes basic playback very simple while also supporting advanced searching and playback
control.
As shown in Figure 1-1, your application has two ways to retrieve media items. The media item picker, shown
on the left, is an easy-to-use, pre-packaged view controller that behaves like the built-in iPod application’s
music selection interface. For many applications, this is sufficient. If the picker doesn’t provide the specialized
access control you want, the media query interface will. Itsupports predicate-based specification of itemsfrom
the iPod library.
Figure 1-1 Using iPod library access
iPod Library
Music Player
Media Picker Media Query
Your application
As depicted in the figure to the right of your application, you then play the retrieved media items using the
music player provided by this API.
For a complete explanation of how to add media item playback to your application, see iPod Library Access
Programming Guide . For a code example, see the AddMusic sample code project.
Playing UI Sound Effects or Invoking Vibration Using System Sound Services
To play user-interface sound effects (such as button clicks), or to invoke vibration on devices that support it,
use System Sound Services. This compact interface is described in System Sound Services Reference . You can
find sample code in the Audio UI Sounds (SysSound) sample in the iOS Dev Center.
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
12Note: Sounds played with System Sound Services are not subject to configuration using your audio
session. As a result, you cannot keep the behavior of System Sound Services audio in line with other
audio behavior in your application. This is the most important reason to avoid using System Sound
Services for any audio apart from its intended uses.
The AudioServicesPlaySystemSound function lets you very simply play short sound files. The simplicity
carries with it a few restrictions. Your sound files must be:
● No longer than 30 seconds in duration
●
In linear PCM or IMA4 (IMA/ADPCM) format
● Packaged in a .caf, .aif, or .wav file
In addition, when you use the AudioServicesPlaySystemSound function:
● Sounds play at the current system audio volume, with no programmatic volume control available
● Sounds play immediately
● Looping and stereo positioning are unavailable
● Simultaneous playback is unavailable: You can play only one sound at a time
The similar AudioServicesPlayAlertSound function plays a shortsound as an alert. If a user has configured
their device to vibrate in Ring Settings, calling this function invokes vibration in addition to playing the sound
file.
Note: System-supplied alert sounds and system-supplied user-interface sound effects are not
available to your application. For example, using the kSystemSoundID_UserPreferredAlert
constant as a parameter to the AudioServicesPlayAlertSound function will not play anything.
To play a sound with the AudioServicesPlaySystemSound or AudioServicesPlayAlertSound function,
first create a sound ID object, as shown in Listing 1-1.
Listing 1-1 Creating a sound ID object
// Get the main bundle for the app
CFBundleRef mainBundle = CFBundleGetMainBundle ();
// Get the URL to the sound file to play. The file in this case
// is "tap.aif"
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
13soundFileURLRef = CFBundleCopyResourceURL (
mainBundle,
CFSTR ("tap"),
CFSTR ("aif"),
NULL
);
// Create a system sound object representing the sound file
AudioServicesCreateSystemSoundID (
soundFileURLRef,
&soundFileObject
);
Then play the sound, as shown in Listing 1-2.
Listing 1-2 Playing a system sound
- (IBAction) playSystemSound {
AudioServicesPlaySystemSound (self.soundFileObject);
}
In typical use, which includes playing a sound occasionally or repeatedly, retain the sound ID object until your
application quits. If you know that you will use a sound only once—for example, in the case of a startup
sound—you can destroy the sound ID object immediately after playing the sound, freeing memory.
Applicationsrunning on iOS devicesthatsupport vibration can trigger that feature using System Sound Services.
You specify the vibrate option with the kSystemSoundID_Vibrate identifier. To trigger it, use the
AudioServicesPlaySystemSound function, as shown in Listing 1-3.
Listing 1-3 Triggering vibration
#import
#import
- (void) vibratePhone {
AudioServicesPlaySystemSound (kSystemSoundID_Vibrate);
}
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
14If your application is running on an iPod touch, this code does nothing.
Playing Sounds Easily with the AVAudioPlayer Class
The AVAudioPlayer class provides a simple Objective-C interface for playing sounds. If your application does
not require stereo positioning or precise synchronization, and if you are not playing audio captured from a
network stream, Apple recommends that you use this class for playback.
Using an audio player you can:
● Play sounds of any duration
● Play sounds from files or memory buffers
● Loop sounds
● Play multiple sounds simultaneously (although not with precise synchronization)
● Control relative playback level for each sound you are playing
● Seek to a particular point in a sound file, which supports application features such as fast forward and
rewind
● Obtain audio power data that you can use for audio level metering
The AVAudioPlayer class lets you play sound in any audio format available in iOS, as described in Table
1-1 (page 7). For a complete description of this class’s interface, see AVAudioPlayer Class Reference .
To configure an audio player:
1. Assign a sound file to the audio player.
2. Prepare the audio player for playback, which acquires the hardware resources it needs.
3. Designate an audio player delegate object, which handlesinterruptions as well asthe playback-completed
event.
The code in Listing 1-4 illustratesthese steps. It would typically go into an initialization method of the controller
class for your application. (In production code, you’d include appropriate error handling.)
Listing 1-4 Configuring an AVAudioPlayer object
// in the corresponding .h file:
// @property (nonatomic, retain) AVAudioPlayer *player;
// in the .m file:
@synthesize player; // the player object
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
15NSString *soundFilePath =
[[NSBundle mainBundle] pathForResource: @"sound"
ofType: @"wav"];
NSURL *fileURL = [[NSURL alloc] initFileURLWithPath: soundFilePath];
AVAudioPlayer *newPlayer =
[[AVAudioPlayer alloc] initWithContentsOfURL: fileURL
error: nil];
[fileURL release];
self.player = newPlayer;
[newPlayer release];
[player prepareToPlay];
[player setDelegate: self];
The delegate (which can be your controller object) handles interruptions and updates the user interface when
a sound has finished playing. The delegate methods for the AVAudioPlayer class are described in
AVAudioPlayerDelegate Protocol Reference . Listing 1-5 shows a simple implementation of one delegatemethod.
This code updates the title of a Play/Pause toggle button when a sound has finished playing.
Listing 1-5 Implementing an AVAudioPlayer delegate method
- (void) audioPlayerDidFinishPlaying: (AVAudioPlayer *) player
successfully: (BOOL) completed {
if (completed == YES) {
[self.button setTitle: @"Play" forState: UIControlStateNormal];
}
}
To play, pause, or stop an AVAudioPlayer object, call one of its playback control methods. You can test
whether or not playback is in progress by using the playing property. Listing 1-6 shows a basic play/pause
toggle method that controls playback and updates the title of a UIButton object.
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
16Listing 1-6 Controlling an AVAudioPlayer object
- (IBAction) playOrPause: (id) sender {
// if already playing, then pause
if (self.player.playing) {
[self.button setTitle: @"Play" forState: UIControlStateHighlighted];
[self.button setTitle: @"Play" forState: UIControlStateNormal];
[self.player pause];
// if stopped or paused, start playing
} else {
[self.button setTitle: @"Pause" forState: UIControlStateHighlighted];
[self.button setTitle: @"Pause" forState: UIControlStateNormal];
[self.player play];
}
}
The AVAudioPlayer class uses the Objective-C declared properties feature for managing information about a
sound—such as the playback point within the sound’s timeline, and for accessing playback options—such as
volume and looping. For example, you can set the playback volume for an audio player as shown here:
[self.player setVolume: 1.0]; // available range is 0.0 through 1.0
For more information on the AVAudioPlayer class, see AVAudioPlayer Class Reference .
Playing Sounds with Control Using Audio Queue Services
Audio Queue Services adds playback capabilities beyond those available with the AVAudioPlayer class. Using
Audio Queue Services for playback lets you:
● Precisely schedule when a sound plays, allowing synchronization
● Precisely control volume on a buffer-by-buffer basis
● Play audio that you have captured from a stream using Audio File Stream Services
Audio Queue Services lets you play sound in any audio format available in iOS, as described in Table 1-1 (page
7). You can also use this technology for recording, as explained in “Recording Audio” (page 21).
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
17For detailed information on using this technology, see Audio Queue Services Programming Guide and Audio
Queue Services Reference . For sample code, see the SpeakHere sample.
Creating an Audio Queue Object
To create an audio queue object for playback, perform these three steps:
1. Create a data structure to manage information needed by the audio queue, such as the audio format for
the data you want to play.
2. Define a callback function for managing audio queue buffers. The callback uses Audio File Servicesto read
the file you want to play. (In iOS 2.1 and later, you can also use Extended Audio File Services to read the
file.)
3. Instantiate the playback audio queue using the AudioQueueNewOutput function.
Listing 1-7 illustrates these steps using ANSI C. (In production code, you’d include appropriate error handling.)
The SpeakHere sample project shows these same steps in the context of a C++ program.
Listing 1-7 Creating an audio queue object
static const int kNumberBuffers = 3;
// Create a data structure to manage information needed by the audio queue
struct myAQStruct {
AudioFileID mAudioFile;
CAStreamBasicDescription mDataFormat;
AudioQueueRef mQueue;
AudioQueueBufferRef mBuffers[kNumberBuffers];
SInt64 mCurrentPacket;
UInt32 mNumPacketsToRead;
AudioStreamPacketDescription *mPacketDescs;
bool mDone;
};
// Define a playback audio queue callback function
static void AQTestBufferCallback(
void *inUserData,
AudioQueueRef inAQ,
AudioQueueBufferRef inCompleteAQBuffer
) {
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
18myAQStruct *myInfo = (myAQStruct *)inUserData;
if (myInfo->mDone) return;
UInt32 numBytes;
UInt32 nPackets = myInfo->mNumPacketsToRead;
AudioFileReadPackets (
myInfo->mAudioFile,
false,
&numBytes,
myInfo->mPacketDescs,
myInfo->mCurrentPacket,
&nPackets,
inCompleteAQBuffer->mAudioData
);
if (nPackets > 0) {
inCompleteAQBuffer->mAudioDataByteSize = numBytes;
AudioQueueEnqueueBuffer (
inAQ,
inCompleteAQBuffer,
(myInfo->mPacketDescs ? nPackets : 0),
myInfo->mPacketDescs
);
myInfo->mCurrentPacket += nPackets;
} else {
AudioQueueStop (
myInfo->mQueue,
false
);
myInfo->mDone = true;
}
}
// Instantiate an audio queue object
AudioQueueNewOutput (
&myInfo.mDataFormat,
AQTestBufferCallback,
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
19&myInfo,
CFRunLoopGetCurrent(),
kCFRunLoopCommonModes,
0,
&myInfo.mQueue
);
Controlling the Playback Level
Audio queue objects give you two ways to control playback level.
To set playback level directly, use the AudioQueueSetParameter function with the
kAudioQueueParam_Volume parameter, as shown in Listing 1-8. Level change takes effect immediately.
Listing 1-8 Setting the playback level directly
Float32 volume = 1; // linear scale, range from 0.0 through 1.0
AudioQueueSetParameter (
myAQstruct.audioQueueObject,
kAudioQueueParam_Volume,
volume
);
You can also set playback level for an audio queue buffer by using the
AudioQueueEnqueueBufferWithParameters function. This lets you assign audio queue settings that are,
in effect, carried by an audio queue buffer as you enqueue it. Such changes take effect when the buffer begins
playing.
In both cases, level changes for an audio queue remain in effect until you change them again.
Indicating Playback Level
You can obtain the current playback level from an audio queue object by:
1. Enabling metering for the audio queue object by setting its
kAudioQueueProperty_EnableLevelMetering property to true
2. Querying the audio queue object’s kAudioQueueProperty_CurrentLevelMeter property
Using Audio
Playing Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
20The value of this property is an array of AudioQueueLevelMeterState structures, one per channel. Listing
1-9 shows this structure:
Listing 1-9 The AudioQueueLevelMeterState structure
typedef struct AudioQueueLevelMeterState {
Float32 mAveragePower;
Float32 mPeakPower;
}; AudioQueueLevelMeterState;
Playing Multiple Sounds Simultaneously
To play multiple sounds simultaneously, create one playback audio queue object for each sound. For each
audio queue, schedule the first buffer of audio to start at the same time using the
AudioQueueEnqueueBufferWithParameters function.
Starting in iOS 3.0, nearly all supported audio formats can be used for simultaneous playback—namely, all
those that can be played using software decoding, as described in Table 1-1 (page 7). For the most
processor-efficient multiple playback, use linear PCM (uncompressed) or IMA4 (compressed) audio.
Playing Sounds with Positioning Using OpenAL
The open-sourced OpenAL audio API, available in iOS in the OpenAL framework, provides an interface optimized
for positioning sounds in a stereo field during playback. Playing, positioning, and moving sounds works just
asit does on other platforms. OpenAL also lets you mix sounds. OpenAL usesthe I/O unit for playback, resulting
in the lowest latency.
For all of these reasons, OpenAL is your best choice for playing sounds in game applications on iOS-based
devices. However, OpenAL is also a good choice for general iOS application audio playback needs.
OpenAL 1.1 support in iOS is built on top of Core Audio. For more information, see OpenAL FAQ for iPhone OS .
For OpenAL documentation, see the OpenAL website at http://openal.org. For sample code, see oalTouch .
Recording Audio
iOS supports audio recording using the AVAudioRecorder class and Audio Queue Services. These interfaces
do the work of connecting to the audio hardware, managing memory, and employing codecs as needed. You
can record audio in any of the formats listed in Table 1-2 (page 8).
Using Audio
Recording Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
21Recording takes place at a system-defined input level in iOS. The system takes input from the audio source
that the user has chosen—the built-in microphone or, if connected, the headset microphone or other input
source.
Recording with the AVAudioRecorder Class
The easiest way to record sound in iOS is with the AVAudioRecorder class, described in AVAudioRecorder
Class Reference . This class provides a highly-streamlined, Objective-C interface that makes it easy to provide
sophisticated features like pausing/resuming recording and handling audio interruptions. At the same time,
you retain complete control over recording format.
To prepare for recording using an audio recorder:
1. Specify a sound file URL.
2. Set up the audio session.
3. Configure the audio recorder’s initial state.
Application launch is a good time to do this part of the setup, as shown in Listing 1-10. Variables such as
soundFileURL and recording in this example are declared in the class interface. (In production code, you
would include appropriate error handling.)
Listing 1-10 Setting up the audio session and the sound file URL
- (void) viewDidLoad {
[super viewDidLoad];
NSString *tempDir = NSTemporaryDirectory ();
NSString *soundFilePath =
[tempDir stringByAppendingString: @"sound.caf"];
NSURL *newURL = [[NSURL alloc] initFileURLWithPath: soundFilePath];
self.soundFileURL = newURL;
[newURL release];
AVAudioSession *audioSession = [AVAudioSession sharedInstance];
audioSession.delegate = self;
[audioSession setActive: YES error: nil];
Using Audio
Recording Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
22recording = NO;
playing = NO;
}
To handle interruptions and the completion of recording, add the AVAudioSessionDelegate and
AVAudioRecorderDelegate protocol names to the interface declaration for your implementation. If your
application also does playback, also adopt the AVAudioPlayerDelegate Protocol Reference protocol.
To implement a record method, you can use code such as that shown in Listing 1-11. (In production code, you
would include appropriate error handling.)
Listing 1-11 A record/stop method using the AVAudioRecorder class
- (IBAction) recordOrStop: (id) sender {
if (recording) {
[soundRecorder stop];
recording = NO;
self.soundRecorder = nil;
[recordOrStopButton setTitle: @"Record" forState:
UIControlStateNormal];
[recordOrStopButton setTitle: @"Record" forState:
UIControlStateHighlighted];
[[AVAudioSession sharedInstance] setActive: NO error: nil];
} else {
[[AVAudioSession sharedInstance]
setCategory: AVAudioSessionCategoryRecord
error: nil];
NSDictionary *recordSettings =
[[NSDictionary alloc] initWithObjectsAndKeys:
Using Audio
Recording Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
23[NSNumber numberWithFloat: 44100.0], AVSampleRateKey,
[NSNumber numberWithInt: kAudioFormatAppleLossless], AVFormatIDKey,
[NSNumber numberWithInt: 1], AVNumberOfChannelsKey,
[NSNumber numberWithInt: AVAudioQualityMax],
AVEncoderAudioQualityKey,
nil];
AVAudioRecorder *newRecorder =
[[AVAudioRecorder alloc] initWithURL: soundFileURL
settings: recordSettings
error: nil];
[recordSettings release];
self.soundRecorder = newRecorder;
[newRecorder release];
soundRecorder.delegate = self;
[soundRecorder prepareToRecord];
[soundRecorder record];
[recordOrStopButton setTitle: @"Stop" forState: UIControlStateNormal];
[recordOrStopButton setTitle: @"Stop" forState: UIControlStateHighlighted];
recording = YES;
}
}
For more information on the AVAudioRecorder class, see AVAudioRecorder Class Reference .
Recording with Audio Queue Services
To set up for recording with audio with Audio Queue Services, your application instantiates a recording audio
queue object and provides a callback function. The callback storesincoming audio data in memory for immediate
use or writes it to a file for long-term storage.
Just as with playback, you can obtain the current recording audio level from an audio queue object by querying
its kAudioQueueProperty_CurrentLevelMeter property, as described in “Indicating Playback Level” (page
20).
Using Audio
Recording Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
24For detailed examples of how to use Audio Queue Services to record audio, see “Recording Audio” in Audio
Queue Services Programming Guide . For sample code, see the SpeakHere sample.
Parsing Streamed Audio
To play streamed audio content, such as from a network connection, use Audio File Stream Services in concert
with Audio Queue Services. Audio File Stream Services parses audio packets and metadata from common audio
file container formats in a network bitstream. You can also use it to parse packets and metadata from on-disk
files.
In iOS, you can parse the same audio file and bitstream formats that you can in Mac OS X, as follows:
● MPEG-1 Audio Layer 3, used for .mp3 files
● MPEG-2 ADTS, used for the .aac audio data format
● AIFC
● AIFF
● CAF
● MPEG-4, used for .m4a, .mp4, and .3gp files
● NeXT
● WAVE
Having retrieved audio packets, you can play back the recovered sound in any of the formats supported in
iOS, as listed in Table 1-1 (page 7).
For best performance, network streaming applications should use data from Wi-Fi connections. iOS lets you
determine which networks are reachable and available through its System Configuration framework and its
SCNetworkReachabilityRef opaque type, described in SCNetworkReachability Reference . Forsample code,
see the Reachability sample in the iOS Dev Center.
To connect to a network stream, use interfaces from Core Foundation, such as the one described in
CFHTTPMessage Reference . Parse the network packetsto recover audio packets using Audio File StreamServices.
Then buffer the audio packets and send them to a playback audio queue object.
Audio File Stream Services relies on interfaces from Audio File Services, such as the
AudioFramePacketTranslation structure and the AudioFilePacketTableInfo structure. These are
described in Audio File Services Reference .
For more information on using streams, refer to Audio File Stream Services Reference .
Using Audio
Parsing Streamed Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
25Audio Unit Support in iOS
iOS provides a set of audio processing plug-ins, known as audio units, that you can use in any application. The
interfaces in the Audio Unit framework let you open, connect, and use these audio units.
To use the features of the Audio Unit framework, add the Audio Toolbox framework to your Xcode project and
link against it in any relevant targets. Then add a #import statement
near the top of relevant source files. For detailed information on how to add frameworks to your project, see
“Files in Projects” in Xcode Project Management Guide .
Table 1-5 lists the audio units provided in iOS.
Table 1-5 System-supplied audio units
Audio unit Description
The iPod EQ unit, of type kAudioUnitSubType_AUiPodEQ, provides a
simple, preset-based equalizer you can use in your application. For a
demonstration of how to use this audio unit,see the sample code project
iPhoneMixerEQGraphTest.
iPod Equalizer unit
The 3DMixer unit, oftype kAudioUnitSubType_AU3DMixerEmbedded,
lets you mix multiple audio streams, specify stereo output panning,
manipulate playback rate, and more. OpenAL is built on top of this audio
unit and provides a higher-level API well suited for game apps.
3D Mixer unit
The Multichannel Mixer unit, of type kAudioUnitSubType_-
MultiChannelMixer, lets you mix multiple mono or stereo audio
streams to a single stereo stream. It also supports left/right panning for
each input. For a demonstration of how to use this audio unit, see the
sample code project Audio Mixer (MixerHost).
Multichannel Mixer unit
The Remote I/Ounit, oftype kAudioUnitSubType_RemoteIO, connects
to audio input and output hardware and supports realtime I/O. For
demonstrations of how to use this audio unit,see the sample code project
aurioTouch .
Remote I/O unit
The Voice Processing I/O unit, of type kAudioUnitSubType_-
VoiceProcessingIO, has the characteristics of the I/O unit and adds
echo suppression and other features for two-way communication.
Voice Processing I/O unit
The Generic Output unit, of type kAudioUnitSubType_-
GenericOutput, supports converting to and from linear PCM format;
can be used to start and stop a graph.
Generic Output unit
Using Audio
Audio Unit Support in iOS
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
26Audio unit Description
The Converter unit, of type kAudioUnitSubType_AUConverter, lets
you convert audio data from one format to another. You typically obtain
the features of this audio unit by using the Remote I/O unit, which
incorporates a Converter unit.
Converter unit
For more information on using system audio units, see Audio Unit Hosting Guide for iOS . For reference
documentation, see Audio Unit Framework Reference and Audio Unit Processing Graph Services Reference . The
iOS Dev Center provides two sample-code projects that demonstrate use of system audio units: aurioTouch
and iPhoneMultichannelMixerTest.
Best Practices for iOS Audio
This section lists some important tips for using audio in iOS and describes the best audio data formats for
various uses.
Tips for Using Audio
Table 1-6 lists some important tips to keep in mind when using audio in iOS.
Table 1-6 Audio tips
Tip Action
For AAC, MP3, and ALAC (Apple Lossless) audio, decoding can take place
using hardware-assisted codecs. While efficient, this is limited to one audio
stream at a time. If you need to play multiple sounds simultaneously, store
those sounds using the IMA4 (compressed) or linear PCM (uncompressed)
format.
Use compressed audio
appropriately
The afconvert tool in Mac OS X lets you convert to a wide range of audio
data formats and file types. See “Preferred Audio Formats in iOS” (page 28)
and the afconvert man page.
Convert to the data
format and file format
you need
When playing sound with Audio Queue Services, you write a callback that
sends short segments of audio data to audio queue buffers. In some cases,
loading an entire sound file to memory for playback, which minimizes disk
access, is best. In other cases, loading just enough data at a time to keep
the buffers full is best. Test and evaluate which strategy works best for your
application.
Evaluate audiomemory
issues
Using Audio
Best Practices for iOS Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
27Tip Action
Sample rate and the number of bits per sample have a direct impact on the
size of your audio files. If you need to play many such sounds, or
long-duration sounds, consider reducing these valuesto reduce the memory
footprint of the audio data. For example, rather than use 44.1 kHz sampling
rate for sound effects, you could use a 32 kHz (or possibly lower) sample
rate and still provide reasonable quality.
Using monophonic (single-channel) audio instead of stereo (two channel)
reduces file size. For each sound asset, consider whether mono could suit
your needs.
Reduce audio file sizes
by limiting sample
rates, bit depths, and
channels
Use OpenAL when you want a convenient, high-level interface for positioning
sounds in a stereo field or when you need low latency playback. To parse
audio packetsfrom a file or a network stream, use Audio File Stream Services.
For simple playback of single or multiple sounds, use the AVAudioPlayer
class. For recording to a file, use the AVAudioRecorder class. For audio
chat, use the Voice Processing I/O unit. To play audio resources synced from
a user’s iTunes library, use iPod Library Access. When your sole audio need
is to play alerts and user-interface sound effects, use Core Audio’s System
Sound Services. For other audio applications, including playback ofstreamed
audio, precise synchronization, and access to packets of incoming audio,
use Audio Queue Services.
Pick the appropriate
technology
For the lowest possible playback latency, use OpenAL or use the I/O unit
directly.
Code for low latency
Preferred Audio Formats in iOS
For uncompressed (highest quality) audio, use 16-bit, little endian, linear PCM audio data packaged in a CAF
file. You can convert an audio file to this format in Mac OS X using the afconvert command-line tool, as
shown here:
/usr/bin/afconvert -f caff -d LEI16 {INPUT} {OUTPUT}
The afconvert tool lets you convert to a wide range of audio data formats and file types. See the afconvert
man page, and enter afconvert -h at a shell prompt, for more information.
For compressed audio when playing one sound at a time, and when you don’t need to play audio simultaneously
with the iPod application, use the AAC format packaged in a CAF or m4a file.
Using Audio
Best Practices for iOS Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
28For less memory usage when you need to play multiple sounds simultaneously, use IMA4 (IMA/ADPCM)
compression. This reduces file size but entails minimal CPU impact during decompression. As with linear PCM
data, package IMA4 data in a CAF file.
Using Audio
Best Practices for iOS Audio
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
29Important: This document contains information that used to be in iOS App Programming Guide . The
information in this document has not been updated specifically for iOS 4.0.
Recording and Editing Video
Starting in iOS 3.0, you can record video, with included audio, on supported devices. To display the video
recording interface, create and push a UIImagePickerController object, just asfor displaying the still-camera
interface.
To record video, you must first check that the camera source type
(UIImagePickerControllerSourceTypeCamera) is available and that the movie media type
(kUTTypeMovie) is available for the camera. Depending on the media types you assign to the mediaTypes
property, the picker can directly display the still camera or the video camera, or a selection interface that lets
the user choose.
Using the UIImagePickerControllerDelegate protocol, register as a delegate of the image picker. Your
delegate object receives a completed video recording by way of the
imagePickerController:didFinishPickingMediaWithInfo: method.
On supported devices, you can also pick previously-recorded videos from a user’s photo library.
For more information on using the image picker class, see UIImagePickerController Class Reference . For
information on trimming recorded videos, see UIVideoEditorController Class Reference and
UIVideoEditorControllerDelegate Protocol Reference .
In iOS 4.0 and later, you can record from a device’s camera and display the incoming data live on screen. You
use AVCaptureSession to manage data flow from inputs represented by AVCaptureInput objects (which
mediate input from an AVCaptureDevice) to outputs represented by AVCaptureOutput.
In iOS 4.0 and later, you can edit, assemble, and compose video using existing assets or with new raw materials.
Assets are represented by AVAsset, which you can inspect asynchronously for better performance. You use
AVMutableComposition to compose media from one or more sources, then AVAssetExportSession to
encode output of a composition for delivery.
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
30
Using VideoPlaying Video Files
Important: The information in this section currently reflects the usage of the Media Player framework in
iOS 3.1 and earlier. Please see the headers for information about changes to this framework in iOS 4.0.
iOS supportsthe ability to play back video files directly from your application using the Media Player framework,
described in Media Player Framework Reference . Video playback is supported in full screen mode only and can
be used by game developers who want to play short animations or by any developers who want to play media
files. When you start a video from your application, the media player interface takes over, fading the screen to
black and then fading in the video content. You can play a video with or without user controls for adjusting
playback. Enabling some or all of these controls (shown in Figure 2-1) gives the user the ability to change the
volume, change the playback point, or start and stop the video. If you disable all of these controls, the video
plays until completion.
Figure 2-1 Media player interface with transport controls
To initiate video playback, you must know the URL of the file you want to play. For files your application
provides, this would typically be a pointer to a file in your application’s bundle; however, it can also be a pointer
to a file on a remote server. Use this URL to instantiate a new instance of the MPMoviePlayerController
class. This class presides over the playback of your video file and manages user interactions, such as user taps
in the transport controls (if shown). To start playback, call the play method described in MPMediaPlayback
Protocol Reference .
Listing 2-1 shows a sample method that plays back the video at a specified URL. The play method is an
asynchronous call that returns control to the caller while the movie plays. The movie controller loadsthe movie
in a full-screen view, and animates the movie into place on top of the application’s existing content. When
playback is finished, the movie controller sends a notification received by the application controller object, which
releases the movie controller now that it is no longer needed.
Listing 2-1 Playing full-screen movies
-(void) playMovieAtURL: (NSURL*) theURL {
Using Video
Playing Video Files
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
31MPMoviePlayerController* theMovie =
[[MPMoviePlayerController alloc] initWithContentURL: theURL];
theMovie.scalingMode = MPMovieScalingModeAspectFill;
theMovie.movieControlMode = MPMovieControlModeHidden;
// Register for the playback finished notification
[[NSNotificationCenter defaultCenter]
addObserver: self
selector: @selector(myMovieFinishedCallback:)
name: MPMoviePlayerPlaybackDidFinishNotification
object: theMovie];
// Movie playback is asynchronous, so this method returns immediately.
[theMovie play];
}
// When the movie is done, release the controller.
-(void) myMovieFinishedCallback: (NSNotification*) aNotification
{
MPMoviePlayerController* theMovie = [aNotification object];
[[NSNotificationCenter defaultCenter]
removeObserver: self
name: MPMoviePlayerPlaybackDidFinishNotification
object: theMovie];
// Release the movie instance created in playMovieAtURL:
[theMovie release];
}
For a list of supported video formats, see iOS Technology Overview.
Using Video
Playing Video Files
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
32In iOS 4.0 and later, you can play video using AVPlayer in conjunction with an AVPlayerLayer or an
AVSynchronizedLayer object. You can use AVAudioMix and AVVideoComposition to customize the
audio and video parts of playback respectively. You can also use AVCaptureVideoPreviewLayer to display
video as it is being captured by an input device.
Using Video
Playing Video Files
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
33This table describes the changes to Multimedia Programming Guide .
Date Notes
Clarified usage of AudioServicesPlaySystemSound function in “Playing
UI Sound Effects or Invoking Vibration Using System Sound Services” (page
12).
2010-09-01
Updated Table 1-2 (page 8) for iOS 4.0 by clarifying support for AAC
encoding.
2010-05-27
2010-09-01 | © 2010 Apple Inc. All Rights Reserved.
34
Document Revision HistoryApple Inc.
© 2010 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, iPad, iPhone, iPod, iPod
touch, iTunes, Mac, Mac OS, Objective-C, OS X,
and Xcode are trademarks of Apple Inc.,
registered in the U.S. and other countries.
NeXT is a trademark of NeXT Software, Inc.,
registered in the U.S. and other countries.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Concepts in Objective-C
ProgrammingContents
About the Basic Programming Concepts for Cocoa and Cocoa Touch 7
At a Glance 7
How to Use This Document 7
Prerequisites 8
See Also 8
Class Clusters 9
Without Class Clusters: Simple Concept but Complex Interface 9
With Class Clusters: Simple Concept and Simple Interface 10
Creating Instances 10
Class Clusters with Multiple Public Superclasses 11
Creating Subclasses Within a Class Cluster 12
A True Subclass 12
True Subclasses: An Example 14
A Composite Object 16
A Composite Object: An Example 16
Class Factory Methods 20
Delegates and Data Sources 22
How Delegation Works 22
The Form of Delegation Messages 24
Delegation and the Application Frameworks 25
Becoming the Delegate of a Framework Class 26
Locating Objects Through the delegate Property 27
Data Sources 27
Implementing a Delegate for a Custom Class 27
Introspection 29
Evaluating Inheritance Relationships 29
Method Implementation and Protocol Conformance 30
Object Comparison 31
Object Allocation 34
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
2Object Initialization 35
The Form of Initializers 35
Issues with Initializers 36
Implementing an Initializer 38
Multiple Initializers and the Designated Initializer 40
Model-View-Controller 43
Roles and Relationships of MVC Objects 43
Model Objects Encapsulate Data and Basic Behaviors 43
View Objects Present Information to the User 44
Controller Objects Tie the Model to the View 44
Combining Roles 45
Types of Cocoa Controller Objects 45
MVC as a Compound Design Pattern 47
Design Guidelines for MVC Applications 50
Model-View-Controller in Cocoa (OS X) 52
Object Modeling 53
Entities 53
Attributes 54
Relationships 55
Relationship Cardinality and Ownership 56
Accessing Properties 57
Keys 57
Values 57
Key Paths 58
Object Mutability 60
Why Mutable and Immutable Object Variants? 60
Programming with Mutable Objects 62
Creating and Converting Mutable Objects 62
Storing and Returning Mutable Instance Variables 63
Receiving Mutable Objects 64
Mutable Objects in Collections 66
Outlets 67
Receptionist Pattern 68
The Receptionist Design Pattern in Practice 68
When to Use the Receptionist Pattern 71
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
3
ContentsTarget-Action 73
The Target 73
The Action 74
Target-Action in the AppKit Framework 75
Controls, Cells, and Menu Items 75
Setting the Target and Action 77
Actions Defined by AppKit 78
Target-Action in UIKit 78
Toll-Free Bridging 80
Document Revision History 83
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
4
ContentsFigures, Tables, and Listings
Class Clusters 9
Figure 1-1 A simple hierarchy for number classes 9
Figure 1-2 A more complete number class hierarchy 10
Figure 1-3 Class cluster architecture applied to number classes 10
Figure 1-4 An object that embeds a cluster object 16
Table 1-1 Class clusters and their public superclasses 11
Table 1-2 Derived methods and their possible implementations 13
Delegates and Data Sources 22
Figure 3-1 The mechanism of delegation 23
Figure 3-2 A more realistic sequence involving a delegate 23
Listing 3-1 Sample delegation methods with return values 24
Listing 3-2 Sample delegation methods returning void 24
Introspection 29
Listing 4-1 Using the class and superclass methods 29
Listing 4-2 Using isKindOfClass: 30
Listing 4-3 Using respondsToSelector: 31
Listing 4-4 Using conformsToProtocol: 31
Listing 4-5 Using isEqual: 32
Listing 4-6 Overriding isEqual: 32
Object Initialization 35
Figure 6-1 Initialization up the inheritance chain 39
Figure 6-2 Interactions of secondary and designated initializers 41
Model-View-Controller 43
Figure 7-1 Traditional version of MVC as a compound pattern 48
Figure 7-2 Cocoa version of MVC as a compound design pattern 48
Figure 7-3 Coordinating controller as the owner of a nib file 50
Object Modeling 53
Figure 8-1 Employee management application object diagram 54
Figure 8-2 Employees table view 55
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
5Figure 8-3 Relationships in the employee management application 56
Figure 8-4 Relationship cardinality 56
Figure 8-5 Object graph for the employee management application 58
Figure 8-6 Employees table view showing department name 59
Object Mutability 60
Listing 9-1 Returning an immutable copy of a mutable instance variable 63
Listing 9-2 Making a snapshot of a potentially mutable object 65
Receptionist Pattern 68
Figure 11-1 Bouncing KVO updates to the main operation queue 69
Listing 11-1 Declaring the receptionist class 69
Listing 11-2 The class factory method for creating a receptionist object 70
Listing 11-3 Handling the KVO notification 71
Listing 11-4 Creating a receptionist object 71
Target-Action 73
Figure 12-1 How the target-action mechanism works in the control-cell architecture 76
Toll-Free Bridging 80
Table 13-1 Data types that can be used interchangeably between Core Foundation and Foundation 81
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
6
Figures, Tables, and ListingsMany of the programmatic interfaces of the Cocoa and Cocoa Touch frameworks only make sense only if you
are aware of the concepts on which they are based. These concepts express the rationale for many of the core
designs of the frameworks. Knowledge of these concepts will illuminate your software-development practices.
Model layer View layer
Controller layer
Application
delegate
System frameworks
At a Glance
This document contains articles that explain central concepts, design patterns, and mechanisms of the Cocoa
and Cocoa Touch frameworks. The articles are arranged in alphabetical order.
How to Use This Document
If you read this document cover-to-cover, you learn important information about Cocoa and Cocoa Touch
application development. However, most readers come to the articles in this document in one of two ways:
● Other documents—especially those that are intended for novice iOS and OS X developers—which link to
these articles.
●
In-line mini-articles (which appear when you click a dash-underlined word or phrase) that have a link to
an article as a “Definitive Discussion.”
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
7
About the Basic Programming Concepts for Cocoa
and Cocoa TouchPrerequisites
Prior programming experience, especially with object-oriented languages, is recommended.
See Also
The Objective-C Programming Language offers further discussion of many of the language-related concepts
covered in this document.
About the Basic Programming Concepts for Cocoa and Cocoa Touch
Prerequisites
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
8Class clusters are a design pattern that the Foundation framework makes extensive use of. Class clusters group
a number of private concrete subclasses under a public abstract superclass. The grouping of classes in this way
simplifies the publicly visible architecture of an object-oriented framework without reducing its functional
richness. Class clusters are based on the Abstract Factory design pattern.
Without Class Clusters: Simple Concept but Complex Interface
To illustrate the class cluster architecture and its benefits, consider the problem of constructing a class hierarchy
that defines objects to store numbers of different types (char, int, float, double). Because numbers of
different types have many features in common (they can be converted from one type to another and can be
represented as strings, for example), they could be represented by a single class. However, their storage
requirements differ,so it’sinefficient to represent them all by the same class. Taking thisfact into consideration,
one could design the class architecture depicted in Figure 1-1 to solve the problem.
Figure 1-1 A simple hierarchy for number classes
Number is the abstract superclass that declares in its methods the operations common to its subclasses.
However, it doesn’t declare an instance variable to store a number. The subclasses declare such instance
variables and share in the programmatic interface declared by Number.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
9
Class ClustersSo far, this design is relatively simple. However, if the commonly used modifications of these basic C types are
taken into account, the class hierarchy diagram looks more like Figure 1-2.
Figure 1-2 A more complete number class hierarchy
The simple concept—creating a class to hold number values—can easily burgeon to over a dozen classes. The
class cluster architecture presents a design that reflects the simplicity of the concept.
With Class Clusters: Simple Concept and Simple Interface
Applying the class cluster design pattern to this problem yieldsthe class hierarchy in Figure 1-3 (private classes
are in gray).
Figure 1-3 Class cluster architecture applied to number classes
Users of this hierarchy see only one public class, Number, so how is it possible to allocate instances of the
proper subclass? The answer is in the way the abstract superclass handles instantiation.
Creating Instances
The abstract superclass in a class cluster must declare methods for creating instances of its private subclasses.
It’s the superclass’s responsibility to dispense an object of the proper subclass based on the creation method
that you invoke—you don’t, and can’t, choose the class of the instance.
In the Foundation framework, you generally create an object by invoking a +className... method or the
alloc... and init... methods. Taking the Foundation framework’s NSNumber class as an example, you
could send these messages to create number objects:
Class Clusters
With Class Clusters: Simple Concept and Simple Interface
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
10NSNumber *aChar = [NSNumber numberWithChar:’a’];
NSNumber *anInt = [NSNumber numberWithInt:1];
NSNumber *aFloat = [NSNumber numberWithFloat:1.0];
NSNumber *aDouble = [NSNumber numberWithDouble:1.0];
You are not responsible for releasing the objects returned from factory methods. Many classes also provide
the standard alloc... and init... methodsto create objectsthat require you to manage their deallocation.
Each object returned—aChar, anInt, aFloat, and aDouble—may belong to a different private subclass
(and in fact does). Although each object’s class membership is hidden, itsinterface is public, being the interface
declared by the abstract superclass, NSNumber. Although it is not precisely correct, it’s convenient to consider
the aChar, anInt, aFloat, and aDouble objects to be instances of the NSNumber class, because they’re
created by NSNumber class methods and accessed through instance methods declared by NSNumber.
Class Clusters with Multiple Public Superclasses
In the example above, one abstract public class declares the interface for multiple private subclasses. This is a
class cluster in the purest sense. It’s also possible, and often desirable, to have two (or possibly more) abstract
public classes that declare the interface for the cluster. This is evident in the Foundation framework, which
includes the clusters listed in Table 1-1.
Table 1-1 Class clusters and their public superclasses
Class cluster Public superclasses
NSData
NSData
NSMutableData
NSArray
NSArray
NSMutableArray
NSDictionary
NSDictionary
NSMutableDictionary
NSString
NSString
NSMutableString
Class Clusters
Class Clusters with Multiple Public Superclasses
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
11Other clusters of this type also exist, but these clearly illustrate how two abstract nodes cooperate in declaring
the programmatic interface to a class cluster. In each of these clusters, one public node declares methods that
all cluster objects can respond to, and the other node declares methods that are only appropriate for cluster
objects that allow their contents to be modified.
This factoring of the cluster’s interface helps make an object-oriented framework’s programmatic interface
more expressive. For example, imagine an object representing a book that declares this method:
- (NSString *)title;
The book object could return its own instance variable or create a new string object and return that—it doesn’t
matter. It’s clear from this declaration that the returned string can’t be modified. Any attempt to modify the
returned object will elicit a compiler warning.
Creating Subclasses Within a Class Cluster
The class cluster architecture involves a trade-off between simplicity and extensibility: Having a few public
classes stand in for a multitude of private ones makes it easier to learn and use the classes in a framework but
somewhat harder to create subclasses within any of the clusters. However, if it’s rarely necessary to create a
subclass, then the cluster architecture is clearly beneficial. Clusters are used in the Foundation framework in
just these situations.
If you find that a cluster doesn’t provide the functionality your program needs, then a subclass may be in order.
For example, imagine that you want to create an array object whose storage is file-based rather than
memory-based, as in the NSArray class cluster. Because you are changing the underlying storage mechanism
of the class, you’d have to create a subclass.
On the other hand, in some cases it might be sufficient (and easier) to define a class that embeds within it an
object from the cluster. Let’s say that your program needs to be alerted whenever some data is modified. In
this case, creating a simple class that wraps a data object that the Foundation framework defines may be the
best approach. An object of this class could intervene in messages that modify the data, intercepting the
messages, acting on them, and then forwarding them to the embedded data object.
In summary, if you need to manage your object’sstorage, create a true subclass. Otherwise, create a composite
object, one that embeds a standard Foundation framework object in an object of your own design. The following
sections give more detail on these two approaches.
A True Subclass
A new class that you create within a class cluster must:
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
12● Be a subclass of the cluster’s abstract superclass
● Declare its own storage
● Override all initializer methods of the superclass
● Override the superclass’s primitive methods (described below)
Because the cluster’s abstract superclass is the only publicly visible node in the cluster’s hierarchy, the first
point is obvious. This implies that the new subclass will inherit the cluster’s interface but no instance variables,
because the abstract superclass declares none. Thus the second point: The subclass must declare any instance
variables it needs. Finally, the subclass must override any method it inherits that directly accesses an object’s
instance variables. Such methods are called primitive methods.
A class’s primitive methodsform the basisfor itsinterface. For example, take the NSArray class, which declares
the interface to objects that manage arrays of objects. In concept, an array stores a number of data items, each
of which is accessible by index. NSArray expresses this abstract notion through its two primitive methods,
count and objectAtIndex:. With these methods as a base, other methods—derived methods—can be
implemented; Table 1-2 gives two examples of derived methods.
Table 1-2 Derived methods and their possible implementations
Derived Method Possible Implementation
Find the last object by sending the array object this message: [self
objectAtIndex: ([self count] –1)].
lastObject
Find an object by repeatedly sending the array object an objectAtIndex:
message, each time incrementing the index until all objects in the array have
been tested.
containsObject:
The division of an interface between primitive and derived methods makes creating subclasses easier. Your
subclass must override inherited primitives, but having done so can be sure that all derived methods that it
inherits will operate properly.
The primitive-derived distinction applies to the interface of a fully initialized object. The question of how
init... methods should be handled in a subclass also needs to be addressed.
In general, a cluster’s abstract superclass declares a number of init... and + className methods. As
described in “Creating Instances” (page 10), the abstract class decides which concrete subclass to instantiate
based your choice of init... or + className method. You can consider that the abstract class declares
these methods for the convenience of the subclass. Since the abstract class has no instance variables, it has
no need of initialization methods.
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
13Your subclass should declare its own init... (if it needs to initialize its instance variables) and possibly +
className methods. It should not rely on any of those that it inherits. To maintain its link in the initialization
chain, it should invoke its superclass’s designated initializer within its own designated initializer method. It
should also override all other inherited initializer methods and implement them to behave in a reasonable
manner. (See ““The Runtime System”“ in The Objective-C Programming Language for a discussion of designated
initializers.) Within a class cluster, the designated initializer of the abstract superclass is always init.
True Subclasses: An Example
Let’s say that you want to create a subclass of NSArray, named MonthArray, that returns the name of a
month given its index position. However, a MonthArray object won’t actually store the array of month names
as an instance variable. Instead, the method that returns a name given an index position (objectAtIndex:)
will return constantstrings. Thus, only twelve string objects will be allocated, no matter how many MonthArray
objects exist in an application.
The MonthArray class is declared as:
#import
@interface MonthArray : NSArray
{
}
+ monthArray;
- (unsigned)count;
- (id)objectAtIndex:(unsigned)index;
@end
Note that the MonthArray class doesn’t declare an init... method because it has no instance variables to
initialize. The count and objectAtIndex: methodssimply cover the inherited primitive methods, as described
above.
The implementation of the MonthArray class looks like this:
#import "MonthArray.h"
@implementation MonthArray
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
14static MonthArray *sharedMonthArray = nil;
static NSString *months[] = { @"January", @"February", @"March",
@"April", @"May", @"June", @"July", @"August", @"September",
@"October", @"November", @"December" };
+ monthArray
{
if (!sharedMonthArray) {
sharedMonthArray = [[MonthArray alloc] init];
}
return sharedMonthArray;
}
- (unsigned)count
{
return 12;
}
- objectAtIndex:(unsigned)index
{
if (index >= [self count])
[NSException raise:NSRangeException format:@"***%s: index
(%d) beyond bounds (%d)", sel_getName(_cmd), index,
[self count] - 1];
else
return months[index];
}
@end
Because MonthArray overridesthe inherited primitive methods, the derived methodsthat it inherits will work
properly without being overridden. NSArray’s lastObject, containsObject:,
sortedArrayUsingSelector:, objectEnumerator, and other methods work without problems for
MonthArray objects.
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
15A Composite Object
By embedding a private cluster object in an object of your own design, you create a composite object. This
composite object can rely on the cluster object for its basic functionality, only intercepting messages that the
composite object wants to handle in some particular way. This architecture reduces the amount of code you
must write and lets you take advantage of the tested code provided by the Foundation Framework. Figure 1-4
depicts this architecture.
Figure 1-4 An object that embeds a cluster object
The composite object must declare itself to be a subclass of the cluster’s abstract superclass. As a subclass, it
must override the superclass’s primitive methods. It can also override derived methods, but this isn’t necessary
because the derived methods work through the primitive ones.
The count method of the NSArray class is an example; the intervening object’s implementation of a method
it overrides can be as simple as:
- (unsigned)count {
return [embeddedObject count];
}
However, your object could put code for its own purposes in the implementation of any method it overrides.
A Composite Object: An Example
To illustrate the use of a composite object, imagine you want a mutable array object that tests changes against
some validation criteria before allowing any modification to the array’s contents. The example that follows
describes a class called ValidatingArray, which contains a standardmutable array object. ValidatingArray
overrides all of the primitive methods declared in its superclasses, NSArray and NSMutableArray. It also
declares the array, validatingArray, and init methods, which can be used to create and initialize an
instance:
#import
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
16@interface ValidatingArray : NSMutableArray
{
NSMutableArray *embeddedArray;
}
+ validatingArray;
- init;
- (unsigned)count;
- objectAtIndex:(unsigned)index;
- (void)addObject:object;
- (void)replaceObjectAtIndex:(unsigned)index withObject:object;
- (void)removeLastObject;
- (void)insertObject:object atIndex:(unsigned)index;
- (void)removeObjectAtIndex:(unsigned)index;
@end
The implementation file shows how, in an init method of the ValidatingArrayclass, the embedded object
is created and assigned to the embeddedArray variable. Messages that simply access the array but don’t
modify its contents are relayed to the embedded object. Messagesthat could change the contents are scrutinized
(here in pseudocode) and relayed only if they pass the hypothetical validation test.
#import "ValidatingArray.h"
@implementation ValidatingArray
- init
{
self = [super init];
if (self) {
embeddedArray = [[NSMutableArray allocWithZone:[self zone]] init];
}
return self;
}
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
17+ validatingArray
{
return [[[self alloc] init] autorelease];
}
- (unsigned)count
{
return [embeddedArray count];
}
- objectAtIndex:(unsigned)index
{
return [embeddedArray objectAtIndex:index];
}
- (void)addObject:object
{
if (/* modification is valid */) {
[embeddedArray addObject:object];
}
}
- (void)replaceObjectAtIndex:(unsigned)index withObject:object;
{
if (/* modification is valid */) {
[embeddedArray replaceObjectAtIndex:index withObject:object];
}
}
- (void)removeLastObject;
{
if (/* modification is valid */) {
[embeddedArray removeLastObject];
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
18}
}
- (void)insertObject:object atIndex:(unsigned)index;
{
if (/* modification is valid */) {
[embeddedArray insertObject:object atIndex:index];
}
}
- (void)removeObjectAtIndex:(unsigned)index;
{
if (/* modification is valid */) {
[embeddedArray removeObjectAtIndex:index];
}
}
Class Clusters
Creating Subclasses Within a Class Cluster
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
19Class factory methods are implemented by a class as a convenience for clients. They combine allocation and
initialization in one step and return the created object. However, the client receiving this object does not own
the object and thus (per the object-ownership policy) is not responsible for releasing it. These methods are of
the form + (type)className... (where className excludes any prefix).
Cocoa provides plenty of examples, especially among the “value” classes. NSDate includes the following class
factory methods:
+ (id)dateWithTimeIntervalSinceNow:(NSTimeInterval)secs;
+ (id)dateWithTimeIntervalSinceReferenceDate:(NSTimeInterval)secs;
+ (id)dateWithTimeIntervalSince1970:(NSTimeInterval)secs;
And NSData offers the following factory methods:
+ (id)dataWithBytes:(const void *)bytes length:(unsigned)length;
+ (id)dataWithBytesNoCopy:(void *)bytes length:(unsigned)length;
+ (id)dataWithBytesNoCopy:(void *)bytes length:(unsigned)length
freeWhenDone:(BOOL)b;
+ (id)dataWithContentsOfFile:(NSString *)path;
+ (id)dataWithContentsOfURL:(NSURL *)url;
+ (id)dataWithContentsOfMappedFile:(NSString *)path;
Factory methods can be more than a simple convenience. They can not only combine allocation and initialization,
but the allocation can inform the initialization. As an example, let’s say you must initialize a collection object
from a property-list file that encodes any number of elements for the collection (NSString objects, NSData
objects, NSNumber objects, and so on). Before the factory method can know how much memory to allocate
for the collection, it must read the file and parse the property list to determine how many elements there are
and what object type these elements are.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
20
Class Factory MethodsAnother purpose for a classfactory method isto ensure that a certain class(NSWorkspace, for example) vends
a singleton instance. Although an init... method could verify that only one instance exists at any one time
in a program, it would require the prior allocation of a “raw” instance and then, in memory-managed code,
would have to release that instance. A factory method, on the other hand, gives you a way to avoid blindly
allocating memory for an object that you might not use, as in the following example:
static AccountManager *DefaultManager = nil;
+ (AccountManager *)defaultManager {
if (!DefaultManager) DefaultManager = [[self allocWithZone:NULL] init];
return DefaultManager;
}
Class Factory Methods
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
21A delegate is an object that acts on behalf of, or in coordination with, another object when that object encounters
an event in a program. The delegating object is often a responder object—that is, an object inheriting from
NSResponder in AppKit or UIResponder in UIKit—that is responding to a user event. The delegate is an
object that is delegated control of the user interface for that event, or is at least asked to interpret the event
in an application-specific manner.
To better appreciate the value of delegation, it helps to consider an off-the-shelf Cocoa object such as a text
field (an instance of NSTextField or UITextField) or a table view (an instance of NSTableView or
UITableView ). These objects are designed to fulfill a specific role in a generic fashion; a window object in
the AppKit framework, for example, responds to mouse manipulations of its controls and handles such things
as closing, resizing, and moving the physical window. This restricted and generic behavior necessarily limits
what the object can know about how an event affects (or will affect) something elsewhere in the application,
especially when the affected behavior isspecific to your application. Delegation provides a way for your custom
object to communicate application-specific behavior to the off-the-shelf object.
The programming mechanism of delegation gives objects a chance to coordinate their appearance and state
with changes occurring elsewhere in a program, changes usually brought about by user actions. More
importantly, delegation makes it possible for one object to alter the behavior of another object without the
need to inherit from it. The delegate is almost always one of your custom objects, and by definition it
incorporates application-specific logic that the generic and delegating object cannot possibly know itself.
How Delegation Works
The design of the delegation mechanism is simple—see Figure 3-1 (page 23). The delegating class has an
outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and
accessing the value of the outlet. It also declares, without implementing, one or more methods that constitute
a formal protocol or an informal protocol. A formal protocol that uses optional methods—a feature ofObjective-C
2.0—is the preferred approach, but both kinds of protocols are used by the Cocoa frameworks for delegation.
In the informal protocol approach, the delegating class declares methods on a category of NSObject, and the
delegate implements only those methods in which it has an interest in coordinating itself with the delegating
object or affecting that object’s default behavior. If the delegating class declares a formal protocol, the delegate
may choose to implement those methods marked optional, but it must implement the required ones.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
22
Delegates and Data SourcesDelegation follows a common design, illustrated by Figure 3-1.
Figure 3-1 The mechanism of delegation
User just clicked close button;
should window close?
No
windowShouldClose:
Don't close. The window
has unsaved data.
windowDelegate
The methods of the protocol mark significant events handled or anticipated by the delegating object. This
object wants either to communicate these events to the delegate or, for impending events, to request input
or approval from the delegate. For example, when a user clicks the close button of a window in OS X, the
window object sends the windowShouldClose: message to its delegate; this gives the delegate the
opportunity to veto or defer the closing of the window if, for example, the window has associated data that
must be saved (see Figure 3-2).
Figure 3-2 A more realistic sequence involving a delegate
Yes
windowShouldClose:
➌
➊
➍ ➋
aWindow aDelegate
The delegating object sends a message only if the delegate implements the method. It makes this discovery
by invoking the NSObjectmethod respondsToSelector: in the delegate first.
Delegates and Data Sources
How Delegation Works
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
23The Form of Delegation Messages
Delegation methods have a conventional form. They begin with the name of the AppKit or UIKit object doing
the delegating—application, window, control, and so on; this name is in lower-case and without the “NS” or
“UI” prefix. Usually (but not always) this object name is followed by an auxiliary verb indicative of the temporal
status of the reported event. This verb, in other words, indicates whether the event is about to occur (“Should”
or “Will”) or whether it has just occurred (“Did” or “Has”). This temporal distinction helps to categorize those
messagesthat expect a return value and those that don’t. Listing 3-1 includes a few AppKit delegation methods
that expect a return value.
Listing 3-1 Sample delegation methods with return values
- (BOOL)application:(NSApplication *)sender
openFile:(NSString *)filename; // NSApplication
- (BOOL)application:(UIApplication *)application
handleOpenURL:(NSURL *)url; // UIApplicationDelegate
- (UITableRowIndexSet *)tableView:(NSTableView *)tableView
willSelectRows:(UITableRowIndexSet *)selection; // UITableViewDelegate
- (NSRect)windowWillUseStandardFrame:(NSWindow *)window
defaultFrame:(NSRect)newFrame; // NSWindow
The delegate that implements these methods can block the impending event (by returning NO in the first two
methods) or alter a suggested value (the index set and the frame rectangle in the last two methods). It can
even defer an impending event; for example, the delegate implementing the
applicationShouldTerminate:method can delay application termination by returning NSTerminateLater.
Other delegation methods are invoked by messagesthat don’t expect a return value and so are typed to return
void. These messages are purely informational, and the method names often contain “Did”, “Will”, or some
other indication of a transpired or impending event. Listing 3-2 shows a few examples of these kinds of
delegation method.
Listing 3-2 Sample delegation methods returning void
- (void) tableView:(NSTableView*)tableView
mouseDownInHeaderOfTableColumn:(NSTableColumn *)tableColumn; // NSTableView
- (void)windowDidMove:(NSNotification *)notification; // NSWindow
- (void)application:(UIApplication *)application
willChangeStatusBarFrame:(CGRect)newStatusBarFrame; //
UIApplication
Delegates and Data Sources
The Form of Delegation Messages
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
24- (void)applicationWillBecomeActive:(NSNotification *)notification; //
NSApplication
There are a couple of things to note about this last group of methods. The first is that an auxiliary verb of “Will”
(as in the third method) does not necessarily mean that a return value is expected. In this case, the event is
imminent and cannot be blocked, but the message gives the delegate an opportunity to prepare the program
for the event.
The other point of interest concernsthe second and last method declarationsin Listing 3-2 . The sole parameter
of each of these methods is an NSNotification object, which means that these methods are invoked as the
result of the posting of a particular notification. For example, the windowDidMove: method is associated with
the NSWindow notification NSWindowDidMoveNotification. It’s important to understand the relationship
of notifications to delegation messages in AppKit. The delegating object automatically makes its delegate an
observer of all notifications it posts. All the delegate needs to do is implement the associated method to get
the notification.
To make an instance of your custom class the delegate of an AppKit object, simply connect the instance to the
delegate outlet or property in Interface Builder. Or you can set it programmatically through the delegating
object’s setDelegate: method or delegate property, preferably early on, such as in the awakeFromNib
or applicationDidFinishLaunching: method.
Delegation and the Application Frameworks
The delegating object in a Cocoa or Cocoa Touch application is often a responder object such as a
UIApplication, NSWindow, or NSTableView object. The delegate object itself istypically, but not necessarily,
an object, often a custom object, that controls some part of the application (that is, a coordinating controller
object). The following AppKit classes define a delegate:
● NSApplication
● NSBrowser
● NSControl
● NSDrawer
● NSFontManager
● NSFontPanel
● NSMatrix
● NSOutlineView
● NSSplitView
Delegates and Data Sources
Delegation and the Application Frameworks
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
25● NSTableView
● NSTabView
● NSText
● NSTextField
● NSTextView
● NSWindow
The UIKit framework also uses delegation extensively and always implements it using formal protocols. The
application delegate is extremely important in an application running in iOS because it must respond to
application-launch, application-quit, low-memory, and other messages from the application object. The
application delegate must adopt the UIApplicationDelegate protocol.
Delegating objects do not (and should not) retain their delegates. However, clients of delegating objects
(applications, usually) are responsible for ensuring that their delegates are around to receive delegation
messages. To do this, they may have to retain the delegate in memory-managed code. This precaution applies
equally to data sources, notification observers, and targets of action messages. Note that in a garbage-collection
environment, the reference to the delegate is strong because the retain-cycle problem does not apply.
Some AppKit classes have a more restricted type of delegate called a modal delegate . Objects of these classes
(NSOpenPanel, for example) run modal dialogs that invoke a handler method in the designated delegate
when the user clicksthe dialog’s OK button. Modal delegates are limited in scope to the operation of the modal
dialog.
Becoming the Delegate of a Framework Class
A framework class or any other classthat implements delegation declares a delegate property and a protocol
(usually a formal protocol). The protocol liststhe required and optional methodsthat the delegate implements.
For an instance of your class to function as the delegate of a framework object, it must do the following:
● Set your object asthe delegate (by assigning it to the delegate property). You can do this programmatically
or through Interface Builder.
●
If the protocol is formal, declare that your class adopts the protocol in the class definition. For example:
@interface MyControllerClass : UIViewController {
●
Implement all required methods of the protocol and any optional methods that you want to participate
in.
Delegates and Data Sources
Delegation and the Application Frameworks
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
26Locating Objects Through the delegate Property
The existence of delegates has other programmatic uses. For example, with delegates it is easy for two
coordinating controllers in the same program to find and communicate with each other. For example, the
object controlling the application overall can find the controller of the application’sinspector window (assuming
it’s the current key window) using code similar to the following:
id winController = [[NSApp keyWindow] delegate];
And your code can find the application-controller object—by definition, the delegate of the global application
instance—by doing something similar to the following:
id appController = [NSApp delegate];
Data Sources
A data source is like a delegate except that, instead of being delegated control of the user interface, it is
delegated control of data. A data source is an outlet held by NSView and UIView objects such as table views
and outline views that require a source from which to populate their rows of visible data. The data source for
a view is usually the same object that acts as its delegate, but it can be any object. As with the delegate, the
data source must implement one or more methods of an informal protocol to supply the view with the data
it needs and, in more advanced implementations, to handle data that users directly edit in such views.
As with delegates, data sources are objectsthat must be present to receive messagesfrom the objectsrequesting
data. The application that uses them must ensure their persistence, retaining them if necessary in
memory-managed code.
Data sources are responsible for the persistence of the objectsthey hand out to user-interface objects. In other
words, they are responsible for the memory management of those objects. However, whenever a view object
such as an outline view or table view accesses the data from a data source, it retains the objects as long as it
uses the data. But it does not use the data for very long. Typically it holds on to the data only long enough to
display it.
Implementing a Delegate for a Custom Class
To implement a delegate for your custom class, complete the following steps:
● Declare the delegate accessor methods in your class header file.
Delegates and Data Sources
Data Sources
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
27- (id)delegate;
- (void)setDelegate:(id)newDelegate;
●
Implement the accessor methods. In a memory-managed program, to avoid retain cycles, the setter method
should not retain or copy your delegate.
- (id)delegate {
return delegate;
}
- (void)setDelegate:(id)newDelegate {
delegate = newDelegate;
}
In a garbage-collected environment, where retain cycles are not a problem, you should not make the
delegate a weak reference (by using the __weak type modifier). For more on retain cycles, see Advanced
MemoryManagement ProgrammingGuide . Formore on weak referencesin garbage collection,see “Garbage
Collection for Cocoa Essentials” in Garbage Collection Programming Guide .
● Declare a formal or informal protocol containing the programmatic interface for the delegate. Informal
protocols are categories on the NSObject class. If you declare a formal protocol for your delegate, make
sure you mark groups of optional methods with the @optional directive.
“The Form of Delegation Messages” (page 24) gives advice for naming your own delegation methods.
● Before invoking a delegation method, make sure the delegate implements it by sending it a
respondsToSelector: message.
- (void)someMethod {
if ( [delegate respondsToSelector:@selector(operationShouldProceed)]
) {
if ( [delegate operationShouldProceed] ) {
// do something appropriate
}
}
}
The precaution is necessary only for optional methods in a formal protocol or methods of an informal
protocol.
Delegates and Data Sources
Implementing a Delegate for a Custom Class
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
28Introspection is a powerful feature of object-oriented languages and environments, and introspection in
Objective-C and Cocoa is no exception. Introspection refersto the capability of objectsto divulge details about
themselves as objects at runtime. Such details include an object’s place in the inheritance tree, whether it
conforms to a specific protocol, and whether it responds to a certain message. The NSObject protocol and
class define many introspection methodsthat you can use to query the runtime in order to characterize objects.
Used judiciously, introspection makes an object-oriented program more efficient and robust. It can help you
avoid message-dispatch errors, erroneous assumptions of object equality, and similar problems. The following
sections show how you might effectively use the NSObject introspection methods in your code.
Evaluating Inheritance Relationships
Once you know the class an object belongs to, you probably know quite a bit about the object. You might
know what its capabilities are, what attributes it represents, and what kinds of messages it can respond to.
Even if after introspection you are unfamiliar with the classto which an object belongs, you now know enough
to not send it certain messages.
The NSObject protocol declares several methods for determining an object’s position in the class hierarchy.
These methods operate at different granularities. The class and superclass instance methods, for example,
return the Class objects representing the class and superclass, respectively, of the receiver. These methods
require you to compare one Class object with another. Listing 4-1 gives a simple (one might say trivial)
example of their use.
Listing 4-1 Using the class and superclass methods
// ...
while ( id anObject = [objectEnumerator nextObject] ) {
if ( [self class] == [anObject superclass] ) {
// do something appropriate...
}
}
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
29
IntrospectionNote: Sometimes you use the class or superclass methods to obtain an appropriate receiver
for a class message.
More commonly, to check an object’s class affiliation, you would send it a isKindOfClass: or
isMemberOfClass: message. The former method returns whether the receiver is an instance of a given class
or an instance of any class that inherits from that class. A isMemberOfClass: message, on the other hand,
tells you if the receiver is an instance of the specified class. The isKindOfClass: method is generally more
useful because from it you can know at once the complete range of messages you can send to an object.
Consider the code snippet in Listing 4-2.
Listing 4-2 Using isKindOfClass:
if ([item isKindOfClass:[NSData class]]) {
const unsigned char *bytes = [item bytes];
unsigned int length = [item length];
// ...
}
By learning that the object item inheritsfrom the NSData class, this code knowsit can send it the NSDatabytes
and lengthmessages. The difference between isKindOfClass: and isMemberOfClass: becomes apparent
if you assume that item is an instance of NSMutableData. If you use isMemberOfClass: instead of
isKindOfClass:, the code in the conditionalized block is never executed because item is not an instance
of NSData but rather of NSMutableData, a subclass of NSData.
Method Implementation and Protocol Conformance
Two of the more powerful introspection methods of NSObject are respondsToSelector: and
conformsToProtocol:. These methodstell you, respectively, whether an object implements a certain method
and whether an object conforms to a specified formal protocol (that is, adopts the protocol, if necessary, and
implements all the methods of the protocol).
You use these methodsin a similarsituation in your code. They enable you to discover whethersome potentially
anonymous object can respond appropriately to a particular message or set of messages before you send it
any of those messages. By making this check before sending a message, you can avoid the risk of runtime
exceptionsresulting from unrecognized selectors. The AppKit framework implementsinformal protocols—the
basis of delegation—by checking whether delegates implement a delegation method (using
respondsToSelector:) prior to invoking that method.
Introspection
Method Implementation and Protocol Conformance
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
30Listing 4-3 illustrates how you might use the respondsToSelector: method in your code.
Listing 4-3 Using respondsToSelector:
- (void)doCommandBySelector:(SEL)aSelector {
if ([self respondsToSelector:aSelector]) {
[self performSelector:aSelector withObject:nil];
} else {
[_client doCommandBySelector:aSelector];
}
}
Listing 4-4 illustrates how you might use the conformsToProtocol: method in your code.
Listing 4-4 Using conformsToProtocol:
// ...
if (!([((id)testObject) conformsToProtocol:@protocol(NSMenuItem)])) {
NSLog(@"Custom MenuItem, '%@', not loaded; it must conform to the
'NSMenuItem' protocol.\n", [testObject class]);
[testObject release];
testObject = nil;
}
Object Comparison
Although they are not strictly introspection methods, the hash and isEqual: methods fulfill a similar role.
They are indispensable runtime toolsfor identifying and comparing objects. But instead of querying the runtime
for information about an object, they rely on class-specific comparison logic.
The hash and isEqual: methods, both declared by the NSObject protocol, are closely related. The hash
method must be implemented to return an integer that can be used as a table addressin a hash table structure.
If two objects are equal (as determined by the isEqual: method), they must have the same hash value. If
your object could be included in collections such as NSSet objects, you need to define hash and verify the
invariant that if two objects are equal, they return the same hash value. The default NSObject implementation
of isEqual: simply checks for pointer equality.
Introspection
Object Comparison
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
31Using the isEqual: method is straightforward; it compares the receiver against the object supplied as a
parameter. Object comparison frequently informsruntime decisions about whatshould be done with an object.
As Listing 4-5 illustrates, you can use isEqual: to decide whether to perform an action, in this case to save
user preferences that have been modified.
Listing 4-5 Using isEqual:
- (void)saveDefaults {
NSDictionary *prefs = [self preferences];
if (![origValues isEqual:prefs])
[Preferences savePreferencesToDefaults:prefs];
}
If you are creating a subclass, you might need to override isEqual: to add further checksfor points of equality.
The subclass might define an extra attribute that has to be the same value in two instances for them to be
considered equal. For example, say you create a subclass of NSObject called MyWidget that contains two
instance variables, name and data. Both of these must be the same value for two instances of MyWidget to
be considered equal. Listing 4-6 illustrates how you might implement isEqual: for the MyWidget class.
Listing 4-6 Overriding isEqual:
- (BOOL)isEqual:(id)other {
if (other == self)
return YES;
if (!other || ![other isKindOfClass:[self class]])
return NO;
return [self isEqualToWidget:other];
}
- (BOOL)isEqualToWidget:(MyWidget *)aWidget {
if (self == aWidget)
return YES;
if (![(id)[self name] isEqual:[aWidget name]])
return NO;
if (![[self data] isEqualToData:[aWidget data]])
return NO;
return YES;
Introspection
Object Comparison
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
32}
This isEqual: method first checks for pointer equality, then class equality, and finally invokes an object
comparator whose name indicates the class of object involved in the comparison. This type of comparator,
which forcestype checking of the object passed in, is a common convention in Cocoa; the isEqualToString:
method of the NSString class and the isEqualToTimeZone: method of the NSTimeZone class are but two
examples. The class-specific comparator—isEqualToWidget: in this case—performs the checks for name
and data equality.
In all isEqualToType: methods of the Cocoa frameworks, nil is not a valid parameter and implementations
of these methods may raise an exception upon receiving a nil. However, for backward compatibility, isEqual:
methods of the Cocoa frameworks do accept nil, returning NO.
Introspection
Object Comparison
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
33When you allocate an object, part of what happens is what you might expect, given the term. Cocoa allocates
enough memory for the object from a region of application virtual memory. To calculate how much memory
to allocate, it takes the object’s instance variables into account—including their types and order—as specified
by the object’s class.
To allocate an object, you send the message alloc or allocWithZone: to the object’s class. In return, you
get a “raw” (uninitialized) instance of the class. The alloc variant of the method uses the application’s default
zone. A zone is a page-aligned area of memory for holding related objects and data allocated by an application.
See Advanced Memory Management Programming Guide for more information on zones.
An allocation message does other important things besides allocating memory:
●
It sets the object’s retain count to one.
●
It initializes the object’s isainstance variable to point to the object’s class, a runtime object in its own
right that is compiled from the class definition.
●
It initializes all other instance variables to zero (or to the equivalent type for zero, such as nil, NULL, and
0.0).
An object’s isa instance variable is inherited from NSObject, so it is common to all Cocoa objects. After
allocation sets isa to the object’s class, the object is integrated into the runtime’s view of the inheritance
hierarchy and the current network of objects (class and instance) that constitute a program. Consequently an
object can find whatever information it needs at runtime, such as another object’s place in the inheritance
hierarchy, the protocols that other objects conform to, and the location of the method implementations it can
perform in response to messages.
In summary, allocation not only allocates memory for an object but initializes two small but very important
attributes of any object: its isa instance variable and itsretain count. It also sets all remaining instance variables
to zero. But the resulting object is not yet usable. Initializing methods such as init must yet initialize objects
with their particular characteristics and return a functional object.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
34
Object AllocationInitialization sets the instance variables of an object to reasonable and useful initial values. It can also allocate
and prepare other global resources needed by the object, loading them if necessary from an external source
such as a file. Every object that declares instance variables should implement an initializing method—unless
the defaultset-everything-to-zero initialization issufficient. If an object does not implement an initializer, Cocoa
invokes the initializer of the nearest ancestor instead.
The Form of Initializers
NSObject declares the init prototype for initializers; it is an instance method typed to return an object of
type id. Overriding init is fine for subclasses that require no additional data to initialize their objects. But
often initialization depends on external data to set an object to a reasonable initial state. For example, say you
have an Account class; to initialize an Account object appropriately requires a unique account number, and
this must be supplied to the initializer. Thus initializers can take one or more parameters; the only requirement
is that the initializing method begins with the letters “init”. (The stylistic convention init... is sometimes
used to refer to initializers.)
Note: Instead of implementing an initializer with parameters, a subclass can implement only a
simple init method and then use “set” accessor methods immediately after initialization to set the
object to a useful initial state. (Accessor methods enforce encapsulation of object data by setting
and getting the values of instance variables.) Or, if the subclass uses properties and the related access
syntax, it may assign values to the properties immediately after initialization.
Cocoa has plenty of examples of initializers with parameters. Here are a few (with the defining class in
parentheses):
- (id)initWithArray:(NSArray *)array; (from NSSet)
- (id)initWithTimeInterval:(NSTimeInterval)secsToBeAdded sinceDate:(NSDate
*)anotherDate; (from NSDate)
- (id)initWithContentRect:(NSRect)contentRect styleMask:(unsigned int)aStyle
backing:(NSBackingStoreType)bufferingType defer:(BOOL)flag; (from NSWindow)
- (id)initWithFrame:(NSRect)frameRect; (from NSControl and NSView)
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
35
Object InitializationThese initializers are instance methods that begin with “init” and return an object of the dynamic type id.
Other than that, they follow the Cocoa conventions for multiparameter methods, often using WithType: or
FromSource: before the first and most important parameter.
Issues with Initializers
Although init... methods are required by their method signature to return an object, that object is not
necessarily the one that was most recently allocated—the receiver of the init... message. In other words,
the object you get back from an initializer might not be the one you thought was being initialized.
Two conditions prompt the return of something other than the just-allocated object. The first involves two
related situations: when there must be a singleton instance or when the defining attribute of an object must
be unique. Some Cocoa classes—NSWorkspace, for instance—allow only one instance in a program; a class
in such a case must ensure (in an initializer or, more likely, in a class factory method) that only one instance is
created, returning this instance if there is any further request for a new one.
A similar situation arises when an object is required to have an attribute that makes it unique. Recall the
hypothetical Account class mentioned earlier. An account of any sort must have a unique identifier. If the
initializer for this class—say, initWithAccountID:—is passed an identifier that has already been associated
with an object, it must do two things:
● Release the newly allocated object (in memory-managed code)
● Return the Account object previously initialized with this unique identifier
By doing this, the initializer ensures the uniqueness of the identifier while providing what was asked for: an
Account instance with the requested identifier.
Sometimes an init... method cannot perform the initialization requested. For example, an initFromFile:
method expects to initialize an object from the contents of a file, the path to which is passed as a parameter.
But if no file exists at that location, the object cannot be initialized. A similar problem happens if an
initWithArray: initializer is passed an NSDictionary object instead of an NSArray object. When an
init... method cannot initialize an object, it should:
● Release the newly allocated object (in memory-managed code)
● Return nil
Returning nil from an initializer indicates that the requested object cannot be created. When you create an
object, you should generally check whether the returned value is nil before proceeding:
Object Initialization
Issues with Initializers
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
36id anObject = [[MyClass alloc] init];
if (anObject) {
[anObject doSomething];
// more messages...
} else {
// handle error
}
Because an init... method might return nil or an object other than the one explicitly allocated, it is
dangerous to use the instance returned by alloc or allocWithZone: instead of the one returned by the
initializer. Consider the following code:
id myObject = [MyClass alloc];
[myObject init];
[myObject doSomething];
The init method in this example could have returned nil or could have substituted a different object. Because
you can send a message to nil without raising an exception, nothing would happen in the former case except
(perhaps) a debugging headache. But you should always rely on the initialized instance instead of the “raw”
just-allocated one. Therefore, you should nest the allocation message inside the initialization message and
test the object returned from the initializer before proceeding.
id myObject = [[MyClass alloc] init];
if ( myObject ) {
[myObject doSomething];
} else {
// error recovery...
}
Once an object is initialized, you should not initialize it again. If you attempt a reinitialization, the framework
class of the instantiated object often raises an exception. For example, the second initialization in this example
would result in NSInvalidArgumentException being raised.
NSString *aStr = [[NSString alloc] initWithString:@"Foo"];
aStr = [aStr initWithString:@"Bar"];
Object Initialization
Issues with Initializers
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
37Implementing an Initializer
There are several critical rules to follow when implementing an init... method that serves as a class’s sole
initializer or, if there are multiple initializers, its designated initializer (described in “Multiple Initializers and the
Designated Initializer” (page 40)):
● Always invoke the superclass (super) initializer first.
● Check the object returned by the superclass. If it is nil, then initialization cannot proceed; return nil to
the receiver.
● When initializing instance variables that are references to objects, retain or copy the object as necessary
(in memory-managed code).
● After setting instance variables to valid initial values, return self unless:
●
It was necessary to return a substituted object, in which case release the freshly allocated object first
(in memory-managed code).
● A problem prevented initialization from succeeding, in which case return nil.
- (id)initWithAccountID:(NSString *)identifier {
if ( self = [super init] ) {
Account *ac = [accountDictionary objectForKey:identifier];
if (ac) { // object with that ID already exists
[self release];
return [ac retain];
}
if (identifier) {
accountID = [identifier copy]; // accountID is instance variable
[accountDictionary setObject:self forKey:identifier];
return self;
} else {
[self release];
return nil;
}
} else
return nil;
}
Object Initialization
Implementing an Initializer
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
38Note: Although, for the sake of simplicity, this example returns nil if the parameter is nil, the
better Cocoa practice is to raise an exception.
It isn’t necessary to initialize all instance variables of an object explicitly, just those that are necessary to make
the object functional. The default set-to-zero initialization performed on an instance variable during allocation
is often sufficient. Make sure that you retain or copy instance variables, as required for memory management.
The requirement to invoke the superclass’s initializer as the first action is important. Recall that an object
encapsulates not only the instance variables defined by its class but the instance variables defined by all of its
ancestor classes. By invoking the initializer of super first, you help to ensure that the instance variables defined
by classes up the inheritance chain are initialized first. The immediate superclass, in its initializer, invokes the
initializer of its superclass, which invokes the main init... method of its superclass, and so on (see Figure
6-1). The proper order of initialization is critical because the later initializations of subclasses may depend on
superclass-defined instance variables being initialized to reasonable values.
Figure 6-1 Initialization up the inheritance chain
super
super
Class A
Class B
Class C
inherits from
inherits from
self
- (id)initWithName:birthday:
- (id)initWithName:
Instance variables:
NSString *name:
Instance variables:
NSString *name:
NSDate *dob:
- (id)initWithName:birthday:ssn:
Instance variables:
NSString *name:
NSDate *dob:
NSNumber *ssn:
sets
sets
sets
Object Initialization
Implementing an Initializer
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
39Inherited initializers are a concern when you create a subclass. Sometimes a superclass init... method
sufficiently initializes instances of your class. But because it is more likely it won’t, you should override the
superclass’s initializer. If you don’t, the superclass’s implementation is invoked, and because the superclass
knows nothing about your class, your instances may not be correctly initialized.
Multiple Initializers and the Designated Initializer
A class can define more than one initializer. Sometimes multiple initializers let clients of the class provide the
input for the same initialization in different forms. The NSSet class, for example, offers clientsseveral initializers
that accept the same data in different forms; one takes an NSArray object, another a counted list of elements,
and another a nil-terminated list of elements:
- (id)initWithArray:(NSArray *)array;
- (id)initWithObjects:(id *)objects count:(unsigned)count;
- (id)initWithObjects:(id)firstObj, ...;
Some subclasses provide convenience initializers that supply default values to an initializer that takes the full
complement of initialization parameters. Thisinitializer is usually the designated initializer, the most important
initializer of a class. For example, assume there is a Task class and it declares a designated initializer with this
signature:
- (id)initWithTitle:(NSString *)aTitle date:(NSDate *)aDate;
The Task class might include secondary, or convenience, initializersthatsimply invoke the designated initializer,
passing it default values for those parameters the secondary initializer doesn’t explicitly request. This example
shows a designated initializer and a secondary initializer.
- (id)initWithTitle:(NSString *)aTitle {
return [self initWithTitle:aTitle date:[NSDate date]];
}
- (id)init {
return [self initWithTitle:@"Task"];
}
Object Initialization
Multiple Initializers and the Designated Initializer
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
40The designated initializer plays an important role for a class. It ensures that inherited instance variables are
initialized by invoking the designated initializer of the superclass. It is typically the init... method that has
the most parameters and that does most of the initialization work, and it is the initializer that secondary
initializers of the class invoke with messages to self.
When you define a subclass, you must be able to identify the designated initializer of the superclass and invoke
it in your subclass’s designated initializer through a message to super. You must also make sure that inherited
initializers are covered in some way. And you may provide as many convenience initializers as you deem
necessary. When designing the initializers of your class, keep in mind that designated initializers are chained
to each other through messages to super; whereas other initializers are chained to the designated initializer
of their class through messages to self.
An example will make this clearer. Let’s say there are three classes, A, B, and C; class B inherits from class A,
and class C inherits from class B. Each subclass adds an attribute as an instance variable and implements an
init... method—the designated initializer—to initialize this instance variable. They also define secondary
initializers and ensure that inherited initializers are overridden, if necessary. Figure 6-2 illustrates the initializers
of all three classes and their relationships.
Figure 6-2 Interactions of secondary and designated initializers
- (id)init
super
super
Class A
Class B
Class C
inherits from
inherits from
self
- (id)init
- (id)initWithTitle:
self
- (id)initWithTitle:
- (id)initWithTitle:date:
Object Initialization
Multiple Initializers and the Designated Initializer
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
41The designated initializer for each class is the initializer with the most coverage; it is the method that initializes
the attribute added by the subclass. The designated initializer is also the init... method that invokes the
designated initializer of the superclass in a message to super. In this example, the designated initializer of
class C, initWithTitle:date:, invokesthe designated initializer of itssuperclass, initWithTitle:, which
in turn invokes the init method of class A. When creating a subclass, it’s always important to know the
designated initializer of the superclass.
Although designated initializers are thus connected up the inheritance chain through messages to super,
secondary initializers are connected to their class’s designated initializer through messagesto self. Secondary
initializers (as in this example) are frequently overridden versions of inherited initializers. Class C overrides
initWithTitle: to invoke its designated initializer, passing it a default date. This designated initializer, in
turn, invokes the designated initializer of class B, which is the overridden method, initWithTitle:. If you
sent an initWithTitle: message to objects of class B and class C, you’d be invoking different method
implementations. On the other hand, if class C did not override initWithTitle: and you sent the message
to an instance of class C, the class B implementation would be invoked. Consequently, the C instance would
be incompletely initialized (since it would lack a date). When creating a subclass, it’s important to make sure
that all inherited initializers are adequately covered.
Sometimes the designated initializer of a superclass may be sufficient for the subclass, and so there is no need
for the subclass to implement its own designated initializer. Other times, a class’s designated initializer may
be an overridden version of its superclass's designated initializer. This is frequently the case when the subclass
needs to supplement the work performed by the superclass’s designated initializer, even though the subclass
does not add any instance variables of its own (or the instance variables it does add don’t require explicit
initialization).
Object Initialization
Multiple Initializers and the Designated Initializer
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
42The Model-View-Controller design pattern (MVC) is quite old. Variations of it have been around at least since
the early days of Smalltalk. It is a high-level pattern in that it concerns itself with the global architecture of an
application and classifies objects according to the general rolesthey play in an application. It is also a compound
pattern in that it comprises several, more elemental patterns.
Object-oriented programs benefit in several ways by adapting the MVC design pattern for their designs. Many
objectsin these programstend to be more reusable and their interfacestend to be better defined. The programs
overall are more adaptable to changing requirements—in other words, they are more easily extensible than
programs that are not based on MVC. Moreover, many technologies and architectures in Cocoa—such as
bindings, the document architecture, and scriptability—are based on MVC and require that your custom objects
play one of the roles defined by MVC.
Roles and Relationships of MVC Objects
The MVC design pattern considersthere to be three types of objects: model objects, view objects, and controller
objects. The MVC pattern defines the roles that these types of objects play in the application and their lines
of communication. When designing an application, a major step is choosing—or creating custom classes
for—objects that fall into one of these three groups. Each of the three types of objects is separated from the
others by abstract boundaries and communicates with objects of the other types across those boundaries.
Model Objects Encapsulate Data and Basic Behaviors
Model objects represent special knowledge and expertise. They hold an application’s data and define the logic
that manipulates that data. A well-designed MVC application has all its important data encapsulated in model
objects. Any data that is part of the persistent state of the application (whether that persistent state is stored
in files or databases) should reside in the model objects once the data is loaded into the application. Because
they represent knowledge and expertise related to a specific problem domain, they tend to be reusable.
Ideally, a model object has no explicit connection to the user interface used to present and edit it. For example,
if you have a model object that represents a person (say you are writing an address book), you might want to
store a birthdate. That’s a good thing to store in your Person model object. However, storing a date format
string or other information on how that date is to be presented is probably better off somewhere else.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
43
Model-View-ControllerIn practice, thisseparation is not alwaysthe best thing, and there issome room for flexibility here, but in general
a model object should not be concerned with interface and presentation issues. One example where a bit of
an exception isreasonable is a drawing application that has model objectsthat represent the graphics displayed.
It makes sense for the graphic objects to know how to draw themselves because the main reason for their
existence is to define a visual thing. But even in this case, the graphic objects should not rely on living in a
particular view or any view at all, and they should not be in charge of knowing when to draw themselves. They
should be asked to draw themselves by the view object that wants to present them.
View Objects Present Information to the User
A view object knows how to display, and might allow users to edit, the data from the application’s model. The
view should not be responsible forstoring the data it is displaying. (This does not mean the view never actually
stores data it’s displaying, of course. A view can cache data or do similar tricks for performance reasons). A
view object can be in charge of displaying just one part of a model object, or a whole model object, or even
many different model objects. Views come in many different varieties.
View objects tend to be reusable and configurable, and they provide consistency between applications. In
Cocoa, the AppKit framework defines a large number of view objects and provides many of them in the Interface
Builder library. By reusing the AppKit’s view objects, such as NSButton objects, you guarantee that buttons
in your application behave just like buttonsin any other Cocoa application, assuring a high level of consistency
in appearance and behavior across applications.
A view should ensure it is displaying the model correctly. Consequently, it usually needsto know about changes
to the model. Because model objects should not be tied to specific view objects, they need a generic way of
indicating that they have changed.
Controller Objects Tie the Model to the View
A controller object acts as the intermediary between the application's view objects and its model objects.
Controllers are often in charge of making sure the views have access to the model objects they need to display
and act as the conduit through which views learn about changes to the model. Controller objects can also
perform set-up and coordinating tasks for an application and manage the life cycles of other objects.
In a typical Cocoa MVC design, when users enter a value or indicate a choice through a view object, that value
or choice is communicated to a controller object. The controller object might interpret the user input in some
application-specific way and then either may tell a model object what to do with thisinput—for example, "add
a new value" or "delete the current record"—or it may have the model object reflect a changed value in one
of its properties. Based on this same user input, some controller objects might also tell a view object to change
an aspect of its appearance or behavior, such as telling a button to disable itself. Conversely, when a model
object changes—say, a new data source is accessed—the model object usually communicates that change to
a controller object, which then requests one or more view objects to update themselves accordingly.
Model-View-Controller
Roles and Relationships of MVC Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
44Controller objects can be either reusable or nonreusable, depending on their general type. “Types of Cocoa
Controller Objects” (page 45) describes the different types of controller objects in Cocoa.
Combining Roles
One can merge the MVC roles played by an object, making an object, for example, fulfill both the controller
and view roles—in which case, it would be called a view controller. In the same way, you can also have
model-controller objects. For some applications, combining roles like this is an acceptable design.
A model controller is a controller that concerns itself mostly with the model layer. It “owns” the model; its
primary responsibilities are to manage the model and communicate with view objects. Action methods that
apply to the model as a whole are typically implemented in a model controller. The document architecture
provides a number of these methods for you; for example, an NSDocument object (which is a central part of
the document architecture) automatically handles action methods related to saving files.
A view controller is a controller that concerns itself mostly with the view layer. It “owns” the interface (the
views); its primary responsibilities are to manage the interface and communicate with the model. Action
methods concerned with data displayed in a view are typically implemented in a view controller. An
NSWindowController object (also part of the document architecture) is an example of a view controller.
“Design Guidelinesfor MVC Applications” (page 50) offerssome design advice concerning objects with merged
MVC roles.
FurtherReading: Document-BasedApplicationsOverview discussesthedistinctionbetweenamodel
controller and a view controller from another perspective.
Types of Cocoa Controller Objects
“Controller Objects Tie the Model to the View” (page 44) sketches the abstract outline of a controller object,
but in practice the picture is far more complex. In Cocoa there are two general kinds of controller objects:
mediating controllers and coordinating controllers. Each kind of controller object is associated with a different
set of classes and each provides a different range of behaviors.
A mediating controller is typically an object that inherits from the NSControllerclass. Mediating controller
objects are used in the Cocoa bindings technology. They facilitate—or mediate—the flow of data between
view objects and model objects.
Model-View-Controller
Types of Cocoa Controller Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
45iOS Note: AppKit implements the NSController class and its subclasses. These classes and the
bindings technology are not available in iOS.
Mediating controllers are typically ready-made objects that you drag from the Interface Builder library. You
can configure these objects to establish the bindings between properties of view objects and properties of
the controller object, and then between those controller properties and specific properties of a model object.
As a result, when users change a value displayed in a view object, the new value is automatically communicated
to a model object forstorage—via the mediating controller; and when a property of a model changesits value,
that change is communicated to a view for display. The abstract NSController class and its concrete
subclasses—NSObjectController, NSArrayController, NSUserDefaultsController, and
NSTreeController—provide supporting features such as the ability to commit and discard changes and
the management of selections and placeholder values.
A coordinating controller istypically an NSWindowController or NSDocumentControllerobject (available
only in AppKit), or an instance of a custom subclass of NSObject. Its role in an application is to oversee—or
coordinate—the functioning of the entire application or of part of the application,such asthe objects unarchived
from a nib file. A coordinating controller provides services such as:
● Responding to delegation messages and observing notifications
● Responding to action messages
● Managing the life cycle of owned objects (for example, releasing them at the proper time)
● Establishing connections between objects and performing other set-up tasks
NSWindowController and NSDocumentController are classes that are part of the Cocoa architecture for
document-based applications. Instances of these classes provide default implementations for several of the
services listed above, and you can create subclasses of them to implement more application-specific behavior.
You can even use NSWindowController objects to manage windows in an application that is not based on
the document architecture.
A coordinating controller frequently owns the objects archived in a nib file. As File’s Owner, the coordinating
controller is external to the objects in the nib file and manages those objects. These owned objects include
mediating controllers as well as window objects and view objects. See “MVC as a Compound Design
Pattern” (page 47) for more on coordinating controllers as File's Owner.
Instances of custom NSObject subclasses can be entirely suitable as coordinating controllers. These kinds of
controller objects combine both mediating and coordinating functions. For their mediating behavior, they
make use of mechanismssuch astarget-action, outlets, delegation, and notificationsto facilitate the movement
of data between view objects and model objects. They tend to contain a lot of glue code and, because that
code is exclusively application-specific, they are the least reusable kind of object in an application.
Model-View-Controller
Types of Cocoa Controller Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
46Further Reading: For more on the Cocoa bindings technology, see Cocoa Bindings Programming
Topics.
MVC as a Compound Design Pattern
Model-View-Controller is a design pattern that is composed of several more basic design patterns. These basic
patterns work together to define the functional separation and paths of communication that are characteristic
of an MVC application. However, the traditional notion of MVC assigns a set of basic patterns different from
those that Cocoa assigns. The difference primarily lies in the roles given to the controller and view objects of
an application.
In the original (Smalltalk) conception, MVC is made up of the Composite, Strategy, and Observer patterns.
● Composite—The view objectsin an application are actually a composite of nested viewsthat work together
in a coordinated fashion (that is, the view hierarchy). These display components range from a window to
compound views, such as a table view, to individual views, such as buttons. User input and display can
take place at any level of the composite structure.
● Strategy—A controller object implements the strategy for one or more view objects. The view object
confines itself to maintaining its visual aspects, and it delegates to the controller all decisions about the
application-specific meaning of the interface behavior.
● Observer—A model object keeps interested objects in an application—usually view objects—advised of
changes in its state.
The traditional way the Composite, Strategy, and Observer patterns work together is depicted by Figure 7-1:
The user manipulates a view at some level of the composite structure and, as a result, an event is generated.
A controller object receives the event and interprets it in an application-specific way—that is, it applies a
strategy. This strategy can be to request (via message) a model object to change its state or to request a view
Model-View-Controller
MVC as a Compound Design Pattern
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
47object (at some level of the composite structure) to change its behavior or appearance. The model object, in
turn, notifies all objects who have registered as observers when its state changes; if the observer is a view
object, it may update its appearance accordingly.
Figure 7-1 Traditional version of MVC as a compound pattern
User action
Update
Get changed state
Update
Strategy
Controller
Composite
View
Notify
Observer
Model
The Cocoa version of MVC as a compound pattern has some similarities to the traditional version, and in fact
it is quite possible to construct a working application based on the diagram in Figure 7-1. By using the bindings
technology, you can easily create a Cocoa MVC application whose views directly observe model objects to
receive notifications of state changes. However, there is a theoretical problem with this design. View objects
and model objects should be the most reusable objects in an application. View objects represent the "look
and feel" of an operating system and the applications that system supports; consistency in appearance and
behavior is essential, and that requires highly reusable objects. Model objects by definition encapsulate the
data associated with a problem domain and perform operations on that data. Design-wise, it's best to keep
model and view objects separate from each other, because that enhances their reusability.
In most Cocoa applications, notifications of state changes in model objects are communicated to view objects
through controller objects. Figure 7-2 shows this different configuration, which appears much cleaner despite
the involvement of two more basic design patterns.
Figure 7-2 Cocoa version of MVC as a compound design pattern
User action
Update
Update
Notify
Mediator
Strategy
Controller
View Model
Command
Composite
Observer
Model-View-Controller
MVC as a Compound Design Pattern
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
48The controller object in this compound design pattern incorporatesthe Mediator pattern as well asthe Strategy
pattern; it mediates the flow of data between model and view objects in both directions. Changes in model
state are communicated to view objects through the controller objects of an application. In addition, view
objects incorporate the Command pattern through their implementation of the target-action mechanism.
Note: The target-action mechanism, which enables view objects to communicate user input and
choices, can be implemented in both coordinating and mediating controller objects. However, the
design of the mechanism differs in each controller type. For coordinating controllers, you connect
the view object to its target (the controller object) in Interface Builder and specify an action selector
that must conform to a certain signature. Coordinating controllers, by virtue of being delegates of
windows and the global application object, can also be in the responder chain. The bindings
mechanism used by mediating controllers also connects view objects to targets and allows action
signatures with a variable number of parameters of arbitrary types. Mediating controllers, however,
aren’t in the responder chain.
There are practical reasons as well as theoretical ones for the revised compound design pattern depicted in
Figure 7-2, especially when it comesto the Mediator design pattern. Mediating controllers derive from concrete
subclasses of NSController, and these classes, besides implementing the Mediator pattern, offer many
features that applications should take advantage of, such as the management of selections and placeholder
values. And if you opt not to use the bindings technology, your view object could use a mechanism such as
the Cocoa notification center to receive notifications from a model object. But this would require you to create
a custom view subclass to add the knowledge of the notifications posted by the model object.
Model-View-Controller
MVC as a Compound Design Pattern
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
49In a well-designed Cocoa MVC application, coordinating controller objects often own mediating controllers,
which are archived in nib files. Figure 7-3 shows the relationships between the two types of controller objects.
Figure 7-3 Coordinating controller as the owner of a nib file
Owns
Coordinating
Controller
Nib file
Data flow
Data flow
View
Mediating
Controller
Model
Design Guidelines for MVC Applications
The following guidelines apply to Model-View-Controller considerations in the design of applications:
● Although you can use an instance of a custom subclass of NSObject as a mediating controller, there's no
reason to go through all the work required to make it one. Use instead one of the ready-made
NSController objects designed for the Cocoa bindings technology; that is, use an instance of
NSObjectController, NSArrayController, NSUserDefaultsController, or
NSTreeController—or a custom subclass of one of these concrete NSController subclasses.
However, if the application is very simple and you feel more comfortable writing the glue code needed
to implement mediating behavior using outlets and target-action, feel free to use an instance of a custom
NSObject subclass as a mediating controller. In a custom NSObject subclass, you can also implement a
mediating controller in the NSController sense, using key-value coding, key-value observing, and the
editor protocols.
Model-View-Controller
Design Guidelines for MVC Applications
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
50● Although you can combine MVC roles in an object, the best overall strategy is to keep the separation
between roles. This separation enhances the reusability of objects and the extensibility of the program
they're used in. If you are going to merge MVC roles in a class, pick a predominant role for that class and
then (for maintenance purposes) use categories in the same implementation file to extend the class to
play other roles.
● A goal of a well-designed MVC application should be to use as many objects as possible that are
(theoretically, at least) reusable. In particular, view objects and model objects should be highly reusable.
(The ready-made mediating controller objects, of course, are reusable.) Application-specific behavior is
frequently concentrated as much as possible in controller objects.
● Although it is possible to have views directly observe models to detect changes in state, it is best not to
do so. A view object should always go through a mediating controller object to learn about changes in
an model object. The reason is two-fold:
●
If you use the bindings mechanism to have view objects directly observe the properties of model
objects, you bypass all the advantages that NSController and its subclasses give your application:
selection and placeholder management as well as the ability to commit and discard changes.
●
If you don't use the bindings mechanism, you have to subclass an existing view classto add the ability
to observe change notifications posted by a model object.
● Strive to limit code dependency in the classes of your application. The greater the dependency a class has
on another class, the less reusable it is. Specific recommendations vary by the MVC roles of the two classes
involved:
● A view classshouldn't depend on a model class(although this may be unavoidable with some custom
views).
● A view class shouldn't have to depend on a mediating controller class.
● A model class shouldn't depend on anything other than other model classes.
● A mediating controller class shouldn’t depend on a model class (although, like views, this may be
necessary if it's a custom controller class).
● A mediating controller class shouldn't depend on view classes or on coordinating controller classes.
● A coordinating controller class depends on classes of all MVC role types.
●
If Cocoa offers an architecture that solves a programming problem, and this architecture assigns MVC
roles to objects of specific types, use that architecture. It will be much easier to put your project together
if you do. The document architecture, for example, includes an Xcode project template that configures
an NSDocument object (per-nib model controller) as File's Owner.
Model-View-Controller
Design Guidelines for MVC Applications
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
51Model-View-Controller in Cocoa (OS X)
The Model-View-Controller design pattern is fundamental to many Cocoa mechanisms and technologies. As
a consequence, the importance of using MVC in object-oriented design goes beyond attaining greater reusability
and extensibility for your own applications. If your application is to incorporate a Cocoa technology that is
MVC-based, your application will work best if its design also follows the MVC pattern. It should be relatively
painless to use these technologies if your application has a good MVC separation, but it will take more effort
to use such a technology if you don’t have a good separation.
Cocoa in OS X includes the following architectures, mechanisms, and technologies that are based on
Model-View-Controller:
● Document architecture. In this architecture, a document-based application consists of a controller object
for the entire application (NSDocumentController), a controller object for each document window
(NSWindowController), and an object that combines controller and model roles for each document
(NSDocument).
● Bindings. MVC is central to the bindings technology of Cocoa. The concrete subclasses of the abstract
NSController provide ready-made controller objects that you can configure to establish bindings
between view objects and properly designed model objects.
● Application scriptability. When designing an application to make it scriptable, it is essential not only that
it follow the MVC design pattern but that your application’s model objects are properly designed. Scripting
commandsthat access application state and request application behaviorshould usually be sent to model
objects or controller objects.
● Core Data. The Core Data framework manages graphs of model objects and ensures the persistence of
those objects by saving them to (and retrieving them from) a persistentstore. Core Data istightly integrated
with the Cocoa bindings technology. The MVC and object modeling design patterns are essential
determinants of the Core Data architecture.
● Undo. In the undo architecture, model objects once again play a central role. The primitive methods of
model objects (which are usually its accessor methods) are often where you implement undo and redo
operations. The view and controller objects of an action may also be involved in these operations; for
example, you might have such objects give specific titles to the undo and redo menu items, or you might
have them undo selections in a text view.
Model-View-Controller
Model-View-Controller in Cocoa (OS X)
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
52This section defines terms and presents examples of object modeling and key-value coding that are specific
to Cocoa bindings and the Core Data framework. Understanding terms such as key paths is fundamental to
using these technologies effectively. This section is recommended reading if you are new to object-oriented
design or key-value coding.
When using the Core Data framework, you need a way to describe your model objects that does not depend
on views and controllers. In a good reusable design, views and controllers need a way to access model properties
without imposing dependencies between them. The Core Data framework solves this problem by borrowing
concepts and terms from database technology—specifically, the entity-relationship model.
Entity-relationship modeling is a way of representing objects typically used to describe a data source’s data
structures in a way that allows those data structures to be mapped to objects in an object-oriented system.
Note that entity-relationship modeling isn’t unique to Cocoa; it’s a popular discipline with a set of rules and
terms that are documented in database literature. It is a representation that facilitates storage and retrieval of
objects in a data source. A data source can be a database, a file, a web service, or any other persistent store.
Because it is not dependent on any type of data source it can also be used to represent any kind of object and
its relationship to other objects.
In the entity-relationship model, the objects that hold data are called entities, the components of an entity are
called attributes, and the referencesto other data-bearing objects are called relationships. Together, attributes
and relationships are known as properties. With these three simple components (entities, attributes, and
relationships), you can model systems of any complexity.
Cocoa uses a modified version of the traditional rules of entity-relationship modeling referred to in this document
as object modeling . Object modeling is particularly useful in representing model objects in the
Model-View-Controller (MVC) design pattern. Thisis notsurprising because even in a simple Cocoa application,
models are typically persistent—that is, they are stored in a data container such as a file.
Entities
Entities are model objects. In the MVC design pattern, model objects are the objects in your application that
encapsulate specified data and provide methods that operate on that data. They are usually persistent but
more importantly, model objects are not dependent on how the data is displayed to the user.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
53
Object ModelingFor example, a structured collection of model objects (an object model) can be used to represent a company’s
customer base, a library of books, or a network of computers. A library book has attributes—such as the book
title, ISBN number, and copyright date—and relationships to other objects—such as the author and library
member. In theory, if the parts of a system can be identified, the system can be expressed as an object model.
Figure 8-1 shows an example object model used in an employee management application. In this model,
Department models a department and Employee models an employee.
Figure 8-1 Employee management application object diagram
Department
name
budget
Employee
firstName
lastName
salary
Attributes
Attributes represent structures that contain data. An attribute of an object may be a simple value, such as a
scalar (for example, an integer, float, or double value), but can also be a C structure (for example an array
of char values or an NSPoint structure) or an instance of a primitive class (such as, NSNumber, NSData, or
NSColor in Cocoa). Immutable objects such as NSColor are usually considered attributes too. (Note that Core
Data natively supports only a specific set of attribute types, as described in NSAttributeDescription Class
Reference . You can, however, use additional attribute types, as described in “Non-Standard Persistent Attributes”
in Core Data Programming Guide .)
Object Modeling
Attributes
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
54In Cocoa, an attribute typically corresponds to a model’s instance variable or accessor method. For example,
Employee has firstName, lastName, and salary instance variables. In an employee management application,
you might implement a table view to display a collection of Employee objects and some of their attributes, as
shown in Figure 8-2. Each row in the table correspondsto an instance of Employee, and each column corresponds
to an attribute of Employee.
Figure 8-2 Employees table view
Relationships
Not all properties of a model are attributes—some properties are relationshipsto other objects. Your application
is typically modeled by multiple classes. At runtime, your object model is a collection of related objects that
make up an object graph. These are typically the persistent objects that your users create and save to some
data container or file before terminating the application (asin a document-based application). The relationships
between these model objects can be traversed at runtime to access the properties of the related objects.
For example, in the employee management application, there are relationships between an employee and the
department in which the employee works, and between an employee and the employee’s manager. Because
a manager is also an employee, the employee–manager relationship is an example of a reflexive relationship—a
relationship from an entity to itself.
Relationships are inherently bidirectional, so conceptually at least there are also relationships between a
department and the employees that work in the department, and an employee and the employee’s direct
reports. Figure 8-3 (page 56) illustrates the relationships between a Department and an Employee entity, and
the Employee reflexive relationship. In this example, the Department entity’s “employees” relationship is the
inverse of the Employee entity’s “department” relationship. It is possible, however, for relationships to be
navigable in only one direction—for there to be no inverse relationship. If, for example, you are never interested
in finding out from a department object what employees are associated with it, then you do not have to model
Object Modeling
Relationships
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
55that relationship. (Note that although thisistrue in the general case, Core Data may impose additional constraints
over general Cocoa object modeling—not modeling the inverse should be considered an extremely advanced
option.)
Figure 8-3 Relationships in the employee management application
Department
name
budget
Employee
firstName
lastName
salary
department employees manager
directReports
Relationship Cardinality and Ownership
Every relationship has a cardinality ; the cardinality tells you how many destination objects can (potentially)
resolve the relationship. If the destination object is a single object, then the relationship is called a to-one
relationship . If there may be more than one object in the destination, then the relationship is called a to-many
relationship .
Relationships can be mandatory or optional. A mandatory relationship is one where the destination is
required—for example, every employee must be associated with a department. An optional relationship is, as
the name suggests, optional—for example, not every employee has direct reports. So the directReports
relationship depicted in Figure 8-4 (page 56) is optional.
It is also possible to specify a range for the cardinality. An optional to-one relationship has a range 0-1. An
employee may have any number of direct reports, or a range that specifies a minimum and a maximum, for
example, 0-15, which also illustrates an optional to-many relationship.
Figure 8-4 illustrates the cardinalities in the employee management application. The relationship between an
Employee object and a Department object is a mandatory to-one relationship—an employee must belong to
one, and only one, department. The relationship between a Department and its Employee objectsis an optional
to-many relationship (represented by a “*”). The relationship between an employee and a manager is an
optional to-one relationship (denoted by the range 0-1)—top-ranking employees do not have managers.
Figure 8-4 Relationship cardinality
1 department employees * 0..1 manager
* directReports
Department
name
budget
Employee
firstName
lastName
salary
Note also that destination objects of relationships are sometimes owned and sometimes shared.
Object Modeling
Relationships
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
56Accessing Properties
In order for models, views, and controllers to be independent of each other, you need to be able to access
properties in a way that is independent of a model’s implementation. This is accomplished by using key-value
pairs.
Keys
You specify properties of a model using a simple key, often a string. The corresponding view or controller uses
the key to look up the corresponding attribute value. This design enforces the notion that the attribute itself
doesn’t necessarily contain the data—the value can be indirectly obtained or derived.
Key-value coding is used to perform thislookup; it is a mechanism for accessing an object’s propertiesindirectly
and, in certain contexts, automatically. Key-value coding works by using the names of the object’s
properties—typically itsinstance variables or accessor methods—as keysto accessthe values of those properties.
For example, you might obtain the name of a Department object using a name key. If the Department object
either has an instance variable or a method called name then a value for the key can be returned (if it doesn’t
have either, an error is returned). Similarly, you might obtain Employee attributes using the firstName,
lastName, and salary keys.
Values
All values for a particular attribute of a given entity are of the same data type. The data type of an attribute is
specified in the declaration of its corresponding instance variable or in the return value of its accessor method.
For example, the data type of the Department object name attribute may be an NSString object in Objective-C.
Note that key-value coding returns only object values. If the return type or the data type for the specific accessor
method or instance variable used to supply the value for a specified key is not an object, then an NSNumber
or NSValue object is created for that value and returned in its place. If the name attribute of Department is of
type NSString, then, using key-value coding, the value returned for the name key of a Department object is
an NSString object. If the budget attribute of Department is of type float, then, using key-value coding,
the value returned for the budget key of a Department object is an NSNumber object.
Similarly, when you set a value using key-value coding, if the data type required by the appropriate accessor
or instance variable for the specified key is not an object, then the value is extracted from the passed object
using the appropriate -typeValue method.
The value of a to-one relationship is simply the destination object of that relationship. For example, the value
of the department property of an Employee object is a Department object. The value of a to-many relationship
is the collection object. The collection can be a set or an array. If you use Core Data it is a set; otherwise, it is
Object Modeling
Accessing Properties
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
57typically an array) that contains the destination objects of that relationship. For example, the value of the
employees property of an Department object is a collection containing Employee objects. Figure 8-5 shows
an example object graph for the employee management application.
Figure 8-5 Object graph for the employee management application
Department
name: "Marketing"
budget: 2000000
employees
Collection
Collection
Employee
firstName: "Toni"
lastName: "Lau"
salary: 7000
manager
department
directReports
Employee
firstName: "Joe"
lastName: "Jackson"
salary: 5000
manager
department
directReports
Key Paths
A key path is a string of dot-separated keysthatspecify a sequence of object propertiesto traverse. The property
of the first key is determined by, and each subsequent key is evaluated relative to, the previous property. Key
paths allow you to specify the properties of related objects in a way that is independent of the model
implementation. Using key paths you can specify the path through an object graph, of whatever depth, to a
specific attribute of a related object.
The key-value coding mechanism implements the lookup of a value given a key path similar to key-value pairs.
For example, in the employee-management application you might access the name of a Department via an
Employee object using the department.name key path where department is a relationship of Employee
and name is an attribute of Department. Key paths are useful if you want to display an attribute of a destination
Object Modeling
Accessing Properties
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
58entity. For example, the employee table view in Figure 8-6 is configured to display the name of the employee’s
department object, not the department object itself. Using Cocoa bindings, the value of the Department
column is bound to department.name of the Employee objects in the displayed array.
Figure 8-6 Employees table view showing department name
Not every relationship in a key path necessarily has a value. For example, the manager relationship can be
nil if the employee is the CEO. In this case, the key-value coding mechanism does not break—it simply stops
traversing the path and returns an appropriate value, such as nil.
Object Modeling
Accessing Properties
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
59Cocoa objects are either mutable or immutable. You cannot change the encapsulated values of immutable
objects; once such an object is created, the value it represents remains the same throughout the object’s life.
But you can change the encapsulated value of a mutable object at any time. The following sections explain
the reasons for having mutable and immutable variants of an object type, describe the characteristics and
side-effects of object mutability, and recommend how best to handle objects when their mutability is an issue.
Why Mutable and Immutable Object Variants?
Objects by default are mutable. Most objects allow you to change their encapsulated data through setter
accessor methods. For example, you can change the size, positioning, title, buffering behavior, and other
characteristics of an NSWindow object. A well-designed model object—say, an object representing a customer
record—requires setter methods to change its instance data.
The Foundation framework adds some nuance to this picture by introducing classes that have mutable and
immutable variants. The mutable subclasses are typically subclasses of their immutable superclass and have
“Mutable” embedded in the class name. These classes include the following:
NSMutableArray
NSMutableDictionary
NSMutableSet
NSMutableIndexSet
NSMutableCharacterSet
NSMutableData
NSMutableString
NSMutableAttributedString
NSMutableURLRequest
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
60
Object MutabilityNote: Except for NSMutableParagraphStyle in the AppKit framework, the Foundation framework
currently defines all explicitly named mutable classes. However, any Cocoa framework can potentially
have its own mutable and immutable class variants.
Although these classes have atypical names, they are closer to the mutable norm than their immutable
counterparts. Why this complexity? What purpose does having an immutable variant of a mutable objectserve?
Consider a scenario where all objects are capable of being mutated. In your application you invoke a method
and are handed back a reference to an object representing a string. You use this string in your user interface
to identify a particular piece of data. Now another subsystem in your application gets its own reference to that
same string and decidesto mutate it. Suddenly your label has changed out from under you. Things can become
even more dire if, for instance, you get a reference to an array that you use to populate a table view. The user
selects a row corresponding to an object in the array that has been removed by some code elsewhere in the
program, and problems ensue. Immutability is a guarantee that an object won’t unexpectedly change in value
while you’re using it.
Objects that are good candidates for immutability are ones that encapsulate collections of discrete values or
contain values that are stored in buffers (which are themselves kinds of collections, either of characters or
bytes). But not all such value objects necessarily benefit from having mutable versions. Objects that contain a
single simple value, such as instances of NSNumber or NSDate, are not good candidates for mutability. When
the represented value changes in these cases, it makes more sense to replace the old instance with a new
instance.
Performance is also a reason for immutable versions of objects representing things such as strings and
dictionaries. Mutable objectsfor basic entitiessuch asstrings and dictionaries bring some overhead with them.
Because they must dynamically manage a changeable backing store—allocating and deallocating chunks of
memory as needed—mutable objects can be less efficient than their immutable counterparts.
Although in theory immutability guarantees that an object’s value is stable, in practice this guarantee isn’t
always assured. A method may choose to hand out a mutable object under the return type of its immutable
variant; later, it may decide to mutate the object, possibly violating assumptions and choices the recipient has
made based on the earlier value. The mutability of an object itself may change as it undergoes various
transformations. For example, serializing a property list (using the NSPropertyListSerialization class)
does not preserve the mutability aspect of objects, only their general kind—a dictionary, an array, and so on.
Thus, when you deserialize this property list, the resulting objects might not be of the same class asthe original
objects. For instance, what was once an NSMutableDictionary object might now be a NSDictionary
object.
Object Mutability
Why Mutable and Immutable Object Variants?
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
61Programming with Mutable Objects
When the mutability of objects is an issue, it’s best to adopt some defensive programming practices. Here are
a few general rules or guidelines:
● Use a mutable variant of an object when you need to modify its contents frequently and incrementally
after it has been created.
● Sometimes it’s preferable to replace one immutable object with another; for example, most instance
variables that hold string values should be assigned immutable NSString objects that are replaced with
setter methods.
● Rely on the return type for indications of mutability.
●
If you have any doubts about whether an object is, or should be, mutable, go with immutable.
This section explores the gray areas in these guidelines, discussing typical choices you have to make when
programming with mutable objects. It also gives an overview of methods in the Foundation framework for
creating mutable objects and for converting between mutable and immutable object variants.
Creating and Converting Mutable Objects
You can create a mutable object through the standard nested alloc-init message—for example:
NSMutableDictionary *mutDict = [[NSMutableDictionary alloc] init];
However, many mutable classes offer initializers and factory methodsthat let you specify the initial or probable
capacity of the object, such as the arrayWithCapacity: class method of NSMutableArray:
NSMutableArray *mutArray = [NSMutableArray arrayWithCapacity:[timeZones count]];
The capacity hint enables more efficient storage of the mutable object’s data. (Because the convention for
class factory methods is to return autoreleased instances, be sure to retain the object if you wish to keep it
viable in your code.)
You can also create a mutable object by making a mutable copy of an existing object of that general type. To
do so, invoke the mutableCopy method that each immutable super class of a Foundation mutable class
implements:
NSMutableSet *mutSet = [aSet mutableCopy];
Object Mutability
Programming with Mutable Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
62In the other direction, you can send copy to a mutable object to make an immutable copy of the object.
Many Foundation classes with immutable and mutable variants include methods for converting between the
variants, including:
●
typeWithType:—for example, arrayWithArray:
● setType:—for example, setString: (mutable classes only)
● initWithType:copyItems:—for example, initWithDictionary:copyItems:
Storing and Returning Mutable Instance Variables
In Cocoa development you often have to decide whether to make an instance variable mutable or immutable.
For an instance variable whose value can change, such as a dictionary or string, when is it appropriate to make
the object mutable? And when is it better to make the object immutable and replace it with another object
when its represented value changes?
Generally, when you have an object whose contents change wholesale, it’s better to use an immutable object.
Strings (NSString) and data objects (NSData) usually fall into this category. If an object is likely to change
incrementally, it is a reasonable approach to make it mutable. Collections such as arrays and dictionaries fall
into this category. However, the frequency of changes and the size of the collection should be factors in this
decision. For example, if you have a small array that seldom changes, it’s better to make it immutable.
There are a couple of other considerations when deciding on the mutability of a collection held as an instance
variable:
●
If you have a mutable collection that is frequently changed and that you frequently hand out to clients
(that is, you return it directly in a getter accessor method), you run the risk of mutating something that
your clients might have a reference to. If this risk is probable, the instance variable should be immutable.
●
If the value of the instance variable frequently changes but you rarely return it to clientsin getter methods,
you can make the instance variable mutable but return an immutable copy of it in your accessor method;
in memory-managed programs, this object would be autoreleased (Listing 9-1).
Listing 9-1 Returning an immutable copy of a mutable instance variable
@interface MyClass : NSObject {
// ...
NSMutableSet *widgets;
}
// ...
@end
Object Mutability
Programming with Mutable Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
63@implementation MyClass
- (NSSet *)widgets {
return (NSSet *)[[widgets copy] autorelease];
}
One sophisticated approach for handling mutable collections that are returned to clients is to maintain a flag
that records whether the object is currently mutable or immutable. If there is a change, make the object mutable
and apply the change. When handing out the collection, make the object immutable (if necessary) before
returning it.
Receiving Mutable Objects
The invoker of a method is interested in the mutability of a returned object for two reasons:
●
It wants to know if it can change the object’s value.
●
It wants to know if the object’s value will change unexpectedly while it has a reference to it.
Use Return Type, Not Introspection
To determine whether it can change a received object, the receiver of a message must rely on the formal type
of the return value. If it receives, for example, an array object typed as immutable, it should not attempt to
mutate it. It is not an acceptable programming practice to determine if an object is mutable based on its class
membership—for example:
if ( [anArray isKindOfClass:[NSMutableArray class]] ) {
// add, remove objects from anArray
}
For reasons related to implementation, what isKindOfClass: returns in this case may not be accurate. But
for reasons other than this, you should not make assumptions about whether an object is mutable based on
class membership. Your decision should be guided solely by what the signature of the method vending the
object says about its mutability. If you are not sure whether an object is mutable or immutable, assume it’s
immutable.
A couple of examples might help clarify why this guideline is important:
Object Mutability
Programming with Mutable Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
64● You read a property list from a file. When the Foundation framework processes the list, it notices that
various subsets of the property list are identical, so it creates a set of objects that it shares among all those
subsets. Afterward you look at the created property list objects and decide to mutate one subset. Suddenly,
and without being aware of it, you’ve changed the tree in multiple places.
● You ask NSView for its subviews (with the subviews method) and it returns an object that is declared to
be an NSArray but which could be an NSMutableArray internally. Then you pass that array to some
other code that, through introspection, determinesit to be mutable and changesit. By changing this array,
the code is mutating internal data structures of the NSView class.
So don’t make an assumption about object mutability based on what introspection tells you about an object.
Treat objects as mutable or not based on what you are handed at the API boundaries (that is, based on the
return type). If you need to unambiguously mark an object as mutable or immutable when you passit to clients,
pass that information as a flag along with the object.
Make Snapshots of Received Objects
If you want to ensure that a supposedly immutable object received from a method does not mutate without
your knowing about it, you can make snapshots of the object by copying it locally. Then occasionally compare
the stored version of the object with the most recent version. If the object has mutated, you can adjust anything
in your program that is dependent on the previous version of the object. Listing 9-2 shows a possible
implementation of this technique.
Listing 9-2 Making a snapshot of a potentially mutable object
static NSArray *snapshot = nil;
- (void)myFunction {
NSArray *thingArray = [otherObj things];
if (snapshot) {
if ( ![thingArray isEqualToArray:snapshot] ) {
[self updateStateWith:thingArray];
}
}
snapshot = [thingArray copy];
}
A problem with making snapshots of objects for later comparison is that it is expensive. You’re required to
make multiple copies of the same object. A more efficient alternative isto use key-value observing. See Key-Value
Observing Programming Guide for a description of this protocol.
Object Mutability
Programming with Mutable Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
65Mutable Objects in Collections
Storing mutable objects in collection objects can cause problems. Certain collections can become invalid or
even corrupt if objects they contain mutate because, by mutating, these objects can affect the way they are
placed in the collection. First, the properties of objects that are keys in hashing collections such as
NSDictionary objects or NSSet objects will, if changed, corrupt the collection if the changed properties
affect the results of the object’s hash or isEqual: methods. (If the hash method of the objectsin the collection
does not depend on their internal state, corruption is less likely.) Second, if an object in an ordered collection
such as a sorted array has its properties changed, this might affect how the object compares to other objects
in the array, thus rendering the ordering invalid.
Object Mutability
Programming with Mutable Objects
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
66An outlet is a property of an object that references another object. The reference is archived through Interface
Builder. The connections between the containing object and its outlets are reestablished every time the
containing object is unarchived from its nib file. The containing object holds an outlet declared as a property
with the type qualifier of IBOutlet and a weak option. For example:
@interface AppController : NSObject
{
}
@property (weak) IBOutlet NSArray *keywords;
Because it is a property, an outlet becomes part of an object’s encapsulated data and is backed by an instance
variable. But an outlet is more than a simple property. The connection between an object and its outlets is
archived in a nib file; when the nib file is loaded, each connection is unarchived and reestablished, and is thus
always available whenever it becomes necessary to send messages to the other object. The type qualifier
IBOutlet is a tag applied to an property declaration so that the Interface Builder application can recognize
the property as an outlet and synchronize the display and connection of it with Xcode.
An outlet is declared as a weak reference (weak) to prevent strong reference cycles.
You create and connect an outlet in the Interface Builder feature of Xcode.The property declaration for the outlet
must be tagged with the IBOutlet qualifier.
An application typically sets outlet connections between its custom controller objects and objects on the user
interface, but they can be made between any objects that can be represented as instances in Interface Builder,
even between two custom objects. As with any item of object state, you should be able to justify its inclusion
in a class; the more outlets an object has, the more memory it takes up. If there are other ways to obtain a
reference to an object, such as finding it through its index position in a matrix, or through its inclusion as a
function parameter, or through use of a tag (an assigned numeric identifier), you should do that instead.
Outlets are a form of object composition, which is a dynamic pattern that requires an object to somehow
acquire referencesto its constituent objectsso that it can send messagesto them. It typically holdsthese other
objects as properties backed by instance variables. These variables must be initialized with the appropriate
references at some point during the execution of the program.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
67
OutletsThe Receptionist design pattern addresses the general problem of redirecting an event occurring in one
execution context of an application to another execution context for handling. It is a hybrid pattern. Although
it doesn’t appear in the “Gang of Four” book, it combines elements of the Command, Memo, and Proxy design
patterns described in that book. It is also a variant of the Trampoline pattern (which also doesn’t appear in the
book); in this pattern, an event initially is received by a trampoline object, so-called because it immediately
bounces, or redirects, the event to a target object for handling.
The Receptionist Design Pattern in Practice
A KVO notification invokes the observeValueForKeyPath:ofObject:change:context: method
implemented by an observer. If the change to the property occurs on a secondary thread, the
observeValueForKeyPath:ofObject:change:context: code executes on that same thread. There the
central object in this pattern, the receptionist, acts as a thread intermediary. As Figure 11-1 illustrates, a
receptionist object is assigned as the observer of a model object’s property. The receptionist implements
observeValueForKeyPath:ofObject:change:context: to redirect the notification received on a
secondary thread to another execution context—the main operation queue, in this case. When the property
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
68
Receptionist Patternchanges, the receptionist receives a KVO notification. The receptionist immediately adds a block operation to
the main operation queue; the block contains code—specified by the client—that updates the user interface
appropriately.
Figure 11-1 Bouncing KVO updates to the main operation queue
Main
thread
self.value = newValue;
observeValueForKeyPath:
ofObject:change:context:
addOperation:
modelObject
receptionist
Secondary Main operation queue
thread
task
You define a receptionist class so that it has the elements it needs to add itself as an observer of a property
and then convert a KVO notification into an update task. Thus it must know what object it’s observing, the
property of the object that it’s observing, what update task to execute, and what queue to execute it on. Listing
11-1 shows the initial declaration of the RCReceptionist class and its instance variables.
Listing 11-1 Declaring the receptionist class
@interface RCReceptionist : NSObject {
id observedObject;
NSString *observedKeyPath;
RCTaskBlock task;
NSOperationQueue *queue;
}
Receptionist Pattern
The Receptionist Design Pattern in Practice
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
69The RCTaskBlock instance variable is a block object of the following declared type:
typedef void (^RCTaskBlock)(NSString *keyPath, id object, NSDictionary *change);
These parameters are similar to those of the observeValueForKeyPath:ofObject:change:context:
method. Next, the parameter class declares a single class factory method in which an RCTaskBlock object is
a parameter:
+ (id)receptionistForKeyPath:(NSString *)path
object:(id)obj
queue:(NSOperationQueue *)queue
task:(RCTaskBlock)task;
It implementsthis method to assign the passed-in value to instance variables of the created receptionist object
and to add that object as an observer of the model object’s property, as shown in Listing 11-2.
Listing 11-2 The class factory method for creating a receptionist object
+ (id)receptionistForKeyPath:(NSString *)path object:(id)obj queue:(NSOperationQueue
*)queue task:(RCTaskBlock)task {
RCReceptionist *receptionist = [RCReceptionist new];
receptionist->task = [task copy];
receptionist->observedKeyPath = [path copy];
receptionist->observedObject = [obj retain];
receptionist->queue = [queue retain];
[obj addObserver:receptionist forKeyPath:path
options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
context:0];
return [receptionist autorelease];
}
Note that the code copies the block object instead of retaining it. Because the block was probably created on
the stack, it must be copied to the heap so it exists in memory when the KVO notification is delivered.
Finally, the parameter class implements the observeValueForKeyPath:ofObject:change:context:
method. The implementation (see Listing 11-3) is simple.
Receptionist Pattern
The Receptionist Design Pattern in Practice
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
70Listing 11-3 Handling the KVO notification
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
change:(NSDictionary *)change context:(void *)context {
[queue addOperationWithBlock:^{
task(keyPath, object, change);
}];
}
This code simply enqueues the task onto the given operation queue, passing the task block the observed
object, the key path for the changed property, and the dictionary containing the new value. The task is
encapsulated in an NSBlockOperation object that executes the task on the queue.
The client object supplies the block code that updates the user interface when it creates a receptionist object,
as shown in Listing 11-4. Note that when it creates the receptionist object, the client passes in the operation
queue on which the block is to be executed, in this case the main operation queue.
Listing 11-4 Creating a receptionist object
RCReceptionist *receptionist = [RCReceptionist
receptionistForKeyPath:@"value" object:model queue:mainQueue task:^(NSString
*keyPath, id object, NSDictionary *change) {
NSView *viewForModel = [modelToViewMap objectForKey:model];
NSColor *newColor = [change objectForKey:NSKeyValueChangeNewKey];
[[[viewForModel subviews] objectAtIndex:0] setFillColor:newColor];
}];
When to Use the Receptionist Pattern
You can adopt the Receptionist design pattern whenever you need to bounce off work to another execution
context for handling. When you observe a notification, or implement a block handler, or respond to an action
message and you want to ensure that your code executes in the appropriate execution context, you can
implement the Receptionist pattern to redirect the work that must be done to that execution context. With
the Receptionist pattern, you might even perform some filtering or coalescing of the incoming data before
you bounce off a task to processthe data. For example, you could collect data into batches, and then at intervals
dispatch those batches elsewhere for processing.
Receptionist Pattern
When to Use the Receptionist Pattern
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
71One common situation where the Receptionist pattern is useful is key-value observing. In key-value observing,
changes to the value of an model object’s property are communicated to observers via KVO notifications.
However, changes to a model object can occur on a background thread. This results in a thread mismatch,
because changes to a model object’s state typically result in updates to the user interface, and these must
occur on the main thread. In this case, you want to redirect the KVO notifications to the main thread. where
the updates to an application’s user interface can occur.
Receptionist Pattern
When to Use the Receptionist Pattern
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
72Although delegation, bindings, and notification are useful for handling certain forms of communication between
objects in a program, they are not particularly suitable for the most visible sort of communication. A typical
application’s user interface consists of a number of graphical objects, and perhaps the most common of these
objects are controls. A control is a graphical analog of a real-world or logical device (button, slider, checkboxes,
and so on); as with a real-world control, such as a radio tuner, you use it to convey your intent to some system
of which it is a part—that is, an application.
The role of a control on a user interface is simple: It interprets the intent of the user and instructs some other
object to carry out that request. When a user acts on the control by, say, clicking it or pressing the Return key,
the hardware device generates a raw event. The control accepts the event (as appropriately packaged for
Cocoa) and translates it into an instruction that is specific to the application. However, events by themselves
don't give much information about the user's intent; they merely tell you that the user clicked a mouse button
or pressed a key. So some mechanism must be called upon to provide the translation between event and
instruction. This mechanism is called target-action .
Cocoa uses the target-action mechanism for communication between a control and another object. This
mechanism allows the control and, in OS X its cell or cells, to encapsulate the information necessary to send
an application-specific instruction to the appropriate object. The receiving object—typically an instance of a
custom class—is called the target. The action is the message that the control sends to the target. The object
that is interested in the user event—the target—is the one that imparts significance to it, and this significance
is usually reflected in the name it gives to the action.
The Target
A target is a receiver of an action message. A control or, more frequently, its cell holds the target of its action
message as an outlet (see “Outlets” (page 67)). The target usually is an instance of one of your custom classes,
although it can be any Cocoa object whose class implements the appropriate action method.
You can also set a cell’s or control’s target outlet to nil and let the target object be determined at runtime.
When the targetis nil,the application object(NSApplication or UIApplication)searchesfor an appropriate
receiver in a prescribed order:
1. It begins with the first responder in the key window and follows nextResponder links up the responder
chain to the window object’s (NSWindow or UIWindow) content view.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
73
Target-ActionNote: A key window in OS X responds to key presses for an application and is the receiver of
messages from menus and dialogs. An application’s main window is the principal focus of user
actions and often has key status as well.
2. It tries the window object and then the window object’s delegate.
3. If the main window is different from the key window, it then starts over with the first responder in the
main window and works its way up the main window’s responder chain to the window object and its
delegate.
4. Next, the application object tries to respond. If it can’t respond, it tries its delegate. The application object
and its delegate are the receivers of last resort.
Control objects do not (and should not) retain their targets. However, clients of controlssending action messages
(applications, usually) are responsible for ensuring that their targets are available to receive action messages.
To do this, they may have to retain their targets in memory-managed environments. This precaution applies
equally to delegates and data sources.
The Action
An action is the message a control sends to the target or, from the perspective of the target, the method the
target implements to respond to the action message. A control or—as is frequently the case in AppKit—a
control’s cell stores an action as an instance variable of type SEL. SEL is an Objective-C data type used to
specify the signature of a message. An action message must have a simple, distinct signature. The method it
invokes returns nothing and usually has a sole parameter of type id. This parameter, by convention, is named
sender. Here is an example from the NSResponder class, which defines a number of action methods:
- (void)capitalizeWord:(id)sender;
Action methods declared by some Cocoa classes can also have the equivalent signature:
- (IBAction) deleteRecord:(id)sender;
In this case, IBAction does not designate a data type for a return value; no value is returned. IBAction is a
type qualifier that Interface Builder notices during application development to synchronize actions added
programmatically with its internal list of action methods defined for a project.
Target-Action
The Action
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
74iOS Note: In UIKit, action selectors can also take two other forms. See “Target-Action in UIKit” (page
78) for details.
The senderparameter usually identifies the control sending the action message (although it can be another
object substituted by the actual sender). The idea behind this is similar to a return address on a postcard. The
target can query the sender for more information if it needsto. If the actualsending objectsubstitutes another
object as sender, you should treat that object in the same way. For example, say you have a text field and when
the user enters text, the action method nameEntered: is invoked in the target:
- (void)nameEntered:(id) sender {
NSString *name = [sender stringValue];
if (![name isEqualToString:@""]) {
NSMutableArray *names = [self nameList];
[names addObject:name];
[sender setStringValue:@""];
}
}
Here the responding method extracts the contents of the text field, adds the string to an array cached as an
instance variable, and clears the field. Other possible queries to the sender would be asking an NSMatrix
object for its selected row ([sender selectedRow]), asking an NSButton object for its state ([sender
state]), and asking any cell associated with a control for its tag ([[sender cell] tag]), a tag being a
numeric identifier.
Target-Action in the AppKit Framework
The AppKit framework uses specific architectures and conventions in implementing target-action.
Controls, Cells, and Menu Items
Most controls in AppKit are objects that inherit from the NSControl class. Although a control has the initial
responsibility for sending an action message to its target, it rarely carries the information needed to send the
message. For this, it usually relies on its cell or cells.
A control almost always has one or more cells—objects that inherit from NSCell—associated with it. Why is
there this association? A control is a relatively “heavy” object because it inherits all the combined instance
variables of its ancestors, which include the NSView and NSResponder classes. Because controls are expensive,
Target-Action
Target-Action in the AppKit Framework
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
75cells are used to subdivide the screen real estate of a control into various functional areas. Cells are lightweight
objects that can be thought of as overlaying all or part of the control. But it's not only a division of area, it's a
division of labor. Cells do some of the drawing that controls would otherwise have to do, and cells hold some
of the data that controls would otherwise have to carry. Two items of this data are the instance variables for
target and action. Figure 12-1 (page 76) depicts the control-cell architecture.
Being abstract classes, NSControl and NSCell both incompletely handle the setting of the target and action
instance variables. By default, NSControl simply sets the information in its associated cell, if one exists.
(NSControl itself supports only a one-to-one mapping between itself and a cell; subclasses of NSControl
such as NSMatrix support multiple cells.) In its default implementation, NSCell simply raises an exception.
You must go one step further down the inheritance chain to find the class that really implements the setting
of target and action: NSActionCell.
Objects derived from NSActionCell provide target and action values to their controls so the controls can
compose and send an action message to the proper receiver. An NSActionCell object handles mouse (cursor)
tracking by highlighting its area and assisting its control in sending action messages to the specified target.
In most cases, the responsibility for an NSControl object’s appearance and behavior is completely given over
to a corresponding NSActionCell object. (NSMatrix, and itssubclass NSForm, are subclasses of NSControl
that don’t follow this rule.)
Figure 12-1 How the target-action mechanism works in the control-cell architecture
washerObject
dryerObject
washerCell
dryerCell
Target
Action
Target
Action
Control
(NSMatrix)
Cells
(NSButtonCell)
(void)dryIt: (id)sender
(void)washIt: (id)sender
Target-Action
Target-Action in the AppKit Framework
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
76When users choose an item from a menu, an action is sent to a target. Yet menus (NSMenu objects) and their
items (NSMenuItem objects) are completely separate, in an architectural sense, from controls and cells. The
NSMenuItem class implements the target-action mechanism for its own instances; an NSMenuItem object has
both target and action instance variables (and related accessor methods) and sends the action message to the
target when a user chooses it.
Note: See Control and Cell Programming Topics for Cocoa and Application Menu and Pop-up List
Programming Topics for more information about the control-cell architecture.
Setting the Target and Action
You can set the targets and actions of cells and controls programmatically or by using Interface Builder. For
most developers and mostsituations, Interface Builder isthe preferred approach. When you use it to set controls
and targets, Interface Builder provides visual confirmation, allows you to lock the connections, and archives
the connections to a nib file. The procedure is simple:
1. Declare an action method in the header file of your custom class that has the IBAction qualifier.
2. In Interface Builder, connect the control sending the message to the action method of the target.
If the action is handled by a superclass of your custom class or by an off-the-shelf AppKit or UIKit class, you
can make the connection without declaring any action method. Of course, if you declare an action method
yourself, you must be sure to implement it.
To set the action and the target programmatically, use the following methods to send messages to a control
or cell object:
- (void)setTarget:(id)anObject;
- (void)setAction:(SEL)aSelector;
The following example shows how you might use these methods:
[aCell setTarget:myController];
[aControl setAction:@selector(deleteRecord:)];
[aMenuItem setAction:@selector(showGuides:)];
Target-Action
Target-Action in the AppKit Framework
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
77Programmatically setting the target and action does have its advantages and in certain situations it is the only
possible approach. For example, you might want the target or action to vary according to some runtime
condition, such as whether a network connection exists or whether an inspector window has been loaded.
Another example is when you are dynamically populating the items of a pop-up menu, and you want each
pop-up item to have its own action.
Actions Defined by AppKit
The AppKit framework not only includes many NSActionCell-based controls for sending action messages,
it defines action methods in many of its classes. Some of these actions are connected to default targets when
you create a Cocoa application project. For example, the Quit command in the application menu is connected
to the terminate: method in the global application object (NSApp).
The NSResponder class also defines many default action messages (also known as standard commands) for
common operations on text. This allowsthe Cocoa textsystem to send these action messages up an application’s
responder chain—a hierarchical sequence of event-handling objects—where it can be handled by the first
NSView, NSWindow, or NSApplication object that implements the corresponding method.
Target-Action in UIKit
The UIKit framework also declares and implements a suite of control classes; the control classesin thisframework
inherit from the UIControl class, which defines most of the target-action mechanism for iOS. However there
are some fundamental differences in how the AppKit and UIKit frameworks implement target-action. One of
these differences is that UIKit does not have any true cell classes. Controls in UIKit do not rely upon their cells
for target and action information.
A larger difference in how the two frameworks implement target-action lies in the nature of the event model.
In the AppKit framework, the user typically uses a mouse and keyboard to register events for handling by the
system. These events—such as clicking on a button—are limited and discrete. Consequently, a control object
in AppKit usually recognizes a single physical event as the trigger for the action it sends to its target. (In the
case of buttons, this is a mouse-up event.) In iOS, the user’s fingers are what originate events instead of mouse
clicks, mouse drags, or physical keystrokes. There can be more than one finger touching an object on the screen
at one time, and these touches can even be going in different directions.
To account for this multitouch event model, UIKit declares a set of control-event constants in UIControl.h
that specify various physical gestures that users can make on controls, such as lifting a finger from a control,
dragging a finger into a control, and touching down within a text field. You can configure a control object so
that it responds to one or more of these touch events by sending an action message to a target. Many of the
Target-Action
Target-Action in UIKit
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
78control classes in UIKit are implemented to generate certain control events; for example, instances of the
UISlider class generate a UIControlEventValueChanged control event, which you can use to send an
action message to a target object.
You set up a control so that it sends an action message to a target object by associating both target and action
with one or more control events. To do this, send addTarget:action:forControlEvents: to the control
for each target-action pair you want to specify. When the user touches the control in a designated fashion, the
control forwards the action message to the global UIApplication object in a
sendAction:to:from:forEvent: message. As in AppKit, the global application object is the centralized
dispatch point for action messages. If the control specifies a nil target for an action message, the application
queries objects in the responder chain until it finds one that is willing to handle the action message—that is,
one implementing a method corresponding to the action selector.
In contrast to the AppKit framework, where an action method may have only one or perhapstwo valid signatures,
the UIKit framework allows three different forms of action selector:
- (void)action
- (void)action:(id)sender
- (void)action:(id)sender forEvent:(UIEvent *)event
To learn more about the target-action mechanism in UIKit, read UIControl Class Reference .
Target-Action
Target-Action in UIKit
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
79There are a number of data types in the Core Foundation framework and the Foundation framework that can
be used interchangeably. This capability, called toll-free bridging , means that you can use the same data type
as the parameter to a Core Foundation function call or as the receiver of an Objective-C message. For example,
NSLocale (see NSLocale Class Reference ) is interchangeable with its Core Foundation counterpart, CFLocale
(see CFLocale Reference ). Therefore, in a method where you see an NSLocale * parameter, you can pass a
CFLocaleRef, and in a function where you see a CFLocaleRef parameter, you can pass an NSLocale
instance. You cast one type to the other to suppress compiler warnings, as illustrated in the following example.
NSLocale *gbNSLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_GB"];
CFLocaleRef gbCFLocale = (CFLocaleRef) gbNSLocale;
CFStringRef cfIdentifier = CFLocaleGetIdentifier (gbCFLocale);
NSLog(@"cfIdentifier: %@", (NSString *)cfIdentifier);
// logs: "cfIdentifier: en_GB"
CFRelease((CFLocaleRef) gbNSLocale);
CFLocaleRef myCFLocale = CFLocaleCopyCurrent();
NSLocale * myNSLocale = (NSLocale *) myCFLocale;
[myNSLocale autorelease];
NSString *nsIdentifier = [myNSLocale localeIdentifier];
CFShow((CFStringRef) [@"nsIdentifier: " stringByAppendingString:nsIdentifier]);
// logs identifier for current locale
Note from the example that the memory management functions and methods are also interchangeable—you
can use CFRelease with a Cocoa object and release and autorelease with a Core Foundation object.
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
80
Toll-Free BridgingNote: When using garbage collection, there are important differencesto how memory management
works for Cocoa objects and Core Foundation objects. See “Using Core Foundation with Garbage
Collection” for details.
Toll-free bridging has been available since OS X v10.0. Table 13-1 provides a list of the data types that are
interchangeable between Core Foundation and Foundation. For each pair, the table also lists the version of
OS X in which toll-free bridging between them became available.
Table 13-1 Data types that can be used interchangeably between Core Foundation and Foundation
Core Foundation type Foundation class Availability
CFArrayRef NSArray OS X v10.0
CFAttributedStringRef NSAttributedString OS X v10.4
CFCalendarRef NSCalendar OS X v10.4
CFCharacterSetRef NSCharacterSet OS X v10.0
CFDataRef NSData OS X v10.0
CFDateRef NSDate OS X v10.0
CFDictionaryRef NSDictionary OS X v10.0
CFErrorRef NSError OS X v10.5
CFLocaleRef NSLocale OS X v10.4
CFMutableArrayRef NSMutableArray OS X v10.0
CFMutableAttributedStringRef NSMutableAttributedString OS X v10.4
CFMutableCharacterSetRef NSMutableCharacterSet OS X v10.0
CFMutableDataRef NSMutableData OS X v10.0
CFMutableDictionaryRef NSMutableDictionary OS X v10.0
CFMutableSetRef NSMutableSet OS X v10.0
CFMutableStringRef NSMutableString OS X v10.0
CFNumberRef NSNumber OS X v10.0
CFReadStreamRef NSInputStream OS X v10.0
Toll-Free Bridging
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
81Core Foundation type Foundation class Availability
CFRunLoopTimerRef NSTimer OS X v10.0
CFSetRef NSSet OS X v10.0
CFStringRef NSString OS X v10.0
CFTimeZoneRef NSTimeZone OS X v10.0
CFURLRef NSURL OS X v10.0
CFWriteStreamRef NSOutputStream OS X v10.0
Note: Not all data types are toll-free bridged, even though their names might suggest that they
are. For example, NSRunLoop is not toll-free bridged to CFRunLoop, NSBundle is not toll-free bridged
to CFBundle, and NSDateFormatter is not toll-free bridged to CFDateFormatter.
Toll-Free Bridging
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
82This table describes the changes to Concepts in Objective-C Programming .
Date Notes
Descriptions of design patterns, architectures, and other concepts
important in Cocoa and Cocoa Touch development.
2012-01-09
2012-01-09 | © 2012 Apple Inc. All Rights Reserved.
83
Document Revision HistoryApple Inc.
© 2012 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, Cocoa Touch,
Objective-C, OS X, and Xcode are trademarks of
Apple Inc., registered in the U.S. and other
countries.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Local and Push
Notification
Programming GuideContents
About Local Notifications and Push Notifications 5
At a Glance 6
The Problem That Local and Push Notifications Solve 6
Local and Push Notifications Are Different in Origination 6
You Schedule a Local Notification, Register a Push Notification, and Handle Both 6
The Apple Push Notification Service Is the Gateway for Push Notifications 7
You Must Obtain Security Credentials for Push Notifications 7
The Provider Communicates with APNs over a Binary Interface 7
Prerequisites 8
See Also 8
Local and Push Notifications in Depth 9
Push and Local Notifications Appear the Same to Users 9
More About Local Notifications 12
More About Push Notifications 13
Scheduling, Registering, and Handling Notifications 15
Preparing Custom Alert Sounds 15
Scheduling Local Notifications 16
Registering for Remote Notifications 19
Handling Local and Remote Notifications 21
Passing the Provider the Current Language Preference (Remote Notifications) 26
Apple Push Notification Service 28
A Push Notification and Its Path 28
Feedback Service 29
Quality of Service 30
Security Architecture 30
Service-to-Device Connection Trust 31
Provider-to-Service Connection Trust 31
Token Generation and Dispersal 32
Token Trust (Notification) 34
Trust Components 34
The Notification Payload 35
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
2Localized Formatted Strings 37
Examples of JSON Payloads 39
Provisioning and Development 42
Sandbox and Production Environments 42
Provisioning Procedures 43
Creating the SSL Certificate and Keys 43
Creating and Installing the Provisioning Profile 44
Installing the SSL Certificate and Key on the Server 45
Provider Communication with Apple Push Notification Service 47
General Provider Requirements 47
The Binary Interface and Notification Formats 48
The Feedback Service 53
Document Revision History 55
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
3
ContentsFigures, Tables, and Listings
Local and Push Notifications in Depth 9
Figure 1-1 A notification alert 10
Figure 1-2 An application icon with a badge number (iOS) 11
Figure 1-3 A notification alert message with the action button suppressed 11
Scheduling, Registering, and Handling Notifications 15
Listing 2-1 Creating, configuring, and scheduling a local notification 17
Listing 2-2 Presenting a local notification immediately while running in the background 18
Listing 2-3 Registering for remote notifications 21
Listing 2-4 Handling a local notification when an application is launched 23
Listing 2-5 Downloading data from a provider 24
Listing 2-6 Handling a local notification when an application is already running 25
Listing 2-7 Getting the current supported language and sending it to the provider 26
Apple Push Notification Service 28
Figure 3-1 A push notification from a provider to a client application 29
Figure 3-2 Push notifications from multiple providers to multiple devices 29
Figure 3-3 Sharing the device token 33
Table 3-1 Keys and values of the aps dictionary 36
Table 3-2 Child properties of the alert property 36
Provider Communication with Apple Push Notification Service 47
Figure 5-1 Simple notification format 49
Figure 5-2 Enhanced notification format 50
Figure 5-3 Format of error-response packet 51
Figure 5-4 Binary format of a feedback tuple 54
Table 5-1 Codes in error-response packet 51
Listing 5-1 Sending a notification in the simple format via the binary interface 49
Listing 5-2 Sending a notification in the enhanced format via the binary interface 52
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
4Local notifications and push notifications are ways for an application that isn’t running in the foreground to
let its users know it has information for them. The information could be a message, an impending calendar
event, or new data on a remote server. When presented by the operating system, local and push notifications
look and sound the same. They can display an alert message or they can badge the application icon. They can
also play a sound when the alert or badge number is shown.
Push notifications were introduced in iOS 3.0 and in OS X version 10.7. Local notifications were introduced in
iOS 4.0; they are not available in OS X.
When users are notified that the application has a message, event, or other data for them, they can launch the
application and see the details. They can also choose to ignore the notification, in which case the application
is not activated.
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
5
About Local Notifications and Push NotificationsNote: Push notifications and local notifications are not related to broadcast notifications
(NSNotificationCenter) or key-value observing notifications.
At a Glance
Local notifications and push notifications have several important aspects you should be aware of.
The Problem That Local and Push Notifications Solve
Only one application can be active in the foreground at any time. Many applications operate in a time-based
or interconnected environment where events of interest to users can occur when the application is not in the
foreground. Local and push notifications allow these applicationsto notify their users when these events occur.
Relevant Chapter: “Local and Push Notifications in Depth” (page 9)
Local and Push Notifications Are Different in Origination
Local and push notifications serve different design needs. A local notification is local to an application on an
iPhone, iPad, or iPod touch. Push notifications—also known as remote notifications—arrive from outside a
device. They originate on a remote server—the application’s provider—and are pushed to applications on
devices (via the Apple Push Notification service) when there are messages to see or data to download.
Relevant Chapter: “Local and Push Notifications in Depth” (page 9)
You Schedule a Local Notification, Register a Push Notification, and Handle Both
To have iOS deliver a local notification at a later time, an application creates a UILocalNotification object,
assignsit a delivery date and time,specifies presentation details, and schedulesit. To receive push notifications,
an application must register to receive the notifications and then pass to its provider a device token it gets
from the operating system.
When the operating system delivers a local notification (iOS only) or push notification (iOS or OS X) and the
target application is not running in the foreground, it presents the notification (alert, icon badge number,
sound). If there is a notification alert and the user taps or clicks the action button (or moves the action slider),
the application launches and calls a method to pass in the local-notification object or remote-notification
payload. If the application is running in the foreground when the notification is delivered, the application
delegate receives a local or push notification.
About Local Notifications and Push Notifications
At a Glance
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
6Relevant Chapter: “Scheduling, Registering, and Handling Notifications” (page 15)
The Apple Push Notification Service Is the Gateway for Push Notifications
Apple Push Notification service (APNs) propagates push notificationsto devices having applicationsregistered
to receive those notifications. Each device establishes an accredited and encrypted IP connection with the
service and receives notifications over this persistent connection. Providers connect with APNs through a
persistent and secure channel while monitoring incoming data intended for their client applications. When
new data for an application arrives, the provider prepares and sends a notification through the channel to
APNs, which pushes the notification to the target device.
Related Chapter: “Apple Push Notification Service” (page 28)
You Must Obtain Security Credentials for Push Notifications
To develop and deploy the provider side of an application for push notifications, you must get SSL certificates
from the appropriate Dev Center. Each certificate is limited to a single application, identified by its bundle ID;
it is also limited to one of two environments, sandbox (for development and testing) and production. These
environments have their own assigned IP address and require their own certificates. You must also obtain
provisioning profiles for each of these environments.
Related Chapter: “Provisioning and Development” (page 42)
The Provider Communicates with APNs over a Binary Interface
The binary interface is asynchronous and uses a streaming TCP socket design for sending push notifications
as binary content to APNs. There is a separate interface for the sandbox and production environments, each
with its own address and port. For each interface, you need to use TLS (or SSL) and the SSL certificate you
obtained to establish a secured communications channel. The provider composes each outgoing notification
and sends it over this channel to APNs.
APNs has a feedback service that maintains a per-application list of devicesfor which there were failed-delivery
attempts (that is, APNs was unable to deliver a push notification to an application on a device). Periodically,
the provider should connect with the feedback service to see what devices have persistent failures so that it
can refrain from sending push notifications to them.
About Local Notifications and Push Notifications
At a Glance
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
7Related Chapters: “Apple Push Notification Service” (page 28), “Provider Communication with
Apple Push Notification Service” (page 47)
Prerequisites
For local notifications and the client-side implementation of push notifications, familiarity with application
development for iOS is assumed. For the provider side of the implementation, knowledge of TLS/SSL and
streaming sockets is helpful.
See Also
You might find these additional sources of information useful for understanding and implementing local and
push notifications :
● The reference documentation for UILocalNotification, UIApplication, and
UIApplicationDelegate describe the local- and push-notification API for client applications in iOS.
● The reference documentation for NSApplication and NSApplicationDelegate Protocol describe
the push-notification API for client applications in OS X.
● Security Overview describes the security technologies and techniques used for the iOS and Macs.
● RFC 5246 is the standard for the TLS protocol.
Secure communication between data providers and Apple Push Notification Service requires knowledge
of Transport Layer Security (TLS) or its predecessor, Secure Sockets Layer (SSL). Refer to one of the many
online or printed descriptions of these cryptographic protocols for further information.
About Local Notifications and Push Notifications
Prerequisites
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
8The essential purpose of both local and push notifications is to enable an application to inform its users that
it hassomething for them—for example, a message or an upcoming appointment—when the application isn’t
running in the foreground. The essential difference between local notifications and push notificationsissimple:
● Local notifications are scheduled by an application and delivered by iOS on the same device.
Local notifications are available in iOS only.
● Push notifications, also known as remote notifications, are sent by an application’s remote server (its
provider) to Apple Push Notification service, which pushes the notification to devices on which the
application is installed.
Push notifications are available in both iOS and, beginning with OS X v10.7 (Lion), OS X.
The following sections describe what local and push notifications have in common and then examine their
differences.
Note: For usage guidelines for push and local notifications in iOS, see “Enabling Push Notifications”
in iOS Human Interface Guidelines.
Push and Local Notifications Appear the Same to Users
From a user’s perspective, a push notification and a local notification appear to be the same thing. But that’s
because the purpose is the same: to notify users of an application—which might not currently be running in
the foreground—that there is something of interest for them.
Let’s say you’re using your iPhone—making phone calls, surfing the Internet, listening to music. You have a
chess application installed on your iPhone, and you decide to start a game with a friend who is playing remotely.
You make the first move (which is duly noted by the game’s provider), and then quit the client application to
read some email. In the meantime, your friend counters your move. The provider for the chess application
learns about this move and, seeing that the chess application on your device is no longer connected, sends a
push notification to Apple Push Notification service (APNs).
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
9
Local and Push Notifications in DepthAlmost immediately, your device—or more precisely, the operating system on your device—receives the
notification over the Wi-Fi or cellular connection from APNs. Because your chess application is not currently
running, iOS displays an alert similar to Figure 1-1. The message consists of the application name, a short
message, and (in this case) two buttons: Close and View. The button on the right is called the action button
and its default title is“View”. An application can customize the title of the action button and can internationalize
the button title and the message so that they are in the user’s preferred language.
Figure 1-1 A notification alert
If you tap the View button, the chess application launches, connects with its provider, downloads the new
data, and adjuststhe chessboard user interface to show your friend’s move. (Pressing Close dismissesthe alert.)
OS X Note: Currently, the only type of push notification in OS X for non-running applications is icon
badging. In other words, an application’s icon in the Dock is badged only if the application isn’t
running. If users have not already placed the icon in the Dock, the system inserts the icon into the
Dock so that it can badge it (and removes it after the application next terminates). Running
applications may examine the notification payload for other types of notifications(alerts and sounds)
and handle them appropriately.
Let’s consider a type of application with another requirement. This application manages a to-do list, and each
item in the list has a date and time when the item must be completed. The user can request the application
to notify it at a specific interval before this due date expires. To effect this, the application schedules a local
notification for that date and time. Instead of specifying an alert message, this time the application chooses
to specify a badge number (1). At the appointed time, iOS displays a badge number in the upper-right corner
of the icon of the application, such as illustrated in Figure 1-2.
Local and Push Notifications in Depth
Push and Local Notifications Appear the Same to Users
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
10For both local and push notifications, the badge number is specific to an application and can indicate any
number of things,such asthe number of impending calendar events or the number of data itemsto download
or the number of unread (but already downloaded) email messages. The user sees the badge and taps the
application icon—or, in OS X, clicks the icon in the dock—to launch the application, which then displays the
to-do item or whatever else is of interest to the user.
Figure 1-2 An application icon with a badge number (iOS)
In iOS, an application can specify a sound file along with an alert message or badge number. The sound file
should contain a short, distinctive sound. At the same moment iOS displays the alert or badges the icon, it
plays the sound to alert the user to the incoming notification.
Notification alert message can have one button instead of two. In the latter case, the action button issuppressed,
as illustrated in Figure 1-3. The user can only dismiss these kinds of alerts.
Figure 1-3 A notification alert message with the action button suppressed
Local and Push Notifications in Depth
Push and Local Notifications Appear the Same to Users
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
11The operating system delivers a local or push notification to an application whether the application is running
or not. If the application is running when the notification arrives, no alert is displayed or icon badged or sound
played, even if (in iOS) the device screen islocked. Instead, the application delegate isinformed of the notification
and can handle it directly. (“Scheduling, Registering, and Handling Notifications” (page 15) discusses the
various delivery scenarios in detail.)
Users of iPhone, iPad, and iPod touch devices can control whether the device or specific applications installed
on the device should receive push notifications. They can also selectively enable or disable push notification
types (that is, icon badging, alert messages, and sounds) for specific applications. They set these restrictions
in the Notifications preference of the Settings application. The UIKit framework provides a programming
interface to detect this user preference for a given application.
More About Local Notifications
Local notifications(available only in iOS) are ideally suited for applications with time-based behaviors, including
simple calendar or to-do list applications. Applicationsthat run in the background for the limited period allowed
by iOS might also find local notifications useful. For example, applicationsthat depend on serversfor messages
or data can poll their servers for incoming items while running in the background; if a message is ready to
view or an update is ready to download, they can then present a local notification immediately to inform their
users.
A local notification is an instance of UILocalNotification with three general kinds of properties:
● Scheduled time. You must specify the date and time the operating system delivers the notification; this
is known as the fire date . You may qualify the fire date with a specific time zone so that the system can
make adjustments to the fire date when the user travels. You can also request the operating system to
reschedule the notification on some regular interval (weekly, monthly, and so on).
● Notification type. This category includes the alert message, the title of the action button, the application
icon badge number, and a sound to play.
● Custom data. Local notifications can include a dictionary of custom data.
“Scheduling Local Notifications” (page 16) describesthese propertiesin programmatic detail.Once an application
has created a local-notification object, it can either schedule it with the operating system or present it
immediately.
Each application on a device is limited to the soonest-firing 64 scheduled local notifications. The operating
system discards notificationsthat exceed thislimit. It considers a recurring notification to be a single notification.
Local and Push Notifications in Depth
More About Local Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
12More About Push Notifications
An iOS application or a Mac app is often only a part of a larger application based on the client/server model.
The client side of the application is installed on the device or computer; the server side of the application has
the main function of providing data to its many client applications. (Hence it is termed a provider.) A client
application occasionally connects with its provider and downloads the data that is waiting for it. Email and
social-networking applications are examples of this client/server model.
But what if the application is not connected to its provider or even running on the device or computer when
the provider has new data for it to download? How does it learn about this waiting data? Push notifications
are the solution to this dilemma. A push notification is a short message that a provider has delivered to the
operating system of a device or computer; the operating system, in turn, informsthe user of a client application
that there is data to be downloaded, a message to be viewed, and so on. If the user enables this feature (on
iOS) and the application is properly registered, the notification is delivered to the operating system and possibly
to the application. Apple Push Notification service is the primary technology for the push-notification feature.
Push notificationsserve much the same purpose as a background application on a desktop system, but without
the additional overhead. For an application that is not currently running—or, in the case of iOS, not running
in the foreground—the notification occurs indirectly. The operating system receives a push notification on
behalf of the application and alerts the user. Once alerted, users may choose to launch the application, which
then downloads the data from its provider. If an application is running when a notification comes in, the
application can choose to handle the notification directly.
iOS Note: Beginning with iOS 4.0, applications can run in the background, but only for a limited
period. Only one application may be executing in the foreground at a time.
As its name suggests, Apple Push Notification service (APNs) uses a push design to deliver notifications to
devices and computers. A push design differs from its opposite, a pull design, in that the immediate recipient
of the notification—in this case, the operating system—passively listensfor updatesrather than actively polling
for them. A push design makes possible a wide and timely dissemination of information with few of the
scalability problems inherent with pull designs. APNs uses a persistent IP connection for implementing push
notifications.
Most of a push notification consists of a payload: a property list containing APNs-defined propertiesspecifying
how the user is to be notified. For performance reasons, the payload is deliberately small. Although you may
define custom properties for the payload, you should never use the remote-notification mechanism for data
transport because delivery of push notificationsis not guaranteed. For more on the payload,see “The Notification
Payload” (page 35).
Local and Push Notifications in Depth
More About Push Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
13APNs retains the last notification it receives from a provider for an application on a device; so, if a device or
computer comes online and has not received the notification, APNs pushes the stored notification to it. A
device running iOS receives push notifications over both Wi-Fi and cellular connections; a computer running
OS X receives push notifications over both WiFi and Ethernet connections.
Important: In iOS, Wi-Fi is used for push notifications only if there is no cellular connection or if the device
is an iPod touch. For some devices to receive notifications via Wi-Fi, the device’s display must be on (that
is, it cannot be sleeping) or it must be plugged in. The iPad, on the other hand, remains associated with
the Wi-Fi access point while asleep, thus permitting the delivery of push notifications. The Wi-Fi radio wakes
the host processor for any incoming traffic.
Adding the remote-notification feature to your application requires that you obtain the proper certificates
from the Dev Center for either iOS or OS X and then write the requisite code for the client and provider sides
of the application. “Provisioning and Development” (page 42) explains the provisioning and setup steps, and
“Provider Communication with Apple Push Notification Service” (page 47) and “Scheduling, Registering, and
Handling Notifications” (page 15) describe the details of implementation.
Apple Push Notification service continually monitors providersfor irregular behavior, looking forsudden spikes
of activity, rapid connect-disconnect cycles, and similar activity. Apple seeksto notify providers when it detects
this behavior, and if the behavior continues, it may put the provider’s certificate on a revocation list and refuse
further connections. Any continued irregular or problematic behavior may result in the termination of a
provider's access to APNs.
Local and Push Notifications in Depth
More About Push Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
14This chapter describes the tasks that a iPhone, iPad, or iPod touch application should (or might) do to schedule
local notifications, register remote notifications, and handle both local and remote notifications. Because the
client-side API for push notifications refers to push notifications as remote notifications, that terminology is
used in this chapter.
Preparing Custom Alert Sounds
For remote notifications in iOS, you can specify a custom sound that iOS plays when it presents a local or
remote notification for an application. The sound files must be in the main bundle of the client application.
Because custom alert sounds are played by the iOS system-sound facility, they must be in one of the following
audio data formats:
● Linear PCM
● MA4 (IMA/ADPCM)
● µLaw
● aLaw
You can package the audio data in an aiff, wav, or caf file. Then, in Xcode, add the sound file to your project
as a nonlocalized resource of the application bundle.
You may use the afconvert tool to convert sounds. For example, to convert the 16-bit linear PCM system
sound Submarine.aiff to IMA4 audio in a CAF file, use the following command in the Terminal application:
afconvert /System/Library/Sounds/Submarine.aiff ~/Desktop/sub.caf -d ima4 -f caff
-v
You can inspect a sound to determine its data format by opening it in QuickTime Player and choosing Show
Movie Inspector from the Movie menu.
Custom sounds must be under 30 seconds when played. If a custom sound is over that limit, the defaultsystem
sound is played instead.
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
15
Scheduling, Registering, and Handling NotificationsScheduling Local Notifications
Creating and scheduling local notifications in iOS requires that you perform a few simple steps:
1. Allocate and initialize a UILocalNotification object.
2. Set the date and time that the operating system should deliver the notification. This is the fireDate
property.
If you set the timeZone property to the NSTimeZone object for the current locale, the system automatically
adjusts the fire date when the device travels across (and is reset for) different time zones. (Time zones
affect the values of date components—that is, day, month, hour, year, and minute—that the system
calculates for a given calendar and date value.) You can also schedule the notification for delivery on a
recurring basis (daily, weekly, monthly, and so on).
3. Configure the substance of the notification: alert, icon badge number, and sound.
● The alert has a property for the message (the alertBody property) and for the title of the action
button or slider (alertAction); both of these string values can be internationalized for the user’s
current language preference.
● You set the badge number to display on the application icon through the
applicationIconBadgeNumber property.
● You can assign the filename of a nonlocalized custom sound in the application’s main bundle to the
soundName property; to get the default system sound, assign
UILocalNotificationDefaultSoundName. Sounds should always accompany an alert message
or icon badging; they should not be played otherwise.
4. Optionally, you can attach custom data to the notification through the userInfo property.
Keys and values in the userInfo dictionary must be property-list objects.
5. Schedule the local notification for delivery.
You schedule a local notification by calling the UIApplicationmethod scheduleLocalNotification:.
The application uses the fire date specified in the UILocalNotification object for the moment of
delivery. Alternatively, you can present the notification immediately by calling the
presentLocalNotificationNow: method.
The method in Listing 2-1 creates and schedules a notification to inform the user of a hypothetical to-do list
application about the impending due date of a to-do item. There are a couple things to note about it. For the
alertBody and alertAction properties, it fetches from the main bundle (via the NSLocalizedString
macro) strings localized to the user’s preferred language. It also adds the name of the relevant to-do item to
a dictionary assigned to the userInfo property.
Scheduling, Registering, and Handling Notifications
Scheduling Local Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
16Listing 2-1 Creating, configuring, and scheduling a local notification
- (void)scheduleNotificationWithItem:(ToDoItem *)item interval:(int)minutesBefore
{
NSCalendar *calendar = [NSCalendar autoupdatingCurrentCalendar];
NSDateComponents *dateComps = [[NSDateComponents alloc] init];
[dateComps setDay:item.day];
[dateComps setMonth:item.month];
[dateComps setYear:item.year];
[dateComps setHour:item.hour];
[dateComps setMinute:item.minute];
NSDate *itemDate = [calendar dateFromComponents:dateComps];
[dateComps release];
UILocalNotification *localNotif = [[UILocalNotification alloc] init];
if (localNotif == nil)
return;
localNotif.fireDate = [itemDate addTimeInterval:-(minutesBefore*60)];
localNotif.timeZone = [NSTimeZone defaultTimeZone];
localNotif.alertBody = [NSString stringWithFormat:NSLocalizedString(@"%@ in
%i minutes.", nil),
item.eventName, minutesBefore];
localNotif.alertAction = NSLocalizedString(@"View Details", nil);
localNotif.soundName = UILocalNotificationDefaultSoundName;
localNotif.applicationIconBadgeNumber = 1;
NSDictionary *infoDict = [NSDictionary dictionaryWithObject:item.eventName
forKey:ToDoItemKey];
localNotif.userInfo = infoDict;
[[UIApplication sharedApplication] scheduleLocalNotification:localNotif];
[localNotif release];
}
Scheduling, Registering, and Handling Notifications
Scheduling Local Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
17You can cancel a specific scheduled notification by calling cancelLocalNotification: on the application
object, and you can cancel all scheduled notifications by calling cancelAllLocalNotifications. Both of
these methods also programmatically dismiss a currently displayed notification alert.
Applications might also find local notifications useful when they run in the background and some message,
data, or other item arrivesthat might be of interest to the user. In this case, they should present the notification
immediately using the UIApplication method presentLocalNotificationNow: (iOS gives an application
a limited time to run in the background). Listing 2-2 illustrates how you might do this.
Listing 2-2 Presenting a local notification immediately while running in the background
- (void)applicationDidEnterBackground:(UIApplication *)application {
NSLog(@"Application entered background state.");
// bgTask is instance variable
NSAssert(self->bgTask == UIInvalidBackgroundTask, nil);
bgTask = [application beginBackgroundTaskWithExpirationHandler: ^{
dispatch_async(dispatch_get_main_queue(), ^{
[application endBackgroundTask:self->bgTask];
self->bgTask = UIInvalidBackgroundTask;
});
}];
dispatch_async(dispatch_get_main_queue(), ^{
while ([application backgroundTimeRemaining] > 1.0) {
NSString *friend = [self checkForIncomingChat];
if (friend) {
UILocalNotification *localNotif = [[UILocalNotification alloc]
init];
if (localNotif) {
localNotif.alertBody = [NSString stringWithFormat:
NSLocalizedString(@"%@ has a message for you.", nil),
friend];
localNotif.alertAction = NSLocalizedString(@"Read Message",
nil);
localNotif.soundName = @"alarmsound.caf";
localNotif.applicationIconBadgeNumber = 1;
[application presentLocalNotificationNow:localNotif];
Scheduling, Registering, and Handling Notifications
Scheduling Local Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
18[localNotif release];
friend = nil;
break;
}
}
}
[application endBackgroundTask:self->bgTask];
self->bgTask = UIInvalidBackgroundTask;
});
}
Registering for Remote Notifications
An application must register with Apple Push Notification service for the operating systems on a device and
on a computer to receive remote notifications sent by the application’s provider. Registration has three stages:
1. The application calls the registerForRemoteNotificationTypes: method.
2. The delegate implements the
application:didRegisterForRemoteNotificationsWithDeviceToken: method to receive the
device token.
3. It passes the device token to its provider as a non-object, binary value.
Note: Unless otherwise noted, all methods cited in thissection are declared with identicalsignatures
by both UIApplication and NSApplication, and, for delegates, by both
NSApplicationDelegate Protocol and UIApplicationDelegate.
What happens between the application, the device, Apple Push Notification Service, and the provider during
this sequence is illustrated by Figure 3-3 in “Token Generation and Dispersal” (page 32).
An application should register every time it launches and give its provider the current token. It calls
theregisterForRemoteNotificationTypes: method to kick off the registration process. The parameter
of this method takes a UIRemoteNotificationType (or, for OS X, a NSRemoteNotificationType) bit
mask that specifies the initial types of notifications that the application wishes to receive—for example,
icon-badging and sounds, but not alert messages. In iOS, users can thereafter modify the enabled notification
types in the Notifications preference of the Settings application. In both iOS and OS X, you can retrieve the
Scheduling, Registering, and Handling Notifications
Registering for Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
19currently enabled notification types by calling the enabledRemoteNotificationTypes method. The
operating system does not badge icons, display alert messages, or play alertsoundsif any of these notifications
types are not enabled, even if they are specified in the notification payload.
OS XNote: Because the only notification type supported for non-running applicationsisicon-badging,
simply pass NSRemoteNotificationTypeBadge as the parameter of
registerForRemoteNotificationTypes:.
If registration issuccessful, APNsreturns a device token to the device and iOS passesthe token to the application
delegate in the application:didRegisterForRemoteNotificationsWithDeviceToken: method. The
application should connect with its provider and pass it this token, encoded in binary format. If there is a
problem in obtaining the token, the operating system informs the delegate by calling the
application:didFailToRegisterForRemoteNotificationsWithError:method. The NSError object
passed into this method clearly describes the cause of the error. The error might be, for instance, an erroneous
aps-environment value in the provisioning profile. You should view the error as a transient state and not
attempt to parse it. (See “Creating and Installing the Provisioning Profile” (page 44) for details.)
iOS Note: If a cellular or Wi-Fi connection is not available, neither the
application:didRegisterForRemoteNotificationsWithDeviceToken: method or the
application:didFailToRegisterForRemoteNotificationsWithError: method is called.
For Wi-Fi connections, this sometimes occurs when the device cannot connect with APNs over port
5223. If this happens, the user can move to another Wi-Fi network that isn’t blocking this port or,
on an iPhone or iPad, wait until the cellular data service becomes available. In either case, the
connection should then succeed and one of the delegation methods is called.
By requesting the device token and passing it to the provider every time your application launches, you help
to ensure that the provider has the current token for the device. If a user restores a backup to a device or
computer other than the one that the backup was created for (for example, the user migrates data to a new
device or computer), he or she must launch the application at least once for it to receive notifications again.
If the user restores backup data to a new device or computer, or reinstalls the operating system, the device
token changes. Moreover, never cache a device token and give that to your provider; always get the token
from the system whenever you need it. If your application has previously registered, calling
registerForRemoteNotificationTypes: resultsin the operating system passing the device token to the
delegate immediately without incurring additional overhead.
Listing 2-3 gives a simple example of how you might register for remote notifications in an iOS application.
The code would be nearly identical for a Mac app. (SendProviderDeviceToken is a hypothetical method
defined by the client in which it connects with its provider and passes it the device token.)
Scheduling, Registering, and Handling Notifications
Registering for Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
20Listing 2-3 Registering for remote notifications
- (void)applicationDidFinishLaunching:(UIApplication *)app {
// other setup tasks here....
[[UIApplication sharedApplication]
registerForRemoteNotificationTypes:(UIRemoteNotificationTypeBadge |
UIRemoteNotificationTypeSound)];
}
// Delegation methods
- (void)application:(UIApplication *)app
didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)devToken {
const void *devTokenBytes = [devToken bytes];
self.registered = YES;
[self sendProviderDeviceToken:devTokenBytes]; // custom method
}
- (void)application:(UIApplication *)app
didFailToRegisterForRemoteNotificationsWithError:(NSError *)err {
NSLog(@"Error in registration. Error: %@", err);
}
Handling Local and Remote Notifications
Let’s review the possible scenarios when the operating delivers a local notification or a remote notification for
an application.
● The notification is delivered when the application isn’t running in the foreground.
In this case, the system presents the notification, displaying an alert, badging an icon, perhaps playing a
sound.
● As a result of the presented notification, the user taps the action button of the alert or taps (or clicks) the
application icon.
If the action button is tapped (on a device running iOS), the system launches the application and the
application calls its delegate’s application:didFinishLaunchingWithOptions: method (if
implemented); it passesin the notification payload (for remote notifications) or the local-notification object
(for local notifications).
Scheduling, Registering, and Handling Notifications
Handling Local and Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
21If the application icon is tapped on a device running iOS, the application calls the same method, but
furnishes no information about the notification . If the application icon is clicked on a computer running
OS X, the application calls the delegate’s applicationDidFinishLaunching: method in which the
delegate can obtain the remote-notification payload.
iOS Note: The application delegate could implement applicationDidFinishLaunching:
rather than application:didFinishLaunchingWithOptions:, but that is strongly
discouraged. The latter method allows the application to receive information related to the
reason for its launching, which can include things other than notifications.
● The notification is delivered when the application is running in the foreground.
The application calls its delegate’s application:didReceiveRemoteNotification: method (for
remote notifications) or application:didReceiveLocalNotification:method (forlocal notifications)
and passes in the notification payload or the local-notification object.
Note: The delegate methods cited in this section that have “RemoteNotification” in their name are
declared with identical signatures by by both NSApplicationDelegate Protocol and
UIApplicationDelegate.
An application can use the passed-in remote-notification payload or, in iOS, the UILocalNotification
object to help set the context for processing the item related to the notification. Ideally, the delegate does the
following on each platform to handle the delivery of remote and local notifications in all situations:
● For OS X, it should adopt the NSApplicationDelegate Protocol protocol and implement both the
applicationDidFinishLaunching: method and the
application:didReceiveRemoteNotification: method.
● For iOS, it should should adopt the UIApplicationDelegate protocol and implement both the
application:didFinishLaunchingWithOptions: method and the
application:didReceiveRemoteNotification: or
application:didReceiveLocalNotification: method.
Scheduling, Registering, and Handling Notifications
Handling Local and Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
22iOS Note: In iOS, you can determine whether an application is launched as a result of the user
tapping the action button or whether the notification was delivered to the already-running application
by examining the application state. In the delegate’s implementation of the
application:didReceiveRemoteNotification: or
application:didReceiveLocalNotification: method, get the value of the
applicationState property and evaluate it. If the value is UIApplicationStateInactive, the
user tapped the action button; if the value is UIApplicationStateActive, the application was
frontmost when it received the notification.
The delegate for an iOS application in Listing 2-4 implements the
application:didFinishLaunchingWithOptions: method to handle a local notification. It gets the
associated UILocalNotification object from the launch-options dictionary using the
UIApplicationLaunchOptionsLocalNotificationKey key. From the UILocalNotification object’s
userInfo dictionary, it accesses the to-do item that is the reason for the notification and uses it to set the
application’s initial context. As shown in this example, you should appropriately reset the badge number on
the application icon—or remove it if there are no outstanding items—as part of handling the notification.
Listing 2-4 Handling a local notification when an application is launched
- (BOOL)application:(UIApplication *)app didFinishLaunchingWithOptions:(NSDictionary
*)launchOptions {
UILocalNotification *localNotif =
[launchOptions objectForKey:UIApplicationLaunchOptionsLocalNotificationKey];
if (localNotif) {
NSString *itemName = [localNotif.userInfo objectForKey:ToDoItemKey];
[viewController displayItem:itemName]; // custom method
application.applicationIconBadgeNumber =
localNotif.applicationIconBadgeNumber-1;
}
[window addSubview:viewController.view];
[window makeKeyAndVisible];
return YES;
}
The implementation for a remote notification would be similar, except that you would use a specially declared
constant in each platform as a key to access the notification payload:
Scheduling, Registering, and Handling Notifications
Handling Local and Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
23●
In iOS, the delegate, in its implementation of the application:didFinishLaunchingWithOptions:
method, usesthe UIApplicationLaunchOptionsRemoteNotificationKey key to accessthe payload
from the launch-options dictionary.
●
In OS X, the delegate, in its implementation of the applicationDidFinishLaunching: method, uses
the the NSApplicationLaunchRemoteNotificationKey key to access the payload dictionary from
the userInfo dictionary of the NSNotification object that is passed into the method.
The payload itself is an NSDictionary object that contains the elements of the notification—alert message,
badge number, sound, and so on. It can also contain custom data the application can use to provide context
when setting up the initial user interface. See “The Notification Payload” (page 35) for details about the
remote-notification payload.
Important: You should never define custom properties in the notification payload for the purpose of
transporting customer data or any other sensitive data. Delivery of remote notifications is not guaranteed.
One example of an appropriate usage for a custom payload property is a string identifying an email account
from which messages are downloaded to an email client; the application can incorporate this string in its
download user-interface. Another example of custom payload property is a timestamp for when the provider
first sent the notification; the client application can use this value to gauge how old the notification is.
When handling remote notifications in application:didFinishLaunchingWithOptions: or
applicationDidFinishLaunching:, the application delegate might perform a major additional task. Just
after the application launches, the delegate should connect with its provider and fetch the waiting data. Listing
2-5 gives a schematic illustration of this procedure.
Listing 2-5 Downloading data from a provider
- (void)application:(UIApplication *)app didFinishLaunchingWithOptions:(NSDictionary
*)opts {
// check launchOptions for notification payload and custom data, set UI context
[self startDownloadingDataFromProvider]; // custom method
app.applicationIconBadgeNumber = 0;
// other setup tasks here....
}
Scheduling, Registering, and Handling Notifications
Handling Local and Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
24Note: A client application should always communicate with its provider asynchronously or on a
secondary thread.
The code in Listing 2-6 shows an implementation of the application:didReceiveLocalNotification:
method which, as you’ll recall, is called when application is running in the foreground. Here the application
delegate doesthe same work asit doesin Listing 2-4. It can accessthe UILocalNotification object directly
this time because this object is an argument of the method.
Listing 2-6 Handling a local notification when an application is already running
- (void)application:(UIApplication *)app
didReceiveLocalNotification:(UILocalNotification *)notif {
NSString *itemName = [notif.userInfo objectForKey:ToDoItemKey]
[viewController displayItem:itemName]; // custom method
application.applicationIconBadgeNumber =
notification.applicationIconBadgeNumber-1;
}
If you want your application to catch remote notifications that the system delivers while it is running in the
foreground, the application delegate should implement the
application:didReceiveRemoteNotification: method. The delegate should begin the procedure for
downloading the waiting data, message, or other item and, after this concludes, it should remove the badge
from the application icon. (If your application frequently checks with its provider for new data, implementing
this method might not be necessary.) The dictionary passed in the second parameter of this method is the
notification payload; you should not use any custom properties it contains to alter your application’s current
context.
Even though the only supported notification type for nonrunning applications in OS X is icon-badging, the
delegate can implement application:didReceiveRemoteNotification: to examine the notification
payload for other types of notifications and handle them appropriately (that is, display an alert or play a sound).
Scheduling, Registering, and Handling Notifications
Handling Local and Remote Notifications
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
25iOS Note: If the user unlocks the device shortly after a remote-notification alert is displayed, the
operating system automatically triggers the action associated with the alert. (This behavior is
consistent with SMS and calendar alerts.) This makes it even more important that actions related to
remote notifications do not have destructive consequences. A user should always make decisions
that result in the destruction of data in the context of the application that stores the data.
Passing the Provider the Current Language Preference (Remote
Notifications)
If an application doesn’t use the loc-key and loc-args properties of the aps dictionary for client-side
fetching of localized alert messages, the provider needs to localize the text of alert messages it puts in the
notification payload. To do this, however, the provider needs to know the language that the device user has
selected as the preferred language. (The user sets this preference in the General > International > Language
view of the Settings application.) The client application should send its provider an identifier of the preferred
language; this could be a canonicalized IETF BCP 47 language identifier such as “en” or “fr”.
Note: For more information about the loc-key and loc-args properties and client-side message
localizations, see “The Notification Payload” (page 35).
Listing 2-7 illustrates a technique for obtaining the currently selected language and communicating it to the
provider. In iOS, the array returned by the preferredLanguages of NSLocale contains one object: an
NSString object encapsulating the language code identifying the preferred language. The UTF8String
coverts the string object to a C string encoded as UTF8.
Listing 2-7 Getting the current supported language and sending it to the provider
NSString *preferredLang = [[NSLocale preferredLanguages] objectAtIndex:0];
const char *langStr = [preferredLang UTF8String];
[self sendProviderCurrentLanguage:langStr]; // custom method
}
The application might send its provider the preferred language every time the user changes something in the
current locale. To do this, you can listen for the notification named
NSCurrentLocaleDidChangeNotification and, in your notification-handling method, get the code
identifying the preferred language and send that to your provider.
Scheduling, Registering, and Handling Notifications
Passing the Provider the Current Language Preference (Remote Notifications)
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
26If the preferred language is not one the application supports, the provider should localize the message text in
a widely spoken fallback language such as English or Spanish.
Scheduling, Registering, and Handling Notifications
Passing the Provider the Current Language Preference (Remote Notifications)
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
27Apple Push Notification service (APNsforshort) isthe centerpiece of the push notificationsfeature. It is a robust
and highly efficientservice for propagating information to devicessuch asiPhone, iPad, and iPod touch devices.
Each device establishes an accredited and encrypted IP connection with the service and receives notifications
over this persistent connection. If a notification for an application arrives when that application is not running,
the device alerts the user that the application has data waiting for it.
Software developers (“providers”) originate the notifications in their server software. The provider connects
with APNs through a persistent and secure channel while monitoring incoming data intended for their client
applications. When new data for an application arrives, the provider prepares and sends a notification through
the channel to APNs, which pushes the notification to the target device.
In addition to being a simple but efficient and high-capacity transport service, APNs includes a default
quality-of-service component that provides store-and-forward capabilities. See “Quality of Service” (page 30)
for more information.
“Provider Communication with Apple Push Notification Service” (page 47) and “Scheduling, Registering, and
Handling Notifications” (page 15) discuss the specific implementation requirements for providers and iOS
applications, respectively.
A Push Notification and Its Path
Apple Push Notification service transports and routes a notification from a given provider to a given device.
A notification is a short message consisting of two major pieces of data: the device token and the payload. The
device token is analogous to a phone number; it contains information that enables APNs to locate the device
on which the client application is installed. APNs also uses it to authenticate the routing of a notification. The
payload is a JSON-defined property list thatspecifies how the user of an application on a device isto be alerted.
Note: For more information about the device token,see “Security Architecture” (page 30); for further
information about the notification payload, see “The Notification Payload” (page 35) .
The flow of remote-notification data is one-way. The provider composes a notification package that includes
the device token for a client application and the payload. The provider sends the notification to APNs which
in turn pushes the notification to the device.
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
28
Apple Push Notification ServiceWhen it authenticates itself to APNs, a provider furnishes the service with its topic, which identifies the
application for which it’s providing data. The topic is currently the bundle identifier of the target application
on an iOS device.
Figure 3-1 A push notification from a provider to a client application
Provider APNS notification notification
Client
App
iPhone
notification
Figure 3-1 is a greatly simplified depiction of the virtual network APNs makes possible among providers and
devices. The device-facing and provider-facing sides of APNs both have multiple points of connection; on the
provider-facing side, these are called gateways. There are typically multiple providers, each making one or
more persistent and secure connections with APNs through these gateways. And these providers are sending
notifications through APNs to many devices on which their client applications are installed. Figure 3-2 is a
slightly more realistic depiction.
Figure 3-2 Push notifications from multiple providers to multiple devices
APNS
Provider
B
Provider
A
Feedback Service
Sometimes APNs might attempt to deliver notifications for an application on a device, but the device may
repeatedly refuse delivery because there is no target application. This often happens when the user has
uninstalled the application. In these cases, APNs informs the provider through a feedback service that the
provider connects with. The feedback service maintains a list of devices per application for which there were
recent, repeated failed attempts to deliver notifications. The provider should obtain this list of devices and
stop sending notifications to them. For more on this service, see “The Feedback Service” (page 53).
Apple Push Notification Service
Feedback Service
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
29Quality of Service
Apple Push Notification Service includes a default Quality of Service (QoS) component that performs a
store-and-forward function. If APNs attempts to deliver a notification but the device is offline, the QoS stores
the notification. It retains only one notification per application on a device: the last notification received from
a provider for that application. When the offline device later reconnects, the QoS forwardsthe stored notification
to the device. The QoS retains a notification for a limited period before deleting it.
Security Architecture
To enable communication between a provider and a device, Apple Push Notification Service must expose
certain entry points to them. But then to ensure security, it must also regulate access to these entry points.
For this purpose, APNs requires two different levels of trust for providers, devices, and their communications.
These are known as connection trust and token trust.
Connection trust establishes certainty that, on one side, the APNs connection is with an authorized provider
with whom Apple has agreed to deliver notifications. At the device side of the connection, APNs must validate
that the connection is with a legitimate device.
After APNs has established trust at the entry points, it must then ensure that it conveys notificationsto legitimate
end points only. To do this, it must validate the routing of messages traveling through the transport; only the
device that is the intended target of a notification should receive it.
In APNs, assurance of accurate message routing—or token trust—is made possible through the device token.
A device token is an opaque identifier of a device that APNs gives to the device when it first connects with it.
The device shares the device token with its provider. Thereafter, this token accompanies each notification from
the provider. It is the basis for establishing trust that the routing of a particular notification is legitimate. (In a
metaphorical sense, it has the same function as a phone number, identifying the destination of a
communication.)
Note: A device token is not the same thing asthe device UDID returned by the uniqueIdentifier
property of UIDevice.
The following sections discuss the requisite components for connection trust and token trust as well as the
four procedures for establishing trust.
Apple Push Notification Service
Quality of Service
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
30Service-to-Device Connection Trust
APNs establishes the identity of a connecting device through TLS peer-to-peer authentication. (Note that iOS
takes care of this stage of connection trust; you do not need to implement anything yourself.) In the course
of this procedure, a device initiates a TLS connection with APNs, which returns its server certificate. The device
validates this certificate and then sends its device certificate to APNs, which validates that certificate.
TLS initiation
Device certificate
Server certificate
TLS established
Validate device certificate
Device APNS
Validate server certificate
Provider-to-Service Connection Trust
Connection trust between a provider and APNs is also established through TLS peer-to-peer authentication.
The procedure is similar to that described in “Service-to-Device Connection Trust” (page 31). The provider
initiates a TLS connection, getsthe server certificate from APNs, and validatesthat certificate. Then the provider
Apple Push Notification Service
Security Architecture
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
31sends its provider certificate to APNs, which validates it on its end. Once this procedure is complete, a secure
TLS connection has been established; APNsis now satisfied that the connection has been made by a legitimate
provider.
TLS initiation
Provider certificate
Server certificate
TLS established
Validate provider certificate
Provider APNS
Validate server certificate
Note that provider connection is valid for delivery to only one specific application, identified by the topic
(bundle ID) specified in the certificate. APNs also maintains a certificate revocation list; if a provider’s certificate
is on this list, APNs may revoke provider trust (that is, refuse the connection).
Token Generation and Dispersal
An iOS-based application must register to receive push notifications; it typically does this right after it is
installed on a device. (This procedure is described in “Scheduling, Registering, and Handling Notifications” (page
15).) iOS receives the registration request from an application, connects with APNs, and forwards the request.
Apple Push Notification Service
Security Architecture
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
32APNs generates a device token using information contained in the unique device certificate. The device token
contains an identifier of the device. It then encrypts the device token with a token key and returns it to the
device.
Token
Connect (Token, ...)
Token
Generate token package
Encrypt token with token key
Generate device ID from
device certificate
Provider Device APNS
The device returns the device token to the requesting application as an NSData object. The application then
must then deliver the device token to its provider in either binary or hexadecimal format. Figure 3-3 also
illustratesthe token generation and dispersalsequence, but in addition showsthe role of the client application
in furnishing its provider with the device token.
Figure 3-3 Sharing the device token
deviceToken
APNS
Provider
Client
App
2
1
3
4
SSL connect
deviceToken
deviceToken
The form of this phase of token trust ensures that only APNs generates the token which it will later honor, and
it can assure itself that a token handed to it by a device is the same token that it previously provisioned for
that particular device—and only for that device.
Apple Push Notification Service
Security Architecture
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
33Token Trust (Notification)
After iOS obtains a device token from APNs, as described in “Token Generation and Dispersal” (page 32), it
must provide APNs with the token every time it connects with it. APNs decrypts the device token and validates
that the token was generated for the connecting device. To validate, APNs ensures that the device identifier
contained in the token matches the device identifier in the device certificate.
Every notification that a provider sends to APNs for delivery to a device must be accompanied by the device
token it obtained from an application on that device. APNs decrypts the token using the token key, thereby
ensuring that the notification is valid. It then uses the device ID contained in the device token to determine
the destination device for the notification.
Token, Payload
Response (OK)
Payload
Connect (Token, ...)
Decrypt token and validate
with device certificate
Provider APNS Device
Decrypt token with
token key
Trust Components
To support the security model for APNs, providers and devices must possess certain certificates, certificate
authority (CA) certificates, or tokens.
● Provider: Each provider requires a unique provider certificate and private cryptographic key for validating
their connection with APNs. This certificate, provisioned by Apple, must identify the particular topic
published by the provider; the topic is the bundle ID of the client application. For each notification, the
provider must furnish APNs with a device token identifying the target device. The provider may optionally
wish to validate the service it is connecting to using the public server certificate provided by the APNs
server.
Apple Push Notification Service
Security Architecture
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
34● Device: iOS uses the public server certificate passed to it by APNs to authenticate the service that it has
connected to. It has a unique private key and certificate that it uses to authenticate itself to the service
and establish the TLS connection. It obtains the device certificate and key during device activation and
stores them in the keychain. iOS also holds its particular device token, which it receives during the service
connection process. Each registered client application isresponsible for delivering thistoken to its content
provider.
APNs servers also have the necessary certificates, CA certificates, and cryptographic keys (private and public)
for validating connections and the identities of providers and devices.
The Notification Payload
Each push notification carries with it a payload. The payload specifies how users are to be alerted to the data
waiting to be downloaded to the client application. The maximum size allowed for a notification payload is
256 bytes; Apple Push Notification Service refuses any notification that exceeds this limit. Remember that
delivery of notifications is “best effort” and is not guaranteed.
For each notification, providers must compose a JSON dictionary object that strictly adheres to RFC 4627. This
dictionary must contain another dictionary identified by the key aps. The aps dictionary contains one or more
properties that specify the following actions:
● An alert message to display to the user
● A number to badge the application icon with
● A sound to play
Note: Although you can combine an alert message, icon badging, and a sound in a single notification,
you should consider the human-interface implications with push notifications. For example, a user
might find frequent alert messages with accompanying sound more annoying than useful, especially
when the data to be downloaded is not critical.
If the target application isn’t running when the notification arrives, the alert message, sound, or badge value
is played orshown. If the application isrunning, iOS deliversit to the application delegate as an NSDictionary
object. The dictionary contains the corresponding Cocoa property-list objects (plus NSNull).
Providers can specify custom payload values outside the Apple-reserved aps namespace. Custom values must
use the JSON structured and primitive types: dictionary (object), array,string, number, and Boolean. You should
not include customer information as custom payload data. Instead, use it for such purposes as setting context
(for the user interface) or internal metrics. For example, a custom payload value might be a conversation
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
35identifier for use by an instant-message client application or a timestamp identifying when the provider sent
the notification. Any action associated with an alert message should not be destructive—for example, deleting
data on the device.
Important: Because delivery is not guaranteed, you should not depend on the remote-notificationsfacility
for delivering critical data to an application via the payload. And never include sensitive data in the payload.
You should use it only to notify the user that new data is available.
Table 3-1 lists the keys and expected values of the aps payload.
Table 3-1 Keys and values of the aps dictionary
Key Value type Comment
If this property is included, iOS displays a standard alert. You may specify a
string asthe value of alert or a dictionary asits value. If you specify a string,
it becomes the message text of an alert with two buttons: Close and View.
If the user taps View, the application is launched.
Alternatively, you can specify a dictionary as the value of alert. See Table
3-2 (page 36) for descriptions of the keys of this dictionary.
string or
dictionary
alert
The number to display as the badge of the application icon. If this property
is absent, the badge is not changed. To remove the badge, set the value of
this property to 0.
badge number
The name of a sound file in the application bundle. The sound in this file is
played as an alert. If the sound file doesn’t exist or default is specified as
the value, the default alert sound is played. The audio must be in one of the
audio data formats that are compatible with system sounds; see “Preparing
Custom Alert Sounds” (page 15) for details.
sound string
Table 3-2 Child properties of the alert property
Value Comment
type
Key
body string The text of the alert message.
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
36Value Comment
type
Key
If a string is specified, displays an alert with two buttons, whose
behavior is described in Table 3-1. However, iOS uses the string
as a key to get a localized string in the current localization to use
for the right button’s title instead of “View”. If the value is null,
the system displays an alert with a single OK button that simply
dismisses the alert when tapped. See “Localized Formatted
Strings” (page 37) for more information.
string or
null
action-loc-key
A key to an alert-message string in a Localizable.strings file
for the current localization (which is set by the user’s language
preference). The key string can be formatted with %@ and %n$@
specifiers to take the variables specified in loc-args. See
“Localized Formatted Strings” (page 37) for more information.
loc-key string
Variable string values to appear in place of the format specifiers
in loc-key. See “Localized Formatted Strings” (page 37) for more
information.
array of
strings
loc-args
The filename of an image file in the application bundle; it may
include the extension or omit it. The image is used as the launch
image when userstap the action button or move the action slider.
If this property is notspecified, the system either usesthe previous
snapshot,uses the image identified by the UILaunchImageFile
key in the application’s Info.plist file, or falls back to
Default.png.
This property was added in iOS 4.0.
launch-image string
Note: If you want the iPhone, iPad, or iPod touch device to display the message text as-is in an alert
that has both the Close and View buttons, then specify a string as the direct value of alert. Don’t
specify a dictionary as the value of alert if the dictionary only has the body property.
Localized Formatted Strings
You can display localized alert messages in two ways. The server originating the notification can localize the
text; to do this, it must discover the current language preference selected for the device (see “Passing the
Provider the Current Language Preference (Remote Notifications)” (page 26)). Or the client application can
store in its bundle the alert-message strings translated for each localization it supports. The provider specifies
the loc-key and loc-args properties in the aps dictionary of the notification payload. When the device
receives the notification (assuming the application isn’t running), it uses these aps-dictionary properties to
find and format the string localized for the current language, which it then displays to the user.
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
37Here’s how that second option works in a little more detail.
An iOS application can internationalize resources such as images, sounds, and text for each language that it
supports, Internationalization collects the resources and puts them in a subdirectory of the bundle with a
two-part name: a language code and an extension of .lproj (for example, fr.lproj). Localized strings that
are programmatically displayed are put in a file called Localizable.strings. Each entry in this file has a
key and a localized string value; the string can have format specifiers for the substitution of variable values.
When an application asksfor a particular resource—say a localized string—it getsthe resource that islocalized
for the language currently selected by the user. For example, if the preferred language is French, the
corresponding string value for an alert message would be fetched from Localizable.strings in the
fr.lproj directory in the application bundle. (iOS makes this request through the NSLocalizedString
macro.)
Note: This general pattern is also followed when the value of the action-loc-key property is a
string. This string is a key into the Localizable.strings in the localization directory for the
currently selected language. iOS uses this key to get the title of the button on the right side of an
alert message (the “action” button).
To make this clearer, let’s consider an example. The provider specifies the following dictionary as the value of
the alert property:
"alert" : { "loc-key" : "GAME_PLAY_REQUEST_FORMAT", "loc-args" : [ "Jenna", "Frank"]
},
When the device receives the notification, it uses "GAME_PLAY_REQUEST_FORMAT" as a key to look up the
associated string value in the Localizable.strings file in the .lproj directory for the current language.
Assuming the current localization has an Localizable.strings entry such as this:
"GAME_PLAY_REQUEST_FORMAT" = "%@ and %@ have invited you to play Monopoly";
the device displays an alert with the message “Jenna and Frank have invited you to play Monopoly”.
In addition to the format specifier %@, you can %n$@ format specifiers for positional substitution of string
variables. The n is the index (starting with 1) of the array value in loc-args to substitute. (There’s also the %%
specifier for expressing a percentage sign (%).) So if the entry in Localizable.strings is this:
"GAME_PLAY_REQUEST_FORMAT" = "%2$@ and %1$@ have invited you to play Monopoly";
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
38the device displays an alert with the message "Frank and Jenna have invited you to play Monopoly".
For a full example of a notification payload that usesthe loc-key and loc-arg properties,see the last example
of “Examples of JSON Payloads.” To learn more about internationalization in iOS, see ““Advanced App Tricks”” in
iOS App Programming Guide ; for general information about internationalization, see Internationalization
Programming Topics. String formatting is discussed in “Formatting String Objects” in String Programming Guide .
Note: You should use the loc-key and loc-args properties—and the alert dictionary in
general—only if you absolutely need to. The values of these properties, especially if they are long
strings, might use up more bandwidth than is good for performance. Many if not most applications
may not need these properties because their message strings are originated by users and thus are
implicitly "localized."
Examples of JSON Payloads
The following examples of the payload portion of notifications illustrate the practical use of the properties
listed in Table 3-1. Properties with “acme” in the key name are examples of custom payload data. The examples
include whitespace and newline characters for readability; for better performance, providers should omit
whitespace and newline characters.
Example 1: The following payload has an aps dictionary with a simple, recommended form for alert messages
with the default alert buttons (Close and View). It uses a string as the value of alert rather than a dictionary.
This payload also has a custom array property.
{
"aps" : { "alert" : "Message received from Bob" },
"acme2" : [ "bang", "whiz" ]
}
Example 2. The payload in the example uses an aps dictionary to request that the device display an alert
message with an Close button on the left and a localized title for the "action" button on the right side of the
alert. In this case, “PLAY” is used as a key into the Localizable.strings file for the currently selected
language to get the localized equivalent of “Play”. The aps dictionary also requests that the application icon
be badged with 5.
{ "aps" : { "alert" : { "body" : "Bob wants to play poker",
"action-loc-key" : "PLAY" }, "badge" : 5, }, "acme1" : "bar",
"acme2" : [ "bang", "whiz" ] }
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
39Example 3. The payload in this example specifies that device should display an alert message with both Close
and View buttons. It also request that the application icon be badged with 9 and that a bundled alert sound
be played when the notification is delivered.
{
"aps" : {
"alert" : "You got your emails.",
"badge" : 9,
"sound" : "bingbong.aiff"
},
"acme1" : "bar",
"acme2" : 42
}
Example 4. The interesting thing about the payload in this example is that it uses the loc-key and loc-args
child properties of the alert dictionary to fetch a formatted localized string from the application’s bundle
and substitute the variable string values(loc-args) in the appropriate places. It also specifies a custom sound
and include a custom property.
{
"aps" : {
"alert" : { "loc-key" : "GAME_PLAY_REQUEST_FORMAT", "loc-args" : [ "Jenna",
"Frank"] },
"sound" : "chime"
},
"acme" : "foo"
}
Example 5. The following example shows an empty aps dictionary; because the badge property is missing,
any current badge number shown on the application icon is removed. The acme2 custom property is an array
of two integers.
{
"aps" : {
},
"acme2" : [ 5, 8 ]
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
40}
Remember, for better performance, you should strip all whitespace and newline characters from the payload
before including it in the notification.
Apple Push Notification Service
The Notification Payload
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
41Sandbox and Production Environments
To develop and deploy the provider side of a client/server application, you must get SSL certificates from the
appropriate Dev Center. Each certificate is limited to a single application, identified by its bundle ID. Each
certificate is also limited to one of two development environments, each with its own assigned IP address:
● Sandbox: The sandbox environment is used for initial development and testing of the provider application.
It provides the same set of services as the production environment, although with a smaller number of
server units. The sandbox environment also acts a virtual device, enabling simulated end-to-end testing.
You accessthe sandbox environment at gateway.sandbox.push.apple.com, outbound TCP port 2195.
● Production: Use the production environment when building the production version of the provider
application. Applications using the production environment must meet Apple’s reliability requirements.
You access the production environment at gateway.push.apple.com, outbound TCP port 2195.
You must getseparate certificatesfor the sandbox (development) environment and the production environment.
The certificates are associated with an identifier of the application that is the recipient of push notifications;
this identifier includes the application’s bundle ID. When you create a provisioning profile for one of the
environments, the requisite entitlements are automatically added to the profile, including the entitlement
specific to push notifications, . The two provisioning profiles are called Development
and Distribution. The Distribution provisioning profile is a requirement for submitting your application to the
App Store.
OS X Note: The entitlement for the OS X provisioning profile is
com.apple.developer.aps-environment, which scopes it to the platform.
You can determine in Xcode which environment you are in by the selection of a code-signing identity. If you
see an “iPhone Developer: Firstname Lastname ” certificate/provisioning profile pair, you are in the sandbox
environment. If you see an “iPhone Distribution: Companyname ” certificate/provisioning profile pair, you are
in the production environment. It is a good idea to create a Distribution release configuration in Xcode to help
you further differentiate the environments.
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
42
Provisioning and DevelopmentAlthough an SSL certificate is not put into a provisioning profile, the is added to the
profile because of the association of the certificate and a particular application ID. As a result this entitlement
is built into the application, which enables it to receive push notifications.
Provisioning Procedures
In the iOS Developer Program, each member on a development team has one of three roles: team agent, team
admin, and team member. The roles differ in relation to iPhone development certificates and provisioning
profiles. The team agent isthe only person on the team who can create Development (Sandbox) SSL certificates
and Distribution (Production) SSL certificates. The team admin and the team agent can both create both
Development and Distribution provisioning profiles. Team members may only download and install certificates
and provisioning profiles. The procedures in the following sections make reference to these roles.
Note: The iOS Provisioning Portal makes available to all iOS Developer Program members a user
guide and a series of videos that explain all aspects of certificate creation and provisioning. The
following sections focus on APNs-specific aspects of the process and summarize other aspects. To
access the portal, iOS Developer Program members should go to the iOS Dev Center (http://developer.apple.com/devcenter/ios), log in, and click then go to the iOS Provisioning Portal page (there’s
a link in the upper right).
Creating the SSL Certificate and Keys
In the provisioning portal of the iOS Dev Center, the team agent selects the application IDs for APNs. He also
completes the following steps to create the SSL certificate:
1. Click App IDs in the sidebar on the left side of the window.
The next page displays your valid application IDs. An application ID consists of an application’s bundle ID
prefixed with a ten-character code generated by Apple. The team admin must enter the bundle ID. For a
certificate, it must incorporate a specific bundle ID; you cannot use a “wildcard” application ID.
2. Locate the application ID for the sandbox SSL certificate (and that is associated with the Development
provisioning profile) and click Configure.
You must see “Available” under the Apple Push Notification Service column to configure a certificate for
this application ID.
3. In the Configure App ID page, check the Enable Push Notification Services box and click the Configure
button.
Clicking this button launches an APNs Assistant, which guides you through the next series of steps.
Provisioning and Development
Provisioning Procedures
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
434. The first step requires that you launch the Keychain Access application and generate a Certificate Signing
Request (CSR).
Follow the instructions presented in the assistant. When you are finished generating a CSR, click Continue
in Keychain Access to return to the APNs Assistant.
When you create a CSR, Keychain Access generates a private and a public cryptographic key pair. The
private key is put into your Login keychain by default. The public key is included in the CSR sent to the
provisioning authority. When the provisioning authority sendsthe certificate back to you, one of the items
in that certificate is the public key.
5. In the Submit Certificate Signing Request pane, click Choose File. Navigate to the CSR file you created in
the previous step and select it.
6. Click the Generate button.
While displaying the Generate Your Certificate pane, the Assistant configures and generates your Client
SSL Certificate. If it succeeds, it displays the message “Your APNs Certificate has been generated.” Click
Continue to proceed to the next step.
7. In the next pane, click the Download Now button to download the certificate file to your download location.
Navigate to that location and double-click the certificate file (which has an extension of cer) to install it
in your keychain. When you are finished, click Done in the APNs Assistant.
Double-clicking the file launches Keychain Access. Make sure you install the certificate in your login keychain
on the computer you are using for provider development. In Keychain Access, ensure that your certificate
user ID matches your application’s bundle ID. The APNs SSL certificate should be installed on your
notification server.
When you finish these steps you are returned to the Configure App ID page of the iOS Dev Center portal. The
certificate should be badged with a green circle and the label “Enabled”.
To create a certificate for the production environment, repeat the same procedure but choose the application
ID for the production certificate.
Creating and Installing the Provisioning Profile
The Team Admin or Team Agent must next create the provisioning profile (Development or Distribution) used
in the server side of remote-notification development. The provisioning profile is a collection of assets that
associates developers of an application and their devices with an authorized development team and enables
those devicesto be used for testing. The profile contains certificates, device identifiers, the application’s bundle
ID, and all entitlements, including . All team members must install the provisioning
profile on the devices on which they will run and test application code.
Provisioning and Development
Provisioning Procedures
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
44Note: Refer to the program user guide for the details of creating a provisioning profile.
To download and install the provisioning profile, team members should complete the following steps:
1. Go to the provisioning portal in the iOS Dev Center.
2. Create a new provisioning profile that contains the App ID you registered for APNs.
3. Modify any existing profile before you download the new one.
You have to modify the profile in some minor way (for example, toggle an option) for the portal to generate
a new provisioning profile. If the profile isn't so “dirtied,” you're given the original profile without the push
entitlements.
4. From the download location, drag the profile file (which has an extension of mobileprovision) onto
the Xcode or iTunes application icons.
Alternatively, you can move the profile file to ~/Library/MobileDevice/Provisioning Profiles.
Create the directory if it does not exist.
5. Verify that the entitlements in the provisioning-profile file are correct. To do this, open the
.mobileprovision file in a text editor. The contents of the file are structured in XML. In the Entitlements
dictionary locate the aps-environment key. For a development provisioning profile, the string value of
this key should be development; for a distribution provisioning profile, the string value should be
production.
6. In the Xcode Organizer window, go the Provisioning Profiles section and install the profile on your device.
When you build the project, the binary is now signed by the certificate using the private key.
Installing the SSL Certificate and Key on the Server
You should install the SSL distribution certificate and private cryptographic key you obtained earlier on the
server computer on which the provider code runs and from which it connects with the sandbox or production
versions of APNs. To do so, complete the following steps:
1. Open Keychain Access utility and click the My Certificates category in the left pane.
2. Find the certificate you want to install and disclose its contents.
You'll see both a certificate and a private key.
3. Select both the certificate and key, choose File > Export Items, and export them as a Personal Information
Exchange (.p12) file.
4. Servers implemented in languages such as Ruby and Perl often are better able to deal with certificates in
the Personal Information Exchange format. To convert the certificate to thisformat, complete the following
steps:
Provisioning and Development
Provisioning Procedures
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
45a. In KeyChain Access,select the certificate and choose File > Export Items. Select the Personal Information
Exchange (.p12) option, select a save location, and click Save.
b. Launch the Terminal application and enter the following command after the prompt:
openssl pkcs12 -in CertificateName.p12 -out CertificateName.pem -nodes
5. Copy the .pem certificate to the new computer and install it in the appropriate place.
Provisioning and Development
Provisioning Procedures
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
46This chapter describesthe interfacesthat providers use for communication with Apple Push Notification service
(APNs) and discusses some of the functions that providers are expected to fulfill.
General Provider Requirements
As a provider you communicate with Apple Push Notification service over a binary interface. This interface is
a high-speed, high-capacity interface for providers; it uses a streaming TCP socket design in conjunction with
binary content. The binary interface is asynchronous.
The binary interface of the production environment is available through gateway.push.apple.com, port
2195; the binary interface of the sandbox (development) environment is available through
gateway.sandbox.push.apple.com, port 2195. You may establish multiple, parallel connections to the
same gateway or to multiple gateway instances.
For each interface you should use TLS (or SSL) to establish a secured communications channel. The SSL certificate
required for these connections is provisioned through the iOS Provisioning Portal. (See “Provisioning and
Development” (page 42) for details.) To establish a trusted provider identity, you should present this certificate
to APNs at connection time using peer-to-peer authentication.
Note: To establish a TLS session with APNs, an Entrust Secure CA root certificate must be installed
on the provider’s server. If the server is running OS X, this root certificate is already in the keychain.
On other systems, the certificate might not be available. You can download this certificate from the
Entrust SSL Certificates website.
You should also retain connections with APNs across multiple notifications. APNs may consider connections
that are rapidly and repeatedly established and torn down as a denial-of-service attack. Upon error, APNs closes
the connection on which the error occurred.
As a provider, you are responsible for the following aspects of push notifications:
● You must compose the notification payload (see “The Notification Payload” (page 35)).
● You are responsible for supplying the badge number to be displayed on the application icon.
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
47
Provider Communication with Apple Push
Notification Service● You should regularly connect with the feedback web server and fetch the current list of those devices that
have repeatedly reported failed-delivery attempts. Then you should cease sending notifications to the
devices associated with those applications. See “The Feedback Service” (page 53) for more information.
If you intend to support notification messagesin multiple languages, but do not use the loc-key and loc-args
properties of the aps payload dictionary for client-side fetching of localized alert strings, you need to localize
the text of alert messages on the server side. To do this, you need to find out the current language preference
from the client application. “Scheduling, Registering, and Handling Notifications” (page 15) suggests an
approach for obtaining this information. See “The Notification Payload” (page 35) for information about the
loc-key and loc-args properties.
The Binary Interface and Notification Formats
The binary interface employs a plain TCP socket for binary content that is streaming in nature. For optimum
performance, you should batch multiple notificationsin a single transmission over the interface, either explicitly
or using a TCP/IP Nagle algorithm.
The interface supports two formats for notification packets, a simple format and an enhanced format that
addresses some of the issues with the simple format:
● Notification expiry. APNs has a store-and-forward feature that keeps the most recent notification sent to
an application on a device. If the device is offline at time of delivery, APNs delivers the notification when
the device next comes online. With the simple format, the notification is delivered regardless of the
pertinence of the notification. In other words, the notification can become “stale” over time. The enhanced
format includes an expiry value that indicates the period of validity for a notification. APNs discards a
notification in store-and-forward when this period expires.
● Error response. With the simple format, if you send a notification packet that is malformed in some
way—for example, the payload exceeds the stipulated limit—APNs responds by severing the connection.
It gives no indication why it rejected the notification. The enhanced format lets a provider tag a notification
with an arbitrary identifier. If there is an error, APNs returns a packet that associates an error code with
the identifier. This response enables the provider to locate and correct the malformed notification.
The enhanced format is recommended for most providers.
Provider Communication with Apple Push Notification Service
The Binary Interface and Notification Formats
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
48Let’s examine the simple notification format first because much of this format is shared with the enhanced
format. Figure 5-1 illustrates this format.
Figure 5-1 Simple notification format
0 0 32 deviceToken (binary) 0 34 {"aps":{"alert":"You have mail!"}}
Bytes: 1 2 32 2
Command
Token length Payload length
(big endian) (big endian)
34
The first byte in the simple format is a command value of 0 (zero). The lengths of the device token and the
payload must be in network order (that is, big endian). In addition, you should encode the device token in
binary format. The payload must not exceed 256 bytes and must not be null-terminated.
Listing 5-1 gives an example of a function that sends a push notification to APNs over the binary interface
using the simple notification format. The example assumes prior SSL connection to gateway.push.apple.com
(or gateway.sandbox.push.apple.com) and peer-exchange authentication.
Listing 5-1 Sending a notification in the simple format via the binary interface
static bool sendPayload(SSL *sslPtr, char *deviceTokenBinary, char *payloadBuff,
size_t payloadLength)
{
bool rtn = false;
if (sslPtr && deviceTokenBinary && payloadBuff && payloadLength)
{
uint8_t command = 0; /* command number */
char binaryMessageBuff[sizeof(uint8_t) + sizeof(uint16_t) +
DEVICE_BINARY_SIZE + sizeof(uint16_t) + MAXPAYLOAD_SIZE];
/* message format is, |COMMAND|TOKENLEN|TOKEN|PAYLOADLEN|PAYLOAD| */
char *binaryMessagePt = binaryMessageBuff;
uint16_t networkOrderTokenLength = htons(DEVICE_BINARY_SIZE);
uint16_t networkOrderPayloadLength = htons(payloadLength);
/* command */
*binaryMessagePt++ = command;
/* token length network order */
Provider Communication with Apple Push Notification Service
The Binary Interface and Notification Formats
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
49memcpy(binaryMessagePt, &networkOrderTokenLength, sizeof(uint16_t));
binaryMessagePt += sizeof(uint16_t);
/* device token */
memcpy(binaryMessagePt, deviceTokenBinary, DEVICE_BINARY_SIZE);
binaryMessagePt += DEVICE_BINARY_SIZE;
/* payload length network order */
memcpy(binaryMessagePt, &networkOrderPayloadLength, sizeof(uint16_t));
binaryMessagePt += sizeof(uint16_t);
/* payload */
memcpy(binaryMessagePt, payloadBuff, payloadLength);
binaryMessagePt += payloadLength;
if (SSL_write(sslPtr, binaryMessageBuff, (binaryMessagePt -
binaryMessageBuff)) > 0)
rtn = true;
}
return rtn;
}
Figure 5-2 depicts the enhanced format for notification packets. With this format, if APNs encounters an
unintelligible command, it returns an error response before disconnecting.
Figure 5-2 Enhanced notification format
1 Identifier
Bytes: 1 4
Expiry
4
Command
32 deviceToken (binary) 0 34 {"aps":{"alert":"You have mail!"}}
2 32 2
Token length Payload length
(big endian) (big endian)
34
0
The first byte in the enhanced notification format is a command value of 1. The two new fields in this format
are for an identifier and an expiry value. (Everything else is the same as the simple notification format.)
●
Identifier—An arbitrary value that identifies this notification. This same identifier is returned in a
error-response packet if APNs cannot interpret a notification.
Provider Communication with Apple Push Notification Service
The Binary Interface and Notification Formats
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
50● Expiry—A fixed UNIX epoch date expressed in seconds (UTC) that identifies when the notification is no
longer valid and can be discarded. The expiry value should be in network order (big endian). If the expiry
value is positive, APNs tries to deliver the notification at least once. You can specify zero or a value less
than zero to request that APNs not store the notification at all.
If you send a notification and APNs finds the notification malformed or otherwise unintelligible, it returns an
error-response packet prior to disconnecting. (If there is no error, APNs doesn’t return anything.) Figure 5-3
depicts the format of the error-response packet.
Figure 5-3 Format of error-response packet
8
Bytes: 1
Command Status
n Identifier
1 4
The packet has a command value of 8 followed by a one-byte status code and the same notification identifier
specified by the provider when it composed the notification. Table 5-1 lists the possible status codes and their
meanings.
Table 5-1 Codes in error-response packet
Status code Description
0 No errors encountered
1 Processing error
2 Missing device token
3 Missing topic
4 Missing payload
5 Invalid token size
6 Invalid topic size
7 Invalid payload size
8 Invalid token
255 None (unknown)
Provider Communication with Apple Push Notification Service
The Binary Interface and Notification Formats
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
51Listing 5-2 modifies the code in Listing 5-1 (page 49) to compose a push notification in the enhanced format
before sending it to APNs. As with the earlier example, it assumes prior SSL connection to
gateway.push.apple.com (or gateway.sandbox.push.apple.com) and peer-exchange authentication.
Listing 5-2 Sending a notification in the enhanced format via the binary interface
static bool sendPayload(SSL *sslPtr, char *deviceTokenBinary, char *payloadBuff,
size_t payloadLength)
{
bool rtn = false;
if (sslPtr && deviceTokenBinary && payloadBuff && payloadLength)
{
uint8_t command = 1; /* command number */
char binaryMessageBuff[sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t)
+ sizeof(uint16_t) +
DEVICE_BINARY_SIZE + sizeof(uint16_t) + MAXPAYLOAD_SIZE];
/* message format is, |COMMAND|ID|EXPIRY|TOKENLEN|TOKEN|PAYLOADLEN|PAYLOAD|
*/
char *binaryMessagePt = binaryMessageBuff;
uint32_t whicheverOrderIWantToGetBackInAErrorResponse_ID = 1234;
uint32_t networkOrderExpiryEpochUTC = htonl(time(NULL)+86400); // expire
message if not delivered in 1 day
uint16_t networkOrderTokenLength = htons(DEVICE_BINARY_SIZE);
uint16_t networkOrderPayloadLength = htons(payloadLength);
/* command */
*binaryMessagePt++ = command;
/* provider preference ordered ID */
memcpy(binaryMessagePt, &whicheverOrderIWantToGetBackInAErrorResponse_ID,
sizeof(uint32_t));
binaryMessagePt += sizeof(uint32_t);
/* expiry date network order */
memcpy(binaryMessagePt, &networkOrderExpiryEpochUTC, sizeof(uint32_t));
binaryMessagePt += sizeof(uint32_t);
Provider Communication with Apple Push Notification Service
The Binary Interface and Notification Formats
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
52/* token length network order */
memcpy(binaryMessagePt, &networkOrderTokenLength, sizeof(uint16_t));
binaryMessagePt += sizeof(uint16_t);
/* device token */
memcpy(binaryMessagePt, deviceTokenBinary, DEVICE_BINARY_SIZE);
binaryMessagePt += DEVICE_BINARY_SIZE;
/* payload length network order */
memcpy(binaryMessagePt, &networkOrderPayloadLength, sizeof(uint16_t));
binaryMessagePt += sizeof(uint16_t);
/* payload */
memcpy(binaryMessagePt, payloadBuff, payloadLength);
binaryMessagePt += payloadLength;
if (SSL_write(sslPtr, binaryMessageBuff, (binaryMessagePt - binaryMessageBuff))
> 0)
rtn = true;
}
return rtn;
}
Take note that the device token in the production environment and the device token in the development
(sandbox) environment are not the same value.
The Feedback Service
If a provider attempts to deliver a push notification to an application, but the application no longer exists on
the device, the device reports that fact to Apple Push Notification Service. This situation often happens when
the user has uninstalled the application. If a device reports failed-delivery attempts for an application, APNs
needs some way to inform the provider so that it can refrain from sending notifications to that device. Doing
this reduces unnecessary message overhead and improves overall system performance.
For this purpose Apple Push Notification Service includes a feedback service that APNs continually updates
with a per-application list of devices for which there were failed-delivery attempts. The devices are identified
by device tokens encoded in binary format. Providers should periodically query the feedback service to get
Provider Communication with Apple Push Notification Service
The Feedback Service
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
53the list of device tokens for their applications, each of which is identified by its topic. Then, after verifying that
the application hasn’t recently been re-registered on the identified devices, a provider should stop sending
notifications to these devices.
Access to the feedback service takes place through a binary interface similar to that used for sending push
notifications. You access the production feedback service via feedback.push.apple.com, port 2196; you
access the sandbox feedback service via feedback.sandbox.push.apple.com, port 2196. As with the
binary interface for push notifications, you must use TLS (or SSL) to establish a secured communications channel.
The SSL certificate required for these connections is the same one that is provisioned for sending notifications.
To establish a trusted provider identity, you should present this certificate to APNs at connection time using
peer-to-peer authentication.
Once you are connected, transmission begins immediately; you do not need to send any command to APNs.
Begin reading the stream written by the feedback service until there is no more data to read. The received
data is in tuples having the following format:
Figure 5-4 Binary format of a feedback tuple
n n n n 0 32 deviceToken (binary)
Bytes: 4 2 32
Token length
time_t
(big endian) (big endian)
A timestamp (as a four-byte time_t value) indicating when the APNs determined
that the application no longer exists on the device. This value, which is in network
order, represents the seconds since 1970, anchored to UTC.
You should use the timestamp to determine if the application on the device
re-registered with your service since the moment the device token was recorded on
the feedback service. If it hasn’t, you should cease sending push notifications to the
device.
Timestamp
Token length The length of the device token as a two-byte integer value in network order.
Device token The device token in binary format.
Note: APNs monitors providers for their diligence in checking the feedback service and refraining
from sending push notifications to nonexistent applications on devices.
Provider Communication with Apple Push Notification Service
The Feedback Service
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
54This table describes the changes to Local and Push Notification Programming Guide .
Date Notes
Added information about implementing push notifications on an OS X
desktop client. Unified the guide for iOS and OS X.
2011-08-09
Describes how to determine if an application is launched because the
user tapped the notification alert's action button.
2010-08-03
2010-07-08 Changed occurrences of "iPhone OS" to "iOS."
Updated and reorganized to describe local notifications, a feature
introduced in iOS 4.0. Also describes a new format for push notifications
sent to APNs.
2010-05-27
2010-01-28 Made many small corrections.
Made minor corrections and linked to short inline articles on Cocoa
concepts.
2009-08-14
Added notes about Wi-Fi and frequency of registration, and gateway
address for sandbox. Updated with various clarifications and
enhancements.
2009-05-22
First version of a document that explains how providers can send push
notifications to client applications using Apple Push Notification Service.
2009-03-15
2011-08-09 | © 2011 Apple Inc. All Rights Reserved.
55
Document Revision HistoryApple Inc.
© 2011 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, iPad, iPhone, iPod,
iPod touch, iTunes, Keychain, Mac, OS X,
QuickTime, Sand, and Xcode are trademarks of
Apple Inc., registered in the U.S. and other
countries.
App Store is a service mark of Apple Inc.
Times is a registered trademark of Heidelberger
Druckmaschinen AG, available from Linotype
Library GmbH.
UNIX is a registered trademark of The Open
Group.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Mac App Programming
GuideContents
About OS X App Design 7
At a Glance 7
Cocoa Helps You Create Great Apps for OS X 7
Common Behaviors Make Apps Complete 8
Get It Right: Meet System and App Store Requirements 8
Finish Your App with Performance Tuning 8
How to Use This Document 9
See Also 9
The Mac Application Environment 10
An Environment Designed for Ease of Use 10
A Sophisticated Graphics Environment 11
Low-Level Details of the Runtime Environment 12
Based on UNIX 12
Concurrency and Threading 12
The File System 13
Security 18
The Core App Design 21
Fundamental Design Patterns 21
The App Style Determines the Core Architecture 23
The Core Objects for All Cocoa Apps 26
Additional Core Objects for Multiwindow Apps 29
Integrating iCloud Support Into Your App 30
Shoebox-Style Apps Should Not Use NSDocument 31
Document-Based Apps Are Based on an NSDocument Subclass 31
Documents in OS X 31
The Document Architecture Provides Many Capabilities for Free 32
The App Life Cycle 33
The main Function is the App Entry Point 33
The App’s Main Event Loop Drives Interactions 34
Automatic and Sudden Termination of Apps Improve the User Experience 36
Support the Key Runtime Behaviors in Your Apps 36
Automatic Termination 37
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
2Sudden Termination 38
User Interface Preservation 39
Apps Are Built Using Many Different Pieces 43
The User Interface 44
Event Handling 45
Graphics, Drawing, and Printing 46
Text Handling 47
Implementing the Application Menu Bar 47
Xcode Templates Provide the Menu Bar 48
Connect Menu Items to Your Code or Your First Responder 48
Implementing the Full-Screen Experience 49
Full-Screen API in NSApplication 49
Full-Screen API in NSWindow 50
Full-Screen API in NSWindowDelegate Protocol 50
Supporting Common App Behaviors 53
You Can Prevent the Automatic Relaunch of Your App 53
Making Your App Accessible Enables Many Users 53
Provide User Preferences for Customization 56
Integrate Your App With Spotlight Search 57
Use Services to Increase Your App’s Usefulness 58
Optimize for High Resolution 58
Think About Points, Not Pixels 58
Provide High-Resolution Versions of Graphics 59
Use High-Resolution-Savvy Image-Loading Methods 60
Use APIs That Support High Resolution 60
Prepare for Fast User Switching 61
Take Advantage of the Dock 62
Build-Time Configuration Details 63
Configuring Your Xcode Project 63
The Information Property List File 64
The OS X Application Bundle 66
Internationalizing Your App 69
Tuning for Performance and Responsiveness 71
Speed Up Your App’s Launch Time 71
Delay Initialization Code 71
Simplify Your Main Nib File 72
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
3
ContentsMinimize Global Variables 72
Minimize File Access at Launch Time 73
Don’t Block the Main Thread 73
Decrease Your App’s Code Size 73
Compiler-Level Optimizations 74
Use Core Data for Large Data Sets 75
Eliminate Memory Leaks 75
Dead Strip Your Code 75
Strip Symbol Information 76
Document Revision History 77
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
4
ContentsFigures, Tables, and Listings
The Mac Application Environment 10
Table 1-1 Key directories for Mac apps 14
Table 1-2 Attributes for the OS X file system 17
Listing 1-1 Getting the path to the Application Support directory 16
The Core App Design 21
Figure 2-1 The Calculator single-window utility app 24
Figure 2-2 The iPhoto single-window app 25
Figure 2-3 TextEdit document window 26
Figure 2-4 Key objects in a single-window app 27
Figure 2-5 Key objects in a multiwindow document app 29
Figure 2-6 Document file, object, and data model 32
Figure 2-7 The main event loop 35
Figure 2-8 Responder objects targeted by Cocoa for preservation 40
Figure 2-9 Windows and menus in an app 44
Figure 2-10 Processing events in the main run loop 45
Table 2-1 Fundamental design patterns used by Mac apps 21
Table 2-2 The core objects used by all Cocoa apps 27
Table 2-3 Additional objects used by multiwindow document apps 30
Listing 2-1 The main function of a Mac app 34
Listing 2-2 Returning the main window for a single-window app 43
Implementing the Full-Screen Experience 49
Table 3-1 Window delegate methods supporting full-screen mode 51
Supporting Common App Behaviors 53
Figure 4-1 Universal Access system preference dialog 55
Figure 4-2 Spotlight extracting metadata 57
Figure 4-3 Content appears the same size at standard resolution and high resolution 59
Build-Time Configuration Details 63
Figure 5-1 The information property list editor 65
Figure 5-2 The Language preference view 70
Table 5-1 A typical application bundle 66
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
5Tuning for Performance and Responsiveness 71
Table 6-1 Compiler optimization options 74
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
6
Figures, Tables, and ListingsThis document is the starting point for learning how to create Mac apps. It contains fundamental information
about the OS X environment and how your apps interact with that environment. It also contains important
information about the architecture of Mac apps and tips for designing key parts of your app.
At a Glance
Cocoa is the application environment that unlocks the full power of OS X. Cocoa provides APIs, libraries, and
runtimes that help you create fast, exciting apps that automatically inherit the beautiful look and feel of OS X,
as well as standard behaviors users expect.
Cocoa Helps You Create Great Apps for OS X
You write apps for OS X using Cocoa, which provides a significant amount of infrastructure for your program.
Fundamental design patterns are used throughout Cocoa to enable your app to interface seamlessly with
subsystem frameworks, and core application objects provide key behaviorsto supportsimplicity and extensibility
in app architecture. Key parts of the Cocoa environment are designed particularly to support ease of use, one
of the most important aspects of successful Mac apps. Many apps should adopt iCloud to provide a more
coherent user experience by eliminating the need to synchronize data explicitly between devices.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
7
About OS X App DesignRelevant Chapters: “The Mac Application Environment” (page 10), “The Core App Design” (page
21), and “Integrating iCloud Support Into Your App” (page 30)
Common Behaviors Make Apps Complete
During the design phase of creating your app, you need to think about how to implement certain features
that users expect in well-formed Mac apps. Integrating these features into your app architecture can have an
impact on the user experience: accessibility, preferences, Spotlight, services, resolution independence, fast
user switching, and the Dock. Enabling your app to assume full-screen mode, taking over the entire screen,
provides users with a more immersive, cinematic experience and enables them to concentrate fully on their
content without distractions.
Relevant Chapters: “Supporting Common App Behaviors” (page 53) and “Implementing the
Full-Screen Experience” (page 49)
Get It Right: Meet System and App Store Requirements
Configuring your app properly is an important part of the development process. Mac apps use a structured
directory called a bundle to manage their code and resource files. And although most of the files are custom
and exist to support your app, some are required by the system or the App Store and must be configured
properly. The application bundle also contains the resources you need to provide to internationalize your app
to support multiple languages.
Relevant Chapter: “Build-Time Configuration Details” (page 63)
Finish Your App with Performance Tuning
As you develop your app and your project code stabilizes, you can begin performance tuning. Of course, you
want your app to launch and respond to the user’s commands as quickly as possible. A responsive app fits
easily into the user’s workflow and gives an impression of being well crafted. You can improve the performance
of your app by speeding up launch time and decreasing your app’s code footprint.
About OS X App Design
At a Glance
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
8Relevant Chapter: “Tuning for Performance and Responsiveness” (page 71)
How to Use This Document
This guide introduces you to the most important technologies that go into writing an app. In this guide you
will see the whole landscape of what's needed to write one. That is, this guide shows you all the "pieces" you
need and how they fit together. There are important aspects of app design that this guide does not cover,
such as user interface design. However, this guide includes many links to other documents that provide details
about the technologies it introduces, as well as links to tutorials that provide a hands-on approach.
In addition, this guide emphasizes certain technologies introduced in OS X v10.7, which provide essential
capabilities that set your app apart from older ones and give it remarkable ease of use, bringing some of the
best features from iOS to OS X.
See Also
The following documents provide additional information about designing Mac apps, as well as more details
about topics covered in this document:
● To work through a tutorial showing you how to create a Cocoa app, see Start Developing Mac Apps Today .
● For information about user interface design enabling you to create effective apps using OS X, see OS X
Human Interface Guidelines.
● To understand how to create an explicit app ID, create provisioning profiles, and enable the correct
entitlementsfor your application,so you can sell your application through the Mac App Store or use iCloud
storage, see Tools Workflow Guide for Mac .
● For information about the design patterns used in Cocoa, see Cocoa Fundamentals Guide .
● For a general survey of OS X technologies, see Mac Technology Overview.
● To understand how to implement a document-based app, see Document-Based App Programming Guide
for Mac .
About OS X App Design
How to Use This Document
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
9OS X incorporates the latest technologies for creating powerful and fun-to-use apps. But the technologies by
themselves are not enough to make every app great. What sets an app apart from its peers is how it helps the
user achieve some tangible goal. After all, users are not going to care what technologies an app uses, as long
as it helps them do what they need to do. An app that gets in the user’s way is going to be forgotten, but one
that makes work (or play) easier and more fun is going to be remembered.
You use Cocoa to write apps for OS X. Cocoa gives you access to all of the features of OS X and allows you to
integrate your app cleanly with the rest of the system. This chapter covers the key parts of OS X that help you
create great apps. In particular, this chapter describessome of the important ease-of-use technologiesintroduced
in OS X v10.7. For a more thorough list of technologies available in OS X, see Mac Technology Overview.
An Environment Designed for Ease of Use
OS X strives to provide an environment that is transparent to users and as easy to use as possible. By making
hard tasks simple and getting out of the way, the system makes it easier for the user to be creative and spend
less time worrying about the steps needed to make the computer work. Of course, simplifying tasks means
your app has to do more of the work, but OS X provides help in that respect too.
As you design your app, you should think about the tasks that users normally perform and find ways to make
them easier. OS X supports powerful ease-of-use features and design principles. For example:
● Users should not have to save their work manually. The document model in Cocoa provides support for
saving the user’sfile-based documents without user interaction;see “The Document Architecture Provides
Many Capabilities for Free” (page 32).
● Apps should restore the user’s work environment at login time. Cocoa provides support for archiving the
current state of the app’s interface (including the state of unsaved documents) and restoring that state at
launch time; see “User Interface Preservation” (page 39).
● Appsshould support automatic termination so that the user never hasto quit them. Automatic termination
means that when the user closes an app’s windows, the app appears to quit but actually just moves to
the background quietly. The advantage is that subsequent launches are nearly instant as the app simply
moves back to the foreground; see “Automatic and Sudden Termination of Apps Improve the User
Experience” (page 36)
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
10
The Mac Application Environment● You should consider providing your users with an immersive, full-screen experience by implementing a
full-screen version of your user interface. The full-screen experience eliminates outside distractions and
allows the user to focus on their content; see “Implementing the Full-Screen Experience” (page 49).
● Support trackpad gestures for appropriate actions in your app. Gestures provide simple shortcuts for
common tasks and can be used to supplement existing controls and menu commands. OS X provides
automatic support for reporting gestures to your app through the normal event-handling mechanism;
see Cocoa Event Handling Guide .
● Consider minimizing or eliminating the user’s interactions with the raw file system. Rather than expose
the entire file system to the user through the open and save panels, some apps, in the manner of iPhoto
and iTunes, can provide a better user experience by presenting the user’s content in a simplified browser
designed specifically for the app’s content. OS X uses a well-defined file system structure that allows you
to place and find files easily and includes many technologies for accessing those files; see “The File
System” (page 13).
● For apps that support custom document types, provide a Quick Look plug-in so that users can view your
documents from outside of your app; see Quick Look Programming Guide .
● Apps should support the fundamental features for the OS X user experience that make apps elegant and
intuitive,such as direct manipulation and drag-and-drop. Usersshould remain in control, receive consistent
feedback, and be able to explore because the app is forgiving with reversible actions; see OS X Human
Interface Guidelines.
All of the preceding features are supported by Cocoa and can be incorporated with relatively little effort.
A Sophisticated Graphics Environment
High-quality graphics and animation make your app look great and can convey a lot of information to the user.
Animations in particular are a great way to provide feedback about changes to your user interface. So as you
design your app, keep the following ideas in mind:
● Use animations to provide feedback and convey changes. Cocoa provides mechanisms for creating
sophisticated animations quickly in both the AppKit and Core Animation frameworks. For information
about creating view-based animations, see Cocoa Drawing Guide . For information about using Core
Animation to create your animations, see Core Animation Programming Guide .
●
Include high-resolution versions of your art and graphics. OS X automatically loads high-resolution image
resources when an app runs on a screen whose scaling factor is greater than 1.0. Including such image
resources makes your app’s graphics look even sharper and crisper on those higher-resolution screens.
Forinformation aboutthe graphicstechnologies available inOS X,see “Media Layer” in Mac TechnologyOverview.
The Mac Application Environment
A Sophisticated Graphics Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
11Low-Level Details of the Runtime Environment
When you are ready to begin writing actual code, there are a lot of technologies available to make your life
easier. OS X supports all of the basic features such as memory management, file management, networking,
and concurrency that you need to write your code. In some cases, though, OS X also provides more sophisticated
services (or specific coding conventions) that, when followed, can make writing your code even easier.
Based on UNIX
OS X is powered by a 64-bit Mach kernel, which manages processor resources, memory, and other low-level
behaviors. On top of the kernel sits a modified version of the Berkeley Software Distribution (BSD) operating
system, which provides interfaces that apps can use to interact with the lower-level system. This combination
of Mach and BSD provides the following system-level support for your apps:
● Preemptive multitasking—All processes share the CPU efficiently. The kernel schedules processes in a
way that ensures they all receive the time they need to run. Even background apps continue to receive
CPU time to execute ongoing tasks.
● Protected memory—Each process runs in its own protected memory space, which prevents processes
from accidentally interfering with each other. (Apps can share part of their memory space to implement
fast interprocess communication but take responsibility for synchronizing and locking that memory
appropriately.)
● Virtual memory—64-bit apps have a virtual address space of approximately 18 exabytes (18 billion billion
bytes). (If you create a 32-bit app, the amount of virtual memory is only 4 GB.) When an app’s memory
usage exceedsthe amount of free physical memory, the system transparently writes pagesto disk to make
more room. Written out pages remain on disk until they are needed in memory again or the app exits.
● Networking and Bonjour—OS X provides support for the standard networking protocols and services in
use today. BSD sockets provide the low-level communication mechanism for apps, but higher-level
interfaces also exist. Bonjour simplifies the user networking experience by providing a dynamic way to
advertise and connect to network services over TCP/IP.
For detailed information about the underlying environment of OS X, see “Kernel and Device Drivers Layer” in Mac
Technology Overview.
Concurrency and Threading
Each process starts off with a single thread of execution and can create more threads as needed. Although you
can create threads directly using POSIX and other higher-level interfaces, for most types of work it is better to
create them indirectly using block objects with Grand Central Dispatch (GCD) or operation objects, a Cocoa
concurrency technology implemented by the NSOperation class.
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
12GCD and operation objects are an alternative to raw threads that simplify or eliminate many of the problems
normally associated with threaded programming,such assynchronization and locking. Specifically, they define
an asynchronous programming model in which you specify only the work to be performed and the order in
which you want it performed. The system then handles the tedious work required to schedule the necessary
threads and execute your tasks as efficiently as possible on the current hardware. You should not use GCD or
operations for work requiring time-sensitive data processing (such as audio or video playback), but you can
use them for most other types of tasks.
For more information on using GCD and operation objects to implement concurrency in your apps, see
Concurrency Programming Guide .
The File System
The file system in OS X is structured to provide a better experience for users. Rather than exposing the entire
file system to the user, the Finder hides any files and directories that an average user should not need to use,
such as the contents of low-level UNIX directories. This is done to provide a simpler interface for the end user
(and only in places like the Finder and the open and save panels). Apps can still access any files and directories
for which they have valid permissions, regardless of whether they are hidden by the Finder.
When creating apps, you should understand and follow the conventions associated with the OS X file system.
Knowing where to put files and how to get information out of the file system ensures a better user experience.
A Few Important App Directories
The OS X file system is organized in a way that groups related files and data together in specific places. Every
file in the file system has its place and apps need to know where to put the files they create. This is especially
important if you are distributing your app through the App Store, which expects you to put your app’s data
files in specific directories.
Table 1-1 lists the directories with which apps commonly interact. Some of these directories are inside the
home directory, which is either the user’s home directory or, if the app adopts App Sandbox, the app’s container
directory as described in “App Sandbox and XPC” (page 18). Because the actual paths can differ based on
these conditions, use the URLsForDirectory:inDomains: method of the NSFileManager classto retrieve
the actual directory path. You can then add any custom directory and filename information to the returned
URL object to complete the path.
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
13Table 1-1 Key directories for Mac apps
Directory Description
Thisisthe installation directory for your app bundle. The path for the global Applications
directory is /Applications but each user directory may have a local applications
directory containing user-specific apps. Regardless, you should not need to use this
path directly. To access resources inside your application bundle, use an NSBundle
object instead.
For more information about the structure of your application bundle and how you
locate resources, see “The OS X Application Bundle” (page 66).
Applications
directory
The configuration of your app determines the location of the home directory seen by
your app:
● For apps running in a sandbox in OS X v10.7 and later, the home directory is the
app’s container directory. For more information about the container directory,
see “The Keychain” (page 20).
● For apps running outside of a sandbox (including those running in versions of OS
X before 10.7), the home directory isthe user-specific subdirectory of /Users that
contains the user’s files.
To retrieve the path to the home directory, use the NSHomeDirectory function.
Home
directory
The Library directory is the top-level directory for storing private app-related data and
preferences. There are several Library directories scattered throughout the system but
you should always use the one located inside the current home directory.
Do not store files directly at the top-level of the Library directory. Instead, store them
in one of the specific subdirectories described in this table.
In OS X v10.7 and later, the Finder hides the Library directory in the user’s home folder
by default. Therefore, you should never store files in this directory that you want the
user to access.
To get the path to this directory use the NSLibraryDirectory search path key with
the NSUserDomainMask domain.
Library
directory
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
14Directory Description
The Application Support directory is where your app stores any type of file thatsupports
the app but is not required for the app to run, such as document templates or
configuration files. The files should be app-specific but should never store user data.
This directory is located inside the Library directory.
Never store files at the top level of this directory: Always put them in a subdirectory
named for your app or company.
If the resources apply to all users on the system, such as document templates, place
them in /Library/Application Support. To get the path to this directory use
the NSApplicationSupportDirectory search path key with the
NSLocalDomainMask domain. If the resources are user-specific, such as workspace
configuration files, place them in the current user’s ~/Library/Application
Support directory. To get the path to this directory use the
NSApplicationSupportDirectory search path key with the NSUserDomainMask
domain.
Application
Support
directory
The Caches directory is where you store cache files and other temporary data that your
app can re-create as needed. This directory is located inside the Library directory.
Never store files at the top level of this directory: Always put them in a subdirectory
named for your app or company. Your app is responsible for cleaning out cache data
files when they are no longer needed. The system does not delete files from this
directory.
To get the path to this directory use the NSCachesDirectory search path key with
the NSUserDomainMask domain.
Caches
directory
The Movies directory contains the user’s video files.
To get the path to this directory use the NSMoviesDirectory search path key with
the NSUserDomainMask domain.
Movies
directory
The Music directory contains the user’s music and audio files.
To get the path to this directory use the NSMusicDirectory search path key with
the NSUserDomainMask domain.
Music
directory
The Pictures directory contains the user’s images and photos.
To get the path to this directory use the NSPicturesDirectory search path key
with the NSUserDomainMask domain.
Pictures
directory
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
15Directory Description
The Temporary directory is where you store files that do not need to persist between
launches of your app. You normally use this directory for scratch files or other types
ofshort-lived data filesthat are not related to your app’s persistent data. This directory
is typically hidden from the user.
Your app should remove files from this directory as soon as it is done with them. The
system may also purge lingering files from this directory at system startup.
To get the path to this directory use the NSTemporaryDirectory function.
Temporary
directory
Listing 1-1 shows an example of how to retrieve the base path to the Application Support directory and
then append a custom app directory to it.
Listing 1-1 Getting the path to the Application Support directory
NSFileManager* fileManager = [NSFileManager defaultManager];
NSURL* appSupportDir = nil;
NSArray *urls = [fileManager URLsForDirectory:NSApplicationSupportDirectory
inDomains:NSUserDomainMask];
if ([paths count] > 0) {
appSupportDir = [[urls objectAtIndex:0]
URLByAppendingPathComponent:@"com.example.MyApp"];
}
For more information about how to access files in well known system directories, see File System Programming
Guide .
Coordinating File Access with Other Processes
In OS X, other processes may have access to the same files that your app does. Therefore, when working with
files, you should use the file coordination interfacesintroduced in OS X v10.7 to be notified when other processes
(including the Finder) attempt to read or modify files your app is currently using. For example, coordinating
file access is critical when your app adopts iCloud storage.
The file coordination APIs allow you to assert ownership over files and directories that your app cares about.
Any time another process attempts to touch one of those items, your app is given a chance to respond. For
example, when an app attemptsto read the contents of a document your app is editing, you can write unsaved
changes to disk before the other process is allowed to do its reading.
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
16Using iCloud document storage, for example, you must incorporate file coordination because multiple apps
can access your document files in iCloud. The simplest way to incorporate file coordination into your app is to
use the NSDocument class, which handles all of the file-related management for you. See Document-Based
App Programming Guide for Mac .
On the other hand, if you're writing a library-style (or “shoebox”) app, you must use the file coordination
interfaces directly, as described in File System Programming Guide .
Interacting with the File System
Disks in Macintosh computers are formatted using the HFS+ file system by default. However, Macintosh
computers can interact with disks that use other formats so you should never code specifically to any one file
system. Table 1-2 lists some of the basic file system attributes you may need to consider in your app and how
you should handle them.
Table 1-2 Attributes for the OS X file system
Attribute Description
The HFS+ file system is case-insensitive but also case-preserving. Therefore, when
specifying filenames and directoriesin your code, it is best to assume case-sensitivity.
Case sensitivity
Construct paths using the methods of the NSURL and NSString classes. The NSURL
classis preferred for path construction because of its ability to specify not only paths
in the local file system but paths to network resources.
Path
construction
Many file-related attributes can be retrieved using the getResourceValue:
forKey:error: method of the NSURL class. You can also use an NSFileManager
object to retrieve many file-related attributes.
File attributes
File permissions are managed using access control lists(ACLs) and BSD permissions.
The system uses ACLs whenever possible to specify precise permissionsfor files and
directories, but it falls back to using BSD permissions when no ACLs are specified.
By default, any files your app creates are owned by the current user and given
appropriate permissions. Thus, your app should always be able to read and write
files it creates explicitly. In addition, the app’s sandbox may allow it to access other
filesin specific situations. For more information about the sandbox,see “App Sandbox
and XPC” (page 18).
File permissions
Appsthat cannot use the File Coordination interfaces(see “Coordinating File Access
with Other Processes” (page 16)) to track changes to files and directories can use
the FSEvents API instead. This API provides a lower-level interface for tracking file
system interactions and is available in OS X v10.5 and later.
For information on how to use the FSEvents API,see File SystemEvents Programming
Guide .
Tracking file
changes
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
17Security
The security technologies in OS X help you safeguard sensitive data created or managed by your app, and help
minimize damage caused by successful attacks from hostile code. These technologies impact how your app
interacts with system resources and the file system.
App Sandbox and XPC
You secure your app against attack from malware by following the practices recommended in Secure Coding
Guide . But an attacker needs only to find a single hole in your defenses, or in any of the frameworks and libraries
that you link against, to gain control of your app along with all of its privileges.
Starting in OS X v10.7, App Sandbox provides a last line of defense against stolen, corrupted, or deleted user
data if malicious code exploits your app. App Sandbox also minimizes the damage from coding errors. Its
strategy is twofold:
1. App Sandbox enables you to describe how your app interacts with the system. The system then grants
your app the access it needs to get its job done, and no more. For your app to provide the highest level
of damage containment, the best practice is to adopt the tightest sandbox possible.
2. App Sandbox allows the user to transparently grant your app additional access by way of Open and Save
dialogs, drag and drop, and other familiar user interactions.
You describe your app’s interaction with the system by way of setting entitlements in Xcode. An entitlement
is a key-value pair, defined in a property list file, that confers a specific capability or security permission to a
target. For example, there are entitlement keys to indicate that your app needs access to the camera, the
network, and user data such as the Address Book. For details on all the entitlements available in OS X, see
Entitlement Key Reference .
When you adopt App Sandbox, the system provides a special directory for use by your app—and only by your
app—called a container. Your app has unfettered read/write access to the container. All OS X path-finding
APIs, above the POSIX layer, are relative to the container instead of to the user’s home directory. Othersandboxed
apps have no access to your app’s container, as described further in “Code Signing” (page 19).
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
18iOS Note: Because it is not for user documents, an OS X container differs from an iOS container
which, in iOS, is the one and only location for user documents. As the sole local location for user
documents, an iOS container is usually known simply as an app’s Documents directory.
In addition, an iOS container contains the app itself. This is not so in OS X.
iCloud Note: Apple’s iCloud technology, as described in “iCloud Storage”, uses the name “container”
as well. There is no functional connection between an iCloud container and an App Sandbox container.
Your sandboxed app can access paths outside of its container in the following three ways:
● At the specific direction of the user
● By you configuring your app with entitlements for specific file-system locations, such as the Movies folder
● When a path is in any of certain directories that are world readable
The OS X security technology that interacts with the user to expand yoursandbox is called Powerbox. Powerbox
has no API. Your app uses Powerbox transparently when, for example, you use the NSOpenPanel and
NSSavePanel classes, or when the user employs drag and drop with your app.
Some app operations are more likely to be targets of malicious exploitation. Examples are the parsing of data
received over a network, and the decoding of video frames. By using XPC, you can improve the effectiveness
of the damage containment offered by App Sandbox by separating such potentially dangerous activities into
their own address spaces.
XPC is an OS X interprocess communication technology that complements App Sandbox by enabling privilege
separation. Privilege separation, in turn, is a development strategy in which you divide an app into pieces
according to the system resource access that each piece needs. The component pieces that you create are
called XPC services. For details on adopting XPC, see Daemons and Services Programming Guide .
For a complete explanation of App Sandbox and how to use it, read App Sandbox Design Guide .
Code Signing
OS X employs the security technology known as code signing to allow you to certify that your app was indeed
created by you. After an app is code signed, the system can detect any change to the app—whether the change
is introduced accidentally or by malicious code. Various security technologies, including App Sandbox and
parental controls, depend on code signing.
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
19In most cases, you can rely on Xcode’s automatic code signing, which requires only that you specify a code
signing identity in the build settings for your project. The steps to take are described in “Code Signing Your App”
in Tools Workflow Guide for Mac . If you need to incorporate code signing into an automated build system, or
if you link your app against third-party frameworks, refer to the procedures described in Code Signing Guide .
When you adopt App Sandbox, you must code sign your app. This is because entitlements (including the
special entitlement that enables App Sandbox) are built into an app’s code signature.
OS X enforces a tie between an app’s container and the app’s code signature. This important security feature
ensures that no other sandboxed app can access your container. The mechanism works as follows: After the
system creates a container for an app, each time an app with the same bundle ID launches, the system checks
that the app’s code signature matches a code signature expected by the container. If the system detects a
mismatch, it prevents the app from launching.
For a complete explanation of code signing in the context of App Sandbox, read “App Sandbox in Depth” in App
Sandbox Design Guide .
The Keychain
A keychain is a secure, encrypted container for storing a user’s passwords and other secrets. It is designed to
help a user manage their multiple logins, each with its own ID and password. You should always use keychain
to store sensitive credentials for your app.
For more on the keychain, see “Keychain Services Concepts” in Keychain Services Programming Guide .
The Mac Application Environment
Low-Level Details of the Runtime Environment
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
20To unleash the power of OS X, you develop apps using the Cocoa application environment. Cocoa presents
the app’s user interface and integrates it tightly with the other components of the operating system. Cocoa
provides an integrated suite of object-oriented software components packaged in two core class libraries, the
AppKit and Foundation frameworks, and a number of underlying frameworks providing supporting technologies.
Cocoa classes are reusable and extensible—you can use them as is or extend them for your particular
requirements.
Cocoa makes it easy to create apps that adopt all of the conventions and expose all of the power of OS X. In
fact, you can create a new Cocoa application project in Xcode and, without adding any code, have a functional
app. Such an app is able to display its window (or create new documents) and implements many standard
system behaviors. And although the Xcode templates provide some code to make this all happen, the amount
of code they provide is minimal. Most of the behavior is provided by Cocoa itself.
To make a great app, you should build on the foundations Cocoa lays down for you, working with the
conventions and infrastructure provided for you. To do so effectively, it'simportant to understand how a Cocoa
app fits together.
Fundamental Design Patterns
Cocoa incorporates many design patterns in its implementation. Table 2-1 lists the key design patterns with
which you should be familiar.
Table 2-1 Fundamental design patterns used by Mac apps
Design pattern Why it is important
Use of the Model-View-Controller (MVC) design pattern ensures that the
objects you create now can be reused or updated easily in future versions of
your app.
Cocoa provides most of the classes used to build your app’s controller and
view layers. It is your job to customize the classes you need and provide the
necessary data model objects to go with them.
MVC is central to a good design for a Cocoa application because many Cocoa
technologies and architectures are based on MVC and require that your custom
objects assume one of the MVC roles.
Model-View-Controller
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
21
The Core App DesignDesign pattern Why it is important
The delegation design pattern allows you to change the runtime behavior of
an object without subclassing. Delegate objects conform to a specific protocol
that defines the interaction points between the delegate and the object it
modifies. Atspecific points, the master object callsthe methods of its delegate
to provide it with information or ask what to do. The delegate can then take
whatever actions are appropriate.
Delegation
The responder chain definesthe relationships between event-handling objects
in your app. As events arrive, the app dispatches them to the first responder
object for handling. If that object does not want the event, it passes it to the
next responder, which can either handle the event or send it to its next
responder, and so on up the chain.
Windows and views are the most common types of responder objects and are
always the first responders for mouse events. Other types of objects, such as
your app’s controller objects, may also be responders.
Responder chain
Controls use the target-action design pattern to notify your app of user
interactions. When the user interacts with a control in a predefined way (such
as by touching a button), the controlsends a message (the action) to an object
you specify (the target). Upon receiving the action message, the target object
can then respond in an appropriate manner.
Target-action
Block objects are a convenient way to encapsulate code and local stack
variablesin a form that can be executed later. Blocks are used in lieu of callback
functions by many frameworks and are also used in conjunction with Grand
Central Dispatch to perform tasks asynchronously.
For more information about using blocks, see Blocks Programming Topics.
Block objects
Notifications are used throughout Cocoa to deliver news of changes to your
app. Many objects send notifications at key moments in the object’s life cycle.
Intercepting these notifications gives you a chance to respond and add custom
behavior.
Notifications
KVO tracks changes to a specific property of an object. When that property
changes, the change generates automatic notifications for any objects that
registered an interest in that property. Those observers then have a chance to
respond to the change.
Key-value observing
(KVO)
The Core App Design
Fundamental Design Patterns
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
22Design pattern Why it is important
Cocoa bindings provide a convenient bridge between the model, view, and
controller portions of your app. You bind a view to some underlying data object
(which can be static or dynamic) through one of your controllers. Changes to
the view are then automatically reflected in the data object, and vice versa.
The use of bindings is not required for apps but does minimize the amount of
code you have to write. You can set up bindings programmatically or using
Interface Builder.
Bindings
For a more detailed discussion of Cocoa and the design patterns you use to implement Mac apps, see Cocoa
Fundamentals Guide .
The App Style Determines the Core Architecture
The style of your app defines which core objects you must use in its implementation. Cocoa supports the
creation of both single-window and multiwindow apps. For multiwindow designs, it also provides a document
architecture to help manage the files associated with each app window. Thus, apps can have the following
forms:
● Single-window utility app
● Single-window library-style app
● Multiwindow document-based app
You should choose a basic app style early in your design process because that choice affects everything you
do later. The single-window styles are preferred in many cases, especially for developers bringing apps from
iOS. The single-window style typically yields a more streamlined user experience, and it also makes it easier
for your app to support a full-screen mode. However, if your app works extensively with complex documents,
the multiwindow style may be preferable because it provides more document-related infrastructure to help
you implement your app.
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
23The Calculator app provided with OS X, shown in Figure 2-1, is an example of a single-window utility app.
Utility apps typically handle ephemeral data or manage system processes. Calculator does not create or deal
with any documents or persistent user data but simply processes numerical data entered by the user into the
text field in its single window, displaying the results of its calculations in the same field. When the user quits
the app, the data it processed is simply discarded.
Figure 2-1 The Calculator single-window utility app
Single-window, library-style (or “shoebox”) apps do handle persistent user data. One of the most prominent
examples of a library-style app is iPhoto, shown in Figure 2-2. The user data handled by iPhoto are photos (and
associated metadata), which the app edits, displays, and stores. All user interaction with iPhoto happens in a
single window. Although iPhoto stores its data in files, it doesn’t present the files to the user. The app presents
a simplified interface so that users don’t need to manage files in order to use the app. Instead, they work
directly with their photos. Moreover, iPhoto hides its files from regular manipulation in the Finder by placing
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
24them within a single package. In addition, the app savesthe user’s editing changesto disk at appropriate times.
So, users are relieved of the need to manually save, open, or close documents. This simplicity for users is one
of the key advantages of the library-style app design.
Figure 2-2 The iPhoto single-window app
A good example of a multiwindow document-based app is TextEdit, which creates, displays, and edits documents
containing plain or styled text and images. TextEdit does not organize or manage its documents—users do
that with the Finder. Each TextEdit document opens in its own window, multiple documents can be open at
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
25one time, and the user interacts with the frontmost document using controls in the window’s toolbar and the
app’s menu bar. Figure 2-3 shows a document created by TextEdit. For more information about the
document-based app design, see “Document-Based Apps Are Based on an NSDocument Subclass” (page 31).
Figure 2-3 TextEdit document window
Both single-window and multiwindow apps can present an effective full-screen mode, which provides an
immersive experience that enables users to focus on their tasks without distractions. For information about
full-screen mode, see “Implementing the Full-Screen Experience” (page 49).
The Core Objects for All Cocoa Apps
Regardless of whether you are using a single-window or multiwindow app style, all apps use the same core
set of objects. Cocoa provides the default behavior for most of these objects. You are expected to provide a
certain amount of customization of these objects to implement your app’s custom behavior.
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
26Figure 2-4 shows the relationships among the core objects for the single-window app styles. The objects in
this figure are separated according to whether they are part of the model, view, or controller portions of the app.
As you can see from the figure, the Cocoa–provided objects provide much of the controller and view layer for
your app.
Figure 2-4 Key objects in a single-window app
Table 2-2 (page 27) describes the roles played by the objects in the diagram.
Table 2-2 The core objects used by all Cocoa apps
Object Description
(Required) Runs the event loop and manage interactions between your app and
the system. You typically use the NSApplication class as is, putting any custom
app-object-related code in your application delegate object.
NSApplication
object
(Expected) A custom object that you provide which works closely with the
NSApplication object to run the app and manage the transitions between
different application states.
Your application delegate object must conform to the NSApplicationDelegate
Protocol.
Application
delegate object
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
27Object Description
Store content specific to your app. A banking app might store a database
containing financial transactions, whereas a painting app might store an image
object or the sequence of drawing commands that led to the creation of that
image.
Data model
objects
Responsible for loading and managing a single window each and coordinating
with the system to handle standard window behaviors.
You subclass NSWindowController tomanage both the window and its contents.
Each window controller is responsible for everything that happens in its window.
If the contents of your window are simple, the window controller may do all of
the management itself. If your window is more complex, the window controller
might use one or more view controllers to manage portions of the window.
Window
controllers
Represent your onscreen windows, configured in different styles depending on
your app’s needs. For example, most windows have title bars and borders but you
can also configure windows without those visual adornments. A window object
is almost always managed by a window controller.
An app can also have secondary windows, also known as dialogs and panels.
These windows are subordinate to the current document window or, in the case
of single-window apps, to the main window. They support the document or main
window, for example, allowing selection of fonts and color, allowing the selection
of tools from a palette, or displaying a warning‚ A secondary window is often
modal.
Window objects
Coordinate the loading of a single view hierarchy into your app. Use view
controllersto divide up the work for managing more sophisticated window layouts.
Your view controllers work together (with the window controller) to present the
window contents.
If you have developed iOS apps, be aware that AppKit view controllers play a less
prominent role than UIKit view controllers. In OS X, AppKit view controllers are
assistantsto the window controller, which is ultimately responsible for everything
that goes in the window. The main job of an AppKit view controller is to load its
view hierarchy. Everything else is custom code that you write.
View controllers
Define a rectangular region in a window, draw the contents of that region, and
handle events in that region. Views can be layered on top of each other to create
view hierarchies, whereby one view obscures a portion of the underlying view.
View objects
Representstandard system controls. These view subclasses provide standard visual
items such as buttons, text fields, and tables that you can use to build your user
interface. Although a few controls are used as is to present visual adornments,
most work with your code to manage user interactions with your app’s content.
Control objects
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
28Additional Core Objects for Multiwindow Apps
As opposed to a single-window app, a multiwindow app uses several windows to present its primary content.
The Cocoa support for multiwindow appsis built around a document-based model implemented by a subsystem
called the document architecture. In this model, each document object manages its content, coordinates the
reading and writing of that content from disk, and presents the content in a window for editing. All document
objects work with the Cocoa infrastructure to coordinate event delivery and such, but each document object
is otherwise independent of its fellow document objects.
Figure 2-5 shows the relationships among the core objects of a multiwindow document-based app. Many of
the same objects in this figure are identical to those used by a single-window app. The main difference is the
insertion of the NSDocumentController and NSDocument objects between the application objects and the
objects for managing the user interface.
Figure 2-5 Key objects in a multiwindow document app
Table 2-3 (page 30) describes the role of the inserted NSDocumentController and NSDocument objects.
(For information about the roles of the other objects in the diagram, see Table 2-2 (page 27).)
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
29Table 2-3 Additional objects used by multiwindow document apps
Object Description
The NSDocumentController class defines a high-level controller for creating
and managing all document objects. In addition to managing documents, the
document controller also manages many document-related menu items, such as
the Open Recent menu and the open and save panels.
Document
Controller object
The NSDocument class is the base class for implementing documents in a
multiwindow app. This class acts as the controller for the data objects associated
with the document. You define your own custom subclasses to manage the
interactions with your app’s data objects and to work with one or more
NSWindowController objectsto display the document contents on the screen.
Document object
Integrating iCloud Support Into Your App
No matter how you store your app’s data, iCloud is a convenient way to make that data available to all of a
user’s devices. To integrate iCloud into your app, you change where you store user files. Instead of storing
them in the user’s Home folder or in your App Sandbox container, you store them in special file system locations
known as ubiquity containers. A ubiquity containerserves asthe local representation of corresponding iCloud
storage. It is outside of your App Sandbox container, and so requires specific entitlements for your app to
interact with it.
In addition to a change in file system locations, your app design needs to acknowledge that your data model
is accessible to multiple processes. The following considerations apply:
● Document-based apps get iCloud support through the NSDocument class, which handles most of the
interactions required to manage the on-disk file packages that represent documents.
●
If you implement a custom data model and manage files yourself, you must explicitly use file coordination
to ensure that the changes you make are done safely and in concert with the changes made on the user’s
other devices. For details,see “The Role of File Coordinators and Presenters” in File System Programming Guide .
● For storing small amounts of data in iCloud, you use key-value storage. Use key-value storage for such
things as stocks or weather information, locations, bookmarks, a recent-documents list, settings and
preferences, and simple game state. Every iCloud app should take advantage of key-value storage. To
interact with key-value storage, you use the shared NSUbiquitousKeyValueStore object.
To learn how to adopt iCloud in your app, read iCloud Design Guide .
The Core App Design
The App Style Determines the Core Architecture
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
30Shoebox-Style Apps Should Not Use NSDocument
When implementing a single-window, shoebox-style (sometimes referred to as a “library” style) app, it is
sometimes better not to use NSDocument objectsto manage your content. The NSDocument class was designed
specifically for use in multiwindow document apps. Instead, use custom controller objects to manage your
data. Those custom controllers would then work with a view controller or your app’s main window controller
to coordinate the presentation of the data.
Although you normally use an NSDocumentController object only in multiwindow apps, you can subclass
it and use it in a single-window app to coordinate the Open Recent and similar behaviors. When subclassing,
though, you must override any methods related to the creation of NSDocument objects.
Document-Based Apps Are Based on an NSDocument Subclass
Documents are containers for user data that can be stored in files and iCloud. In a document-based design,
the app enables users to create and manage documents containing their data. One app typically handles
multiple documents, each in its own window, and often displays more than one document at a time. For
example, a word processor provides commands to create new documents, it presents an editing environment
in which the user enters text and embeds graphics into the document, it saves the document data to disk (and,
optionally, iCloud), and it provides other document-related commands, such as printing and version
management. In Cocoa, the document-based app design is enabled by the document architecture, which is
part of of the AppKit framework.
Documents in OS X
There are several waysto think of a document. Conceptually, a document is a container for a body of information
that can be named and stored in a disk file and in iCloud. In this sense, the document is not the same as the
file but is an object in memory that owns and manages the document data. To users, the document is their
information—such as text and graphics formatted on a page. Programmatically, a document is an instance of
a custom NSDocument subclass that knows how to represent internally persistent data that it can display in
windows. This document object knows how to read document data from a file and create an object graph in
The Core App Design
Document-Based Apps Are Based on an NSDocument Subclass
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
31memory for the document data model. It also knows how to handle the user’s editing commands to modify
the data model and write the document data back out to disk. So, the document object mediates between
different representations of document data, as shown in Figure 2-6.
Figure 2-6 Document file, object, and data model
Using iCloud, documents can be shared automatically among a user’s computers and iOS devices. Changes to
the document data are synchronized without user intervention. For information about iCloud, see “Integrating
iCloud Support Into Your App” (page 30).
The Document Architecture Provides Many Capabilities for Free
The document-based style of app is a design choice that you should consider when you design your app. If it
makes sense for your users to create multiple discrete sets of data, each of which they can edit in a graphical
environment and store in files or iCloud, then you certainly should plan to develop a document-based app.
The Cocoa document architecture provides a framework for document-based apps to do the following things:
● Create new documents. The first time the user chooses to save a new document, it presents a dialog
enabling the user to name and save the document in a disk file in a user-chosen location.
● Open existing documents stored in files. A document-based app specifies the types of document it can
read and write, as well as read-only and write-only types. It can represent the data of different types
internally and display the data appropriately. It can also close documents.
● Automatically save documents. Document-based apps can adopt autosaving in place, and its documents
are automatically saved at appropriate times so that the data the user sees on screen is effectively the
same as that saved on disk. Saving is done safely, so that an interrupted save operation does not leave
data inconsistent.
The Core App Design
Document-Based Apps Are Based on an NSDocument Subclass
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
32● Asynchronously read and write document data. Reading and writing are done asynchronously on a
background thread, so that lengthy operations do not make the app’s user interface unresponsive. In
addition, reads and writes are coordinated using NSFilePresenter protocol and NSFileCoordinator
class to reduce version conflicts. Coordinated reads and writes reduce version conflicts both among
different appssharing document data in localstorage and among different instances of an app on different
devices sharing document data via iCloud.
● Manage multiple versions of documents. Autosave creates versions at regular intervals, and users can
manually save a version whenever they wish. Users can browse versions and revert the document’s contents
to a chosen version using a Time Machine–like interface. The version browser is also used to resolve version
conflicts from simultaneous iCloud updates.
● Print documents. The print dialog and page setup dialog enable the user to choose various page layouts.
● Monitor and set the document’s edited status and validate menu items. To avoid automatic saving of
inadvertent changes, old files are locked from editing until explicitly unlocked by the user.
● Track changes. The document manages its edited status and implements multilevel undo and redo.
● Handle app and window delegation. Notifications are sent and delegate methods called at significant
lifecycle events, such as when the app terminates.
See Document-Based App Programming Guide for Mac for more detailed information about how to implement
a document-based app.
The App Life Cycle
The app life cycle is the progress of an app from its launch through its termination. Apps can be launched by
the user or the system. The user launches apps by double-clicking the app icon, using Launchpad, or opening
a file whose type is currently associated with the app. In OS X v10.7 and later, the system launches apps at user
login time when it needs to restore the user’s desktop to its previous state.
When an app is launched, the system creates a process and all of the normal system-related data structures
for it. Inside the process, it creates a main thread and uses it to begin executing your app’s code. At that point,
your app’s code takes over and your app is running.
The main Function is the App Entry Point
Like any C-based app, the main entry point for a Mac app at launch time is the main function. In a Mac app,
the main function is used only minimally. Its main job is to give control to the AppKit framework. Any new
project you create in Xcode comes with a default main function like the one shown in Listing 2-1. You should
normally not need to change the implementation of this function.
The Core App Design
The App Life Cycle
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
33Listing 2-1 The main function of a Mac app
#import
int main(int argc, char *argv[])
{
return NSApplicationMain(argc, (const char **) argv);
}
The NSApplicationMain function initializes your app and prepares it to run. As part of the initialization
process, this function does several things:
● Creates an instance of the NSApplication class. You can access this object from anywhere in your app
using the sharedApplication class method.
● Loads the nib file specified by the NSMainNibFile key in the Info.plist file and instantiates all of the
objects in that file. This is your app’s main nib file and should contain your application delegate and any
other critical objects that must be loaded early in the launch cycle. Any objects that are not needed at
launch time should be placed in separate nib files and loaded later.
● Calls the run method of your application object to finish the launch cycle and begin processing events.
By the time the run method is called, the main objects of your app are loaded into memory but the app is still
not fully launched. The run method notifies the application delegate that the app is about to launch, shows
the application menu bar, opens any files that were passed to the app, does some framework housekeeping,
and starts the event processing loop. All of this work occurs on the app’s main thread with one exception. Files
may be opened in secondary threads if the canConcurrentlyReadDocumentsOfType: class method of the
corresponding NSDocument object returns YES.
If your app preserves its user interface between launch cycles, Cocoa loads any preserved data at launch time
and uses it to re-create the windows that were open the last time your app was running. For more information
about how to preserve your app’s user interface, see “User Interface Preservation” (page 39).
The App’s Main Event Loop Drives Interactions
Asthe user interacts with your app, the app’s main event loop processesincoming events and dispatchesthem
to the appropriate objects for handling. When the NSApplication object is first created, it establishes a
connection with the system window server, which receives events from the underlying hardware and transfers
The Core App Design
The App Life Cycle
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
34them to the app. The app also sets up a FIFO event queue to store the events sent to it by the window server.
The main event loop isthen responsible for dequeueing and processing events waiting in the queue, asshown
in Figure 2-7.
Figure 2-7 The main event loop
The run method of the NSApplication object is the workhorse of the main event loop. In a closed loop, this
method executes the following steps until the app terminates:
1. Services window-update notifications, which results in the redrawing of any windows that are marked as
“dirty.”
2. Dequeues an event from its internal event queue using the
nextEventMatchingMask:untilDate:inMode:dequeue: method and converts the event data into
an NSEvent object.
3. Dispatchesthe event to the appropriate target object using the sendEvent: method of NSApplication.
When the app dispatches an event, the sendEvent: method uses the type of the event to determine the
appropriate target. There are two major types of input events: key events and mouse events. Key events are
sent to the key window—the window that is currently accepting key presses. Mouse events are dispatched
to the window in which the event occurred.
For mouse events, the window looks for the view in which the event occurred and dispatches the event to
that object first. Views are responder objects and are capable of responding to any type of event. If the view is
a control, it typically uses the event to generate an action message for its associated target.
The overall process for handling events is described in detail in Cocoa Event Handling Guide .
The Core App Design
The App Life Cycle
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
35Automatic and Sudden Termination of Apps Improve the User Experience
In OS X v10.7 and later, the use of the Quit command to terminate an app is diminished in favor of more
user-centric techniques. Specifically, Cocoa supports two techniques that make the termination of an app
transparent and fast:
● Automatic termination eliminates the need for users to quit an app. Instead, the system manages app
termination transparently behind the scenes, terminating apps that are not in use to reclaim needed
resources such as memory.
● Sudden termination allows the system to kill an app’s process immediately without waiting for it to
perform any final actions. The system uses this technique to improve the speed of operations such as
logging out of, restarting, or shutting down the computer.
Automatic termination and sudden termination are independent techniques, although both are designed to
improve the user experience of app termination. Although Apple recommendsthat appssupport both, an app
can support one technique and not the other. Apps that support both techniques can be terminated by the
system without the app being involved at all. On the other hand, if an app supports sudden termination but
not automatic termination, then it must be sent a Quit event, which it needs to process without displaying
any user interface dialogs.
Automatic termination transfers the job of managing processes from the user to the system, which is better
equipped to handle the job. Users do not need to manage processes manually anyway. All they really need is
to run apps and have those apps available when they need them. Automatic termination makes that possible
while ensuring that system performance is not adversely affected.
Apps must opt in to both automatic termination and sudden termination and implement appropriate support
for them. In both cases, the app must ensure that any user data is saved well before termination can happen.
And because the user does not quit an autoterminable app, such an app should also save the state of its user
interface using the built-in Cocoa support. Saving and restoring the interface state provides the user with a
sense of continuity between app launches.
For information on how to support for automatic termination in your app, see “Automatic Termination” (page
37). For information on how to support sudden termination, see “Sudden Termination” (page 38).
Support the Key Runtime Behaviors in Your Apps
No matter what style of app you are creating, there are specific behaviors that all apps should support. These
behaviors are intended to help users focus on the content they are creating rather than focus on app
management and other busy work that is not part of creating their content.
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
36Automatic Termination
Automatic termination is a feature that you must explicitly code for in your app. Declaring support for automatic
termination is easy, but apps also need to work with the system to save the current state of their user interface
so that it can be restored later as needed. The system can kill the underlying process for an auto-terminable
app at any time, so saving this information maintains continuity for the app. Usually, the system kills an app’s
underlying process some time after the user has closed all of the app’s windows. However, the system may
also kill an app with open windows if the app is not currently on screen, perhaps because the user hid it or
switched spaces.
To support automatic termination, you should do the following:
● Declare your app’s support for automatic termination, either programmatically or using an Info.plist
key.
● Support saving and restoring your window configurations.
● Save the user’s data at appropriate times.
● Single-window, library-style apps should implement strategies for saving data at appropriate
checkpoints.
● Multiwindow, document-based apps can use the autosaving and saveless documents capabilities in
NSDocument.
● Whenever possible, support sudden termination for your app as well.
Enabling Automatic Termination in Your App
Declaring support for automatic termination letsthe system know that itshould manage the actual termination
of your app at appropriate times. An app has two ways to declare its support for automatic termination:
●
Include the NSSupportsAutomaticTermination key (with the value YES) in the app’s Info.plist
file. This sets the app’s default support status.
● Use the NSProcessInfo classto declare support for automatic termination dynamically. Use thistechnique
to change the default support of an app that includes the NSSupportsAutomaticTermination key in
its Info.plist file.
Automatic Data-Saving Strategies Relieve the User
You should always avoid forcing the user to save changesto their data manually. Instead, implement automatic
data saving. For a multiwindow app based on NSDocument, automatic saving is as simple as overriding the
autosavesInPlace classmethod to return YES. Formore information,seeDocument-Based App Programming
Guide for Mac .
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
37For a single-window, library-style app, identify appropriate pointsin your code where any user-related changes
should be saved and write those changes to disk automatically. This benefits the user by eliminating the need
to think about manually saving changes, and when done regularly, it ensures that the user does not lose much
data if there is a problem.
Some appropriate times when you can save user data automatically include the following:
● When the user closes the app window or quits the app (applicationWillTerminate:)
● When the app is deactivated (applicationWillResignActive:)
● When the user hides your app (applicationWillHide:)
● Whenever the user makes a valid change to data in your app
The last item means that you have the freedom to save the user’s data at any time it makes sense to do so. For
example, if the user is editing fields of a data record, you can save each field value as it is changed or you can
wait and save all fields when the user displays a new record. Making these types of incremental changes ensures
that the data is always up-to-date but also requires more fine-grained management of your data model. In
such an instance, Core Data can help you make the changes more easily. For information about Core Data, see
Core Data Starting Point.
Sudden Termination
Sudden termination lets the system know that your app’s process can be killed directly without any additional
involvement from your app. The benefit of supporting sudden termination is that it lets the system close apps
more quickly, which is important when the user is shutting down a computer or logging out.
An app has two ways to declare its support for sudden termination:
●
Include the NSSupportsSuddenTermination key (with the value YES) in the app’s Info.plist file.
● Use the NSProcessInfo class to declare support for sudden termination dynamically. You can also use
this class to change the default support of an app that includes the NSSupportsSuddenTermination
key in its Info.plist file.
One solution is to declare global support for the feature globally and then manually override the behavior at
appropriate times. Because sudden termination means the system can kill your app at any time after launch,
you should disable it while performing actions that might lead to data corruption if interrupted. When the
action is complete, reenable the feature again.
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
38You disable and enable sudden termination programmatically using the disableSuddenTermination and
enableSuddenTerminationmethods ofthe NSProcessInfo class. Thesemethodsincrement and decrement
a counter, respectively, maintained by the process. When the value of this counter is 0, the process is eligible
for sudden termination. When the value is greater than 0, sudden termination is disabled.
Enabling and disabling sudden termination dynamically also meansthat your app should save data progressively
and not rely solely on user actions to save important information. The best way to ensure that your app’s
information is saved at appropriate times is to support the interfaces in OS X v10.7 for saving your document
and window state. Those interfaces facilitate the automatic saving of relevant user and app data. For more
information about saving your user interface state, see “User Interface Preservation” (page 39). For more
information about saving your documents, see “Document-Based Apps Are Based on an NSDocument
Subclass” (page 31).
For additional information about enabling and disabling sudden termination,see NSProcessInfo Class Reference .
User Interface Preservation
The Resume feature, in OS X v10.7 and later, saves the state of your app’s windows and restores them during
subsequent launches of your app. Saving the state of your windows enables you to return your app to the
state it was in when the user last used it. Use the Resume feature especially if your app supports automatic
termination, which can cause your app to be terminated while it is running but hidden from the user. If your
app supports automatic termination but does not preserve its interface, the app launches into its default state.
Users who only switched away from your app might think that the app crashed while it was not being used.
Writing Out the State of Your Windows and Custom Objects
You must do the following to preserve the state of your user interface:
● For each window, you must set whether the window should be preserved using the setRestorable:
method.
● For each preserved window, you must specify an object whose job is to re-create that window at launch
time.
● Any objects involved in your user interface must write out the data they require to restore their state later.
● At launch time, you must use the provided data to restore your objects to their previous state.
The actual process of writing out your application state to disk and restoring it later is handled by Cocoa, but
you must tell Cocoa what to save. Your app’s windows are the starting point for all save operations. Cocoa
iterates over all of your app’s windows and saves data for the ones whose isRestorable method returns
YES. Most windows are preserved by default, but you can change the preservation state of a window using
the setRestorable: method.
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
39In addition to preserving your windows, Cocoa saves data for most of the responder objects associated with
the window. Specifically, it saves the views and window controller objects associated with the window. (For a
multiwindow document-based app, the window controller also saves data from its associated document
object.) Figure 2-8 shows the path that Cocoa takes when determining which objects to save. Window objects
are always the starting point, but other related objects are saved, too.
Figure 2-8 Responder objects targeted by Cocoa for preservation
All Cocoa window and view objects save basic information about their size and location, plus information
about other attributes that might affect the way they are currently displayed. For example, a tab view saves
the index of the selected tab, and a text view savesthe location and range of the current textselection. However,
these responder objects do not have any inherent knowledge about your app’s data structures. Therefore, it
is your responsibility to save your app’s data and any additional information needed to restore the window to
its current state. There are several places where you can write out your custom state information:
●
If you subclass NSWindow or NSView, implement the encodeRestorableStateWithCoder: method
in your subclass and use it to write out any relevant data.
Alternatively, your custom responder objects can override the restorableStateKeyPaths method and
use it to specify key paths for any attributes to be preserved. Cocoa uses the key paths to locate and save
the data for the corresponding attribute. Attributes must be compliant with key-value coding and Key-value
observing.
●
If your window has a delegate object, implement the window:willEncodeRestorableState: method
for the delegate and use it to store any relevant data.
●
In your window controller, use the encodeRestorableStateWithCoder: method to save any relevant
data or configuration information.
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
40Be judicious when deciding what data to preserve, and strive to write out the smallest amount of information
that is required to reconfigure your window and associated objects. You are expected to save the actual data
that the window displays and enough information to reattach the window to the same data objects later.
Important: Never use the user interface preservation mechanism as a way to save your app’s actual data.
The archive created for interface preservation can change frequently and may be ignored altogether if there
is a problem during the restoration process. Your app data should always be saved independently in data
files that are managed by your app.
For information on how to use coder objects to archive state information, see NSCoder Class Reference . For
additional information on what you need to do to save state in a multiwindow document-based app, see
Document-Based App Programming Guide for Mac .
Notifying Cocoa About Changes to Your Interface State
Whenever the preserved state of one of your responder objects changes, mark the object as dirty by calling the
invalidateRestorableState method of that object. Having done so, at some point in the future,
encodeRestorableStateWithCoder: message is sent to your responder object. Marking your responder
objects as dirty lets Cocoa know that it needs to write their preservation state to disk at an appropriate time.
Invalidating your objects is a lightweight operation in itself because the data is not written to disk right away.
Instead, changes are coalesced and written at key times, such as when the user switches to another app or
logs out.
You should mark a responder object as dirty only for changes that are truly interface related. For example, a
tab view marks itself as dirty when the user selects a different tab. However, you do not need to invalidate
your window or its views for many content-related changes, unless the content changes themselves caused
the window to be associated with a completely different set of data-providing objects.
If you used the restorableStateKeyPaths method to declare the attributes you want to preserve, Cocoa
preserves and restores the values of those attributes of your responder object. Therefore, any key paths you
provide should be key-value observing compliant and generate the appropriate notifications. For more information
on how to support key-value observing in your objects, see Key-Value Observing Programming Guide .
Restoring Your Windows and Custom Objects at Launch TIme
As part of your app’s normal launch cycle, Cocoa checks to see whether there is any preserved interface data.
If there is, Cocoa usesthat data to try to re-create your app’s windows. Every window must identify a restoration
class that knows about the window and can act on its behalf at launch time to create the window when asked
to do so by Cocoa.
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
41The restoration class is responsible for creating both the window and all of the critical objects required by that
window. For most app styles, the restoration class usually creates one or more controller objects as well. For
example, in a single-window app, the restoration class would likely create the window controller used to
manage the window and then retrieve the window from that object. Because it createsthese controller objects
too, you typically use high-level application classesfor your restoration classes. An app might use the application
delegate, a document controller, or even a window controller as a restoration class.
During the launch cycle, Cocoa restores each preserved window as follows:
1. Cocoa retrieves the window’s restoration class from the preserved data and calls its
restoreWindowWithIdentifier:state:completionHandler: class method.
2. The restoreWindowWithIdentifier:state:completionHandler: class method must call the
provided completion handler with the desired window object. To do this, it does one of the following:
●
It creates any relevant controller objects (including the window controller) that might normally be
created to display the window.
●
If the controller objects already exist (perhaps because they were already loaded from a nib file), the
method gets the window from those existing objects.
If the window could not be created, perhaps because the associated document was deleted by the user,
the restoreWindowWithIdentifier:state:completionHandler: should pass an error object to
the completion handler.
3. Cocoa uses the returned window to restore it and any preserved responder objects to their previous state.
● Standard Cocoa window and view objects are restored to their previousstate without additional help.
If you subclass NSWindow or NSView, implement the restoreStateWithCoder: method to restore
any custom state.
If you implemented the restorableStateKeyPaths method in your custom responder objects,
Cocoa automatically sets the value of the associated attributes to their preserved values. Thus, you
do not have to implement the restoreStateWithCoder: to restore these attributes.
● For the window delegate object, Cocoa calls the window:didDecodeRestorableState: method
to restore the state of that object.
● For your window controller, Cocoa calls the restoreStateWithCoder: method to restore its state.
When re-creating each window, Cocoa passes the window’s unique identifier string to the restoration class.
You are responsible for assigning user interface identifier strings to your windows prior to preserving the
window state. You can assign an identifier in your window’s nib file or by setting your window object's
identifier property (defined in NSUserInterfaceItemIdentification protocol). For example, you
might give your preferences window an identifier of preferences and then check for that identifier in your
The Core App Design
Support the Key Runtime Behaviors in Your Apps
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
42implementation. Your restoration class can use this identifier to determine which window and associated
objects it needs to re-create. The contents of an identifier string can be anything you want but should be
something to help you identify the window later.
For a single-window app whose main window controller and window are loaded from the main nib file, the
job of your restoration class is fairly straightforward. Here, you could use the application delegate’s class as
the restoration class and implement the restoreWindowWithIdentifier:state:completionHandler:
method similar to the implementation shown in Listing 2-2. Because the app has only one window, it returns
the main window directly. If you used the application delegate’s class asthe restoration classfor other windows,
your own implementation could use the identifier parameter to determine which window to create.
Listing 2-2 Returning the main window for a single-window app
+ (void)restoreWindowWithIdentifier:(NSString *)identifier
state:(NSCoder *)state
completionHandler:(void (^)(NSWindow *, NSError *))completionHandler
{
// Get the window from the window controller,
// which is stored as an outlet by the delegate.
// Both the app delegate and window controller are
// created when the main nib file is loaded.
MyAppDelegate* appDelegate = (MyAppDelegate*)[[NSApplication sharedApplication]
delegate];
NSWindow* mainWindow = [appDelegate.windowController window];
// Pass the window to the provided completion handler.
completionHandler(mainWindow, nil);
}
Apps Are Built Using Many Different Pieces
The objects of the core architecture are important but are not the only objects you need to consider in your
design. The core objects manage the high-level behavior of your app, but the objects in your app’s view layer
do most of the work to display your custom content and respond to events. Other objects also play important
roles in creating interesting and engaging apps.
The Core App Design
Apps Are Built Using Many Different Pieces
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
43The User Interface
An app’s user interface is made up of a menu bar, one or more windows, and one or more views. The menu
bar is a repository for commands that the user can perform in the app. Commands may apply to the app as a
whole, to the currently active window, or to the currently selected object. You are responsible for defining the
commands that your app supports and for providing the event-handling code to respond to them.
You use windows and views to present your app’s visual content on the screen and to manage the immediate
interactions with that content. A window is an instance of the NSWindow class. A panel is an instance of the
NSPanel class(which is a descendant of NSWindow) that you use to presentsecondary content. Single-window
apps have one main window and may have one or more secondary windows or panels. Multiwindow apps
have multiple windows for displaying their primary content and may have one or more secondary windows
or panels too. The style of a window determines its appearance on the screen. Figure 2-9 shows the menu bar,
along with some standard windows and panels.
Figure 2-9 Windows and menus in an app
A view, an instance of the NSView class, defines the content for a rectangular region of a window. Views are
the primary mechanism for presenting content and interacting with the user and have several responsibilities.
For example:
● Drawing and animation support. Views draw content in their rectangular area. Views that support Core
Animation layers can use those layers to animate their contents.
● Layout and subview management. Each view manages a list ofsubviews, allowing you to create arbitrary
view hierarchies. Each view defineslayout and resizing behaviorsto accommodate changesin the window
size.
The Core App Design
Apps Are Built Using Many Different Pieces
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
44● Event handling. Views receive events. Views forward events to other objects when appropriate.
For information about creating and configuring windows, see Window Programming Guide . For information
about using and creating view hierarchies, see View Programming Guide .
Event Handling
The system window server is responsible for tracking mouse, keyboard, and other events and delivering them
to your app. When the system launches an app, it creates both a process and a single thread for the app. This
initial thread becomes the app’s main thread. In it, the NSApplication object sets up the main run loop and
configures its event-handling code, as shown in Figure 2-10. As the window server delivers events, the app
queues those events and then processes them sequentially in the app’s main run loop. Processing an event
involves dispatching the event to the object best suited to handle it. For example, mouse events are usually
dispatched to the view in which the event occurred.
Figure 2-10 Processing events in the main run loop
Note: A run loop monitors sources of input on a specific thread of execution. The app’s event queue
represents one of these inputsources. While the event queue is empty, the main thread sleeps. When
an event arrives, the run loop wakes up the thread and dispatches control to the NSApplication
object to handle the event. After the event has been handled, control passes back to the run loop,
which can then process another event, process other input sources, or put the thread back to sleep
if there is nothing more to do. For more information about how run loops and input sources work,
see Threading Programming Guide .
Distributing and handling events is the job of responder objects, which are instances of the NSResponder
class. The NSApplication, NSWindow, NSDrawer, NSView, NSWindowController, and NSViewController
classes are all descendants of NSResponder. After pulling an event from the event queue, the app dispatches
The Core App Design
Apps Are Built Using Many Different Pieces
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
45that event to the window object where it occurred. The window object, in turn, forwards the event to its first
responder. In the case of mouse events, the first responder is typically the view object (NSView) in which the
touch took place. For example, a mouse event occurring in a button is delivered to the corresponding button
object.
If the first responder is unable to handle an event, it forwardsthe event to its nextresponder, which istypically
a parent view, view controller, or window. If that object is unable to handle the event, it forwards it to its next
responder, and so , until the event is handled. Thisseries of linked responder objectsis known asthe responder
chain. Messages continue traveling up the responder chain—toward higher-level responder objects, such as
a window controller or the application object—until the event is handled. If the event isn't handled, it is
discarded.
The responder object that handles an event often sets in motion a series of programmatic actions by the app.
For example, a control object (that is, a subclass of NSControl) handles an event by sending an action message
to another object, typically the controller that manages the current set of active views. While processing the
action message, the controller might change the user interface or adjust the position of views in ways that
require some of those views to redraw themselves. When this happens, the view and graphics infrastructure
takes over and processes the required redraw events in the most efficient manner possible.
For more information about responders, the responder chain, and handling events, see Cocoa Event Handling
Guide .
Graphics, Drawing, and Printing
There are two basic ways in which a Mac app can draw its content:
● Native drawing technologies (such as Core Graphics and AppKit)
● OpenGL
The native OS X drawing technologies typically use the infrastructure provided by Cocoa views and windows
to render and present custom content. When a view is first shown, the system asks it to draw its content.
System views draw their contents automatically, but custom views must implement a drawRect: method.
Inside this method, you use the native drawing technologies to draw shapes, text, images, gradients, or any
other visual content you want. When you want to update your view’s visual content, you mark all or part of
the view invalid by calling its setNeedsDisplay: or setNeedsDisplayInRect: method. The system then
calls your view’s drawRect: method (at an appropriate time) to accommodate the update. This cycle then
repeats and continues throughout the lifetime of your app.
If you are using OpenGL to draw your app’s content, you still create a window and view to manage your content,
but those objects simply provide the rendering surface for an OpenGL drawing context. Once you have that
drawing context, your app is responsible for initiating drawing updates at appropriate intervals.
The Core App Design
Apps Are Built Using Many Different Pieces
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
46For information about how to draw custom content in your views, see Cocoa Drawing Guide .
Text Handling
The Cocoa text system, the primary text-handling system in OS X, is responsible for the processing and display
of all visible text in Cocoa. It provides a complete set of high-quality typographical services through the
text-related AppKit classes, which enable apps to create, edit, display, and store text with all the characteristics
of fine typesetting.
The Cocoa text system provides all these basic and advanced text-handling features, and it also satisfies
additional requirements from the ever-more-interconnected computing world: support for the character sets
of all of the world’s living languages, powerful layout capabilities to handle various text directionality and
nonrectangular text containers, and sophisticated typesetting capabilities such as control of kerning, ligatures,
line breaking, and justification. Cocoa’s object-oriented textsystem is designed to provide all these capabilities
without requiring you to learn about or interact with more of the system than is necessary to meet the needs
of your app.
Underlying the Cocoa text system is Core Text, which provides low-level, basic text layout and font-handling
capabilities to higher-level engines such as Cocoa and WebKit. Core Text provides the implementation for
many Cocoa text technologies. App developers typically have no need to use Core Text directly. However, the
Core Text API is accessible to developers who must use it directly, such as those writing apps with their own
layout engine and those porting older ATSUI- or QuickDraw-based codebases to the modern world.
For more information about the Cocoa text system, see Cocoa Text Architecture Guide .
Implementing the Application Menu Bar
The classes NSMenu and NSMenuItem are the basis for all types of menus. An instance of NSMenu manages a
collection of menu items and draws them one beneath another. An instance of NSMenuItem represents a
menu item; it encapsulates all the information its NSMenu object needs to draw and manage it, but does no
drawing or event-handling itself. You typically use Interface Builder to create and modify any type of menu,
so often there is no need to write any code.
The application menu bar stretches across the top of the screen, replacing the menu bar of any other app
when the app is foremost. All of an app’s menus in the menu bar are owned by one NSMenu instance that’s
created by the app when it starts up.
The Core App Design
Implementing the Application Menu Bar
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
47Xcode Templates Provide the Menu Bar
Xcode’s Cocoa application templates provide that NSMenu instance in a nib file called MainMenu.xib. This
nib file contains an application menu (named with the app’s name), a File menu (with all of its associated
commands), an Edit menu (with text editing commands and Undo and Redo menu items), and Format, View,
Window, and Help menus (with their own menu items representing commands). These menu items, as well
as all of the menu items of the File menu, are connected to the appropriate first-responder action methods.
For example, the About menu item is connected to the orderFrontStandardAboutPanel: action method
in the File’s Owner that displays a standard About window.
The template has similar ready-made connections for the Edit, Format, View, Window, and Help menus. If your
app does not support any of the supplied actions (for example, printing), you should remove the associated
menu items (or menu) from the nib. Alternatively, you may want to repurpose and rename menu commands
and action methodsto suit your own app, taking advantage of the menu mechanism in the template to ensure
that everything is in the right place.
Connect Menu Items to Your Code or Your First Responder
For your app’s custom menu items that are not already connected to action methods in objects or placeholder
objects in the nib file, there are two common techniques for handling menu commands in a Mac app:
● Connect the corresponding menu item to a first responder method.
● Connect the menu item to a method of your custom application object or your application delegate object.
Of these two techniques, the first is more common given that many menu commands act on the current
document or its contents, which are part of the responder chain. The second technique is used primarily to
handle commands that are global to the app, such as displaying preferences or creating a new document. It
is possible for a custom application object or its delegate to dispatch events to documents, but doing so is
generally more cumbersome and prone to errors. In addition to implementing action methods to respond to
your menu commands, you must also implement the methods of the NSMenuValidation protocol to enable
the menu items for those commands.
Step-by-step instructions for connecting menu items to action methods in your code are given in “Designing
User Interfaces in Xcode”. For more information about menu validation and other menu topics, see Application
Menu and Pop-up List Programming Topics.
The Core App Design
Implementing the Application Menu Bar
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
48Enabling a window of your app to assume full-screen mode, taking over the entire screen, provides users with
a more immersive, cinematic experience. Full-screen appearance can be striking and can make your app stand
out. From a practical standpoint, full-screen mode presents a better view of users’ data, enabling them to
concentrate fully on their content without the distractions of other apps or the desktop.
In full-screen mode, by default, the menu bar and Dock are autohidden; that is, they are normally hidden but
reappear when the user moves the pointer to the top or bottom of the screen. A full-screen window does not
draw its titlebar and may have special handling for its toolbar.
The full-screen experience makes sense for many apps but not for all. For example, the Finder, Address Book,
and Calculator would not provide any benefit to users by assuming full-screen mode. The same is probably
true for most utility apps. Media-rich apps, on the other hand, can often benefit from full-screen presentation.
Beginning with OS X v10.7, Cocoa includes support for full-screen mode through APIs in NSApplication,
NSWindow, and NSWindowDelegate protocol. When the user chooses to enter full-screen mode, Cocoa
dynamically creates a space and puts the window into that space. This behavior enables the user to have one
window of an app running in full-screen mode in one space, while using other windows of that app, as well
as other apps, on the desktop in otherspaces. While in full-screen mode, the user can switch between windows
in the current app or switch apps.
Apps that have implemented full-screen user interfaces in previous versions of OS X should consider
standardizing on the full-screen APIs in OS X v10.7.
Full-Screen API in NSApplication
Full-screen support in NSApplication is provided by the presentation option
NSApplicationPresentationFullScreen. You can find the current presentation mode via the
NSApplication method currentSystemPresentationOptions, which is also key-value observable. You
can set the presentation options using the NSApplication method setPresentationOptions:. (Be sure
to observe the restrictions on presentation option combinations documented with
NSApplicationPresentationOptions, and set the presentation optionsin a try-catch block to ensure that
your program does not crash from an invalid combination of options.)
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
49
Implementing the Full-Screen ExperienceA window delegate may also specify that the window toolbar be removed from the window in full-screen
mode and be shown automatically with the menu bar by including
NSApplicationPresentationAutoHideToolbar in the presentation options returned from the
window:willUseFullScreenPresentationOptions: method of NSWindowDelegate.
Full-Screen API in NSWindow
The app must specify whether a given window can enter full-screen mode. Apps can set collection behavior
using the setCollectionBehavior: method by passing in various constants, and the current options may
be accessed via the collectionBehavior method. You can choose between two constants to override the
window collection behavior, as shown in the following table:
Constant Behavior
The frontmost window with this collection behavior becomes
the full-screen window. A window with this collection
behavior has a full-screen button in the upper right of its
titlebar.
NSWindowCollectionBehaviorFullScreenPrimary
Windows with this collection behavior can be shown in the
same space with the full-screen window.
NSWindowCollectionBehaviorFullScreenAuxiliary
When a window goesinto full-screen mode, the styleMask changesto NSFullScreenWindowMask to reflect
the state of the window.The setting of the styleMask goesthrough the setStyleMask: method. As a result,
a window can override this method if it has customization to do when entering or exiting full-screen.
A window can be taken into or out of full-screen mode using the toggleFullScreen: method. If an app
supports full-screen mode, it should add a menu item to the View menu with toggleFullScreen: as the
action, and nil as the target.
Full-Screen API in NSWindowDelegate Protocol
The following notifications are sent before and after the window enters and exits full-screen mode:
NSWindowWillEnterFullScreenNotification
NSWindowDidEnterFullScreenNotification
NSWindowWillExitFullScreenNotification
NSWindowDidExitFullScreenNotification
Implementing the Full-Screen Experience
Full-Screen API in NSWindow
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
50The window delegate has the following corresponding window delegate notification methods:
windowWillEnterFullScreen:
windowDidEnterFullScreen:
windowWillExitFullScreen:
windowDidExitFullScreen:
The NSWindowDelegate protocol methods supporting full-screen mode are listed in Table 3-1.
Table 3-1 Window delegate methods supporting full-screen mode
Method Description
Invoked to allow the delegate
to modify the full-screen
content size.
window: willUseFullScreenContentSize:
Returns the presentation
options the window will use
when transitioning to
full-screen mode.
window: willUseFullScreenPresentationOptions:
Invoked when the window is
about to enter full-screen mode.
The window delegate can
implement this method to
customize the animation by
returning a custom window or
array of windows containing
layers or other effects.
customWindowsToEnterFullScreenForWindow:
The system has started its
animation into full-screen
mode, including transitioning
into a new space. You can
implement this method to
perform custom animation with
the given duration to be in sync
with the system animation.
window:
startCustomAnimationToEnterFullScreenWithDuration:
Invoked if the window failed to
enter full-screen mode.
windowDidFailToEnterFullScreen:
Implementing the Full-Screen Experience
Full-Screen API in NSWindowDelegate Protocol
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
51Method Description
Invoked when the window is
about to exit full-screen mode.
The window delegate can
implement this method to
customize the animation when
the window is about to exit
full-screen by returning a
custom window or array of
windows containing layers or
other effects.
customWindowsToExitFullScreenForWindow:
The system has started its
animation out of full-screen,
including transitioning back to
the desktop space. You can
implement this method to
perform custom animation with
the given duration to be in sync
with the system animation.
window:
startCustomAnimationToExitFullScreenWithDuration:
Invoked if the window failed to
exit full-screen mode.
windowDidFailToExitFullScreen:
For more information about full-screen mode, see NSWindowDelegate Protocol Reference and the OS X Human
Interface Guidelines.
Implementing the Full-Screen Experience
Full-Screen API in NSWindowDelegate Protocol
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
52During the design phase of creating your app, you need to think about how to implement certain features
that users expect in well-formed Mac apps. Integrating these features into your app architecture can have an
impact on the data model or may require cooperation between significantly different portions in the app.
You Can Prevent the Automatic Relaunch of Your App
By default, as part of the Resume feature of OS X v10.7, apps that were open at logout are relaunched by the
system when the user logsin again. You can prevent the automatic relaunching of your app at login by sending
it a disableRelaunchOnLogin message. This NSApplication method increments a counter that controls
the app being relaunched; if the counter is 0 at the time the user logs out, then the app is relaunched when
the user logs back in. The counter is initially zero, providing the default relaunch behavior.
Your can reinstate automatic relaunching of your app by sending it an enableRelaunchOnLogin message.
This message decrements the relaunch counter, so an equal number of disableRelaunchOnLogin and
enableRelaunchOnLogin messages enables relaunching. Both methods are thread safe.
If your app should not be relaunched because it launches via some other mechanism, such as the launchd
system process, then the recommended practice is to send the app a disableRelaunchOnLogin message
once, and never pair it with an enableRelaunchOnLogin message.
If your app should not be relaunched because it triggers a restart (for example, if it is an installer), then the
recommended practice is to send it a disableRelaunchOnLogin message immediately before you attempt
to trigger a restart and send it an enableRelaunchOnLogin message immediately after. This procedure
handles the case where the user cancels restarting; if the user later restarts for another reason, then your app
should be relaunched.
Making Your App Accessible Enables Many Users
Millions of people have a disability or special need. These include visual and hearing impairments, physical
disabilities, and cognitive and learning challenges. Access to computers is vitally important for this population,
because computers can provide a level of independence that is difficult to attain any other way. As populations
around the world age, an increasing number of people will experience age-related disabilities, such as vision
or hearing loss. Current and future generations of the elderly will expect to be able to continue using their
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
53
Supporting Common App Behaviorscomputers and accessing their data, regardless of the state of their vision and hearing. Apps that support
customizable text displays, access by a screen reader, or the replacement of visual cues by audible ones can
serve this population well.
OS X is designed to accommodate assistive technologies and has many built-in features to help people with
disabilities. Users access most of this functionality through the Universal Access pane of System Preferences.
Some of these built-in technologies take advantage of the same accessibility architecture that allows external
assistive technologies to access your app. Designing your app with accessibility in mind not only allows you
to reach a larger group of users, it results in a better experience for all your users.
As a first step in designing your app, be sure to read OS X Human Interface Guidelines. That book provides
detailed specifications and best practices for designing and implementing an intuitive, consistent, and
aesthetically pleasing user interface that delivers the superlative experience Macintosh users have come to
expect. During the design process, you also should be aware of the accessibility perspective on many basic
design considerations. Consider the following basic accessibility-related design principles:
● Support full keyboard navigation. For many users, a mouse is difficult, if not impossible, to use.
Consequently, a user should be able to perform all your app’s functions using the keyboard alone.
● Don’t override built-in keyboard shortcuts. This applies both to the keyboard shortcuts OS X reserves
(listed in “Keyboard Shortcuts”) and to the accessibility-related keyboard shortcuts (listed in “Accessibility
Keyboard Shortcuts”). As a general rule, you should never override reserved keyboard shortcuts. In particular,
you should take care not to override accessibility-related keyboard shortcuts or your app will not be
accessible to users who enable full keyboard access.
A corollary to this principle is to avoid creating too many new keyboard shortcuts that are specific to your
app. Users should not have to memorize a new set of keyboard commands for each app they use.
● Provide alternatives for drag-and-drop operations. If your app relies on drag-and-drop operations in its
workflow, you should provide alternate ways to accomplish the same tasks. This may not be easy; in fact,
it may require the design of an alternate interface for apps that are heavily dependent on drag and drop.
● Make sure there’s always a way out of your app’s workflow. This is important for all users, of course,
but it’s essential for users of assistive technologies. A user relying on an assistive app to use your app may
have a somewhat narrower view of your app’s user interface. For this reason, it’s especially important to
make canceling operations and retracing steps easy.
In addition to the basic design principles, you should consider the requirements of specific disabilities and
resulting design solutions and adaptations you can implement. The main theme of these suggestions is to
provide as many alternate modes of content display as possible, so that users can find the way that suits their
needs best. Consider the following categories of disabilities:
Supporting Common App Behaviors
Making Your App Accessible Enables Many Users
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
54● Visual Disabilities. Visual disabilities include blindness, color blindness, and low vision. Make your app
accessible to assistive apps, such as screen readers. Ensure that color is not the only source of come
particular information in your user interface. Provide an audio option for all visual cues and feedback, as
well as succinct descriptions of images and animated content.
● Hearing Disabilities. When you design the audio output of your app, remember that some users may not
be able to hear your app’s sound effects well or at all. And, of course, there are situations in which any
user could not use audio output effectively, such as in a library. Providing redundant audio and visual
output can aid comprehension for users with other types of disabilities as well, such as cognitive and
learning disabilities.
● Motor and Cognitive Disabilities. People with motor disabilities may need to use alternatives to the
standard mouse and keyboard input devices. Other users may have difficulty with the fine motor control
required to double-click a mouse or to press key combinations on the keyboard. Users with cognitive or
learning disabilities may need extra time to complete tasks or respond to alerts.
OS X providessupport for many types of disabilities at the system level through solutions offered in the Universal
Access system preferences, illustrated in Figure 4-1. In addition, most standard Cocoa objects implement
accessibility through the NSAccessibility protocol, providing reasonable default behavior in most cases,
Cocoa apps built with standard objects are automatically accessible. In general, you need to explicitly implement
the NSAccessibility protocol methods only if you subclass one of them, adding new behavior.
Figure 4-1 Universal Access system preference dialog
Supporting Common App Behaviors
Making Your App Accessible Enables Many Users
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
55The NSAccessibility informal protocol defines methods that Cocoa classes must implement to make
themselves available to an external assistive app. An assistive app interacts with your app to allow persons
with disabilities to use your app. For example, a person with a visual impairment could use an app to convert
menu items and button labels into speech and then perform actions by verbal command.
An accessible object is described by a set of attributes that define characteristics such as the object type, its
value, its size and position on the screen, and its place in the accessibility hierarchy. For some objects, the set
of attributes can include parameterized attributes. Parameterized attributes behave similar to a function by
allowing you to pass a parameter when requesting an attribute value.
For more information, see Accessibility Overview for OS X .
Provide User Preferences for Customization
Preferences are settings that enable users to customize the appearance or behavior of your software. The OS
X user defaultssystem lets you access and manage user preferences. You can use the defaultssystem to provide
reasonable initial values for app settings, as well as save and retrieve the user's own preference selections
across sessions. The Cocoa NSUserDefaults class provides programmatic access to the user defaults system.
The NSUserDefaults class provides convenience methodsfor accessing common typessuch asfloats, doubles,
integers, Booleans, and URLs. A default object must be a property list, that is, an instance of (or for collections
a combination of instances of): NSData, NSString, NSNumber, NSDate, NSArray, or NSDictionary. If you
want to store any other type of object, you should typically archive it to create an instance of NSData.
The user defaults system groups defaults into domains. Two of the domains are persistently saved in the user
defaults database: the app domain stores app-specific defaults, and the global domain stores defaults applicable
to all apps. In addition, the user defaults system provides three volatile domains whose values last only while
the user defaults object exists: the argument domain for defaults set from command-line arguments, the
languages domain containing defaults for a locale if one is specified, and the registration domain for “factory
defaults” registered by the app.
Your app uses the NSUserDefaults class to register default preferences, and typically it also provides a user
interface (a preferences panel) that enables the user to change those preferences. Preferences are stored in
the ~/Library/Preferences/ folder in a standard XML-format property list file as a set of key-value pairs.
The app-specific preferences property list is identified by the bundle identifier of the app.
For more details, see Preferences and Settings Programming Guide .
Supporting Common App Behaviors
Provide User Preferences for Customization
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
56Integrate Your App With Spotlight Search
Spotlight is a fast desktop search technology that allows users to organize and search for files based on
metadata. Metadata is data about a file, rather than the actual content stored in the file. Metadata can include
familiar information such as an asset’s author and modification date but it can also be keywords or other
information that is custom to a particular asset. For example, an image file might have metadata describing
the image’s dimensions and color model.
Developers of appsthatsave documentsto disk should consider providing Spotlightsupport by implementing
a metadata importer. A Spotlight metadata importer is a small plug-in bundle that you create to extract
information from files created by your app. Spotlight importers are used by the Spotlight server to gather
information about new and existing files, as illustrated in Figure 4-2.
Figure 4-2 Spotlight extracting metadata
Apple provides importers for many standard file types that the system uses, including RTF, JPEG, Mail, PDF and
MP3. However, if you define a custom document format, you must create a metadata importer for your own
content. Xcode provides a template for writing Spotlight importer plug-ins. For information about writing a
Spotlight importer, see Spotlight Importer Programming Guide .
In addition, you may wish to provide metadata search capability in your app. Cocoa provides the
NSMetadataQuery class which enables you to construct queries using a subset of the NSPredicate classes
and execute the queries asynchronously. For information about providing Spotlight search capability in your
app, see File Metadata Search Programming Guide .
For more information about Spotlight, see Spotlight Overview.
Supporting Common App Behaviors
Integrate Your App With Spotlight Search
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
57Use Services to Increase Your App’s Usefulness
Services allow a user to access the functionality of one app from within another app. An app that provides a
service advertises the operations it can perform on a particular type of data—for example, encryption of text,
optical character recognition of a bitmapped image, or generating text such as a message of the day. When
the user is manipulating that particular type of data in some app, the user can choose the appropriate item in
the Services menu to operate on the current data selection (or merely insert new data into the document).
See Services Implementation Guide for more information.
Optimize for High Resolution
High-resolution displays provide a rich visual experience, allowing users to see sharper text and more details
in photos than on standard-resolution displays. The high-resolution model for OS X enables your app to draw
into an abstract coordinate space called user space, without regard for the characteristics of the final drawing
destination—printer, display screen, bitmap, or PDF—and without regard to the resolution of the display.
OS X provides much support for high-resolution automatically. For example,standard AppKit views and controls
automatically render correctly at any resolution, vector-based content automatically uses additional pixels to
rendersharper lines and shapes, Cocoa text displayssharper in high-resolution, and AppKit automatically loads
high-resolution variants of your images.
You must do the following things to optimize your app for high-resolution:
● Provide properly-named high-resolution versions of your bitmapped images.
● Use high-resolution-savvy image-loading methods.
● Use the most recent APIs that support high resolution.
These techniques are described in the following sections.
Think About Points, Not Pixels
OS X refers to screen size in points, not pixels. A point is one unit in user space, prior to any transformations
on the space. Because, on a high-resolution display, there are four onscreen pixels for each point, points can
be expressed asfloating-point values. Valuesthat are integersin standard resolution,such as mouse coordinates,
are floating-point values on a high-resolution display, allowing for greater precision for such things as graphics
alignment.
Supporting Common App Behaviors
Use Services to Increase Your App’s Usefulness
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
58Your app draws to a view using points in user space. The window server composites drawing operations to an
offscreen buffer called the backing store. When it comes time to display the contents of the backing store
onscreen, the window server scales the content appropriately, mapping points to onscreen pixels. The result
is that if you draw the same content on two similar devices, and only one of them has a high-resolution screen,
the content appears to be about the same size on both devices, as shown in Figure 4-3.
Figure 4-3 Content appears the same size at standard resolution and high resolution
In some situations you may need to know how points are mapped to pixels, in which case you can obtain the
backing scale factor which is always either 1.0 or 2.0. The backing scale factor is a property of a layer, view,
or window, and it depends on the resolution of the underlying display device.
Provide High-Resolution Versions of Graphics
OS X automatically magnifies standard-resolution bitmapped images so they appear to the user in the correct
size, but they appear fuzzy. To avoid this problem, you must provide high-resolution versions of your graphics,
along with the standard-resolution versions in the app bundle. In addition to any images your app displays,
you must do this for your app’s icons and any custom controls, cursors, and other artwork.
High-resolution graphics must be scaled with twice as many pixels in each dimension to display the same size
in user space. For example, if you supply a standard-resolution image sized at 50x50 pixels, the high-resolution
version must be sized at 100x100 pixels.
For AppKit to recognize and load high-resolution versions of your graphics at appropriate times, you must
adopt the naming convention of appending @2x to the image name. For example, a standard-resolution image
named circle.png would have a high-resolution counterpart named circle@2x.png. Ideally, you can
package both image versions into a single TIFF file. This is most easily done by setting the Xcode option
Combine High Resolution Artwork to Yes in Target Build Settings under Deployment.
Supporting Common App Behaviors
Optimize for High Resolution
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
59You should create a set of icons for your app consisting of standard- and high-resolution versions of each icon
size—16x16, 32x32, 128x128, 256x256, 512x512 appending @2x to the icon image name which, by convention,
specifies the icon size in user space points. For example, an icon named icon_16x16.png would have a
high-resolution counterpart named icon_16x16@2x.png, the icon_32x32.png size would have a version
named icon_32x32@2x.png, and so on.
After you’ve created your set of app icons, place them in folder a named icon.iconset. Then you can use
the iconutil command-line tool to convert your .iconset folder into a single, deployment-ready,
high-resolution .icns file.
Use High-Resolution-Savvy Image-Loading Methods
If you follow the @2x naming convention, there are two methods available that load standard- and
high-resolution versions of an image into an NSImage object, whether or not you provide a multirepresentation
image file:
● The NSImage method imageNamed: finds resources located in the main application bundle, but not in
frameworks or plug-ins.
● The NSBundle method imageForResource: looks for resources outside as well as inside the main
bundle. Framework authors should use this method.
To create an NSImage object from a CGImageRef data type, use the initWithCGImage:size: method,
specifying the image size in points, not pixels. For custom cursors, you can pass a multirepresentation TIFF to
the NSCursor class method initWithImage:hotSpot:.
Use APIs That Support High Resolution
Cocoa apps must replace deprecated APIs with their newer counterparts. Apps that use older technologies
need to replace those technologies with newer ones. NSImage, NSView, NSWindow, and NSScreen classes
have methods that support high resolution, including methods for converting geometry, detecting scaling,
and aligning pixels. These APIs and deprecated technologiesthat youmust avoid are described in High Resolution
Guidelines for OS X .
You should also consider whether your app requires further adjustments for special scenarios, such as using
pixel-based technologies (OpenGL, Quartz bitmaps) or custom Core Animation layers. These advanced
optimization techniques are described in High Resolution Guidelines for OS X , which also provides much more
detailed information about high resolution.
Supporting Common App Behaviors
Optimize for High Resolution
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
60Prepare for Fast User Switching
Fast user switching lets users share a single machine without having to log out every time they want to access
their user account. Users share physical access to the machine, including the same keyboard, mouse, and
monitor. However, instead of logging out, a new user simply logs in and switches out the previous user.
Processes in a switched-out login session continue running as before. They can continue processing data,
communicating with the system, and drawing to the screen buffer as before. However, because they are
switched out, they do not receive input from the keyboard and mouse. Similarly, if they were to check, the
monitor would appear to be in sleep mode. As a result, it may benefit some apps to adjust their behavior while
in a switched-out state to avoid wasting system resources.
While fast userswitching is a convenient feature for users, it does provide several challengesfor app developers.
Apps that rely on exclusive access to certain resources may need to modify their behavior to live in a fast user
switching environment. For example, an app that stores temporary data in /tmp may run into problems when
a second instance running under a different user tries to modify the same files in that directory.
To support fast user switching, there are certain guidelines you should follow in developing your apps, most
of which describe safe waysto identify and share system resources. A summary of these guidelinesis asfollows:
●
Incorporate session ID information into the name of any entity that appears in a global namespace,
including file names, shared memory regions, semaphores, and named pipes.
Tagging such app-specific resources with a session ID is necessary to distinguish them from similar resources
created by apps in a different session. The Security layer of the system assigns a unique ID to each login
session. Incorporating thisID into cache file or temporary directory names can prevent namespace collisions
when creating these files. See “Supporting Fast User Switching” for information on how to get the session
ID.
● Don't assume you have exclusive access to any resource, especially TCP/IP ports and hardware devices.
● Don't assume there is only one instance of a per-user service running.
● Use file-level or range-level locks when accessing files.
● Accept and handle user switch notifications. See “User Switch Notifications” for more information.
For more information on user switching, see Multiple User Environment Programming Topics.
Supporting Common App Behaviors
Prepare for Fast User Switching
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
61Take Advantage of the Dock
The Dock is a desktop app designed to reduce desktop clutter, provide users with feedback about an app, and
allow users to switch easily between tasks. You can customize your app Dock tile by modifying the Dock icon
and adding items to the menu displayed for your app, and you can customize the Dock icon of a minimized
window.
An app’s Dock icon is, by default, the app’s icon. While your app is running, you can modify or replace the
default icon with another image that indicates the current state of your app. For example, the icon for Mail
changes when messages are waiting to be read. A badge—the red circle and number in the figure—is overlaid
onto Mail’s app icon to indicate the number of unread messages. The number changes each time Mail retrieves
more messages.
When the user holds the Control key down and clicks on a Dock tile, a menu appears. If your app does nothing
to customize the menu, the Dock tile’s menu contains a list of the app’s open documents (if any), followed by
the standard menu items Keep in Dock, Open at Login, Show in Finder, Hide, and Quit. You can add other
menu itemsto the Dock menu, eitherstatically by providing a custom menu nib file, or dynamically by overriding
the application delegate’s applicationDockMenu: method.
You can also customize a dock tile when your app is not currently running by creating a Dock tile plug-in that
can update the Dock tile icon and menu. For example, you may want to update the badge text to indicate that
new content will be available the next time the app is launched, and you may want to customize the app’s
Dock menu to deal with the new content.
For information explaining how to customize your app’s Dock icon and menu, see Dock Tile Programming
Guide .
Supporting Common App Behaviors
Take Advantage of the Dock
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
62Configuring your app properly is an important part of the development process. Mac apps use a structured
directory configuration to manage their code and resource files. And although most of the files are custom
and are there to support your app, some are required by the system or the App Store and must be configured
properly.
If you intend to sell your application through the Mac App Store or use iCloud storage, you also need to create
an explicit app ID, create provisioning profiles, and enable the correct entitlements for your application. These
procedures are explained in Tools Workflow Guide for Mac .
All of the requirements for preparing your app and distributing it on the App Store are described in the App
Store Resource Center.
Configuring Your Xcode Project
To develop a Mac app, you create an Xcode project. An Xcode Project is a repository for all the files, resources,
and information required to build your app (or one of a number of othersoftware products). A project contains
all the elements used to build your app and maintains the relationships between those elements. It contains
one or more targets, which specify how to build the software. A project defines default build settings for all
the targets in the project (each target can also specify its own build settings, which override the project build
settings).
You create a new project using the Xcode File > New > New Project menu command, which invokes the New
Project dialog. This dialog enables you to choose a template for your project, such as a Cocoa app, to name it,
and to locate it in your file system. The New Project dialog also provides options, so you can specify whether
your app uses the Cocoa document architecture or the Core Data framework. When you save your project,
Xcode lets you to create a local Git repository to enable source code control for your project.
If you have two or more closely related projects, you should create an Xcode Workspace and add your projects
to it. A workspace groups projects and other documents so you can work on them together. One project can
use the products and shared libraries of another project while building, and Xcode does indexing across the
entire workspace, extending the scope of content-aware features such as code completion.
Once you have created your project, you write and edit your code using the Xcode source editor. You also use
Xcode to build and debug your code, setting breakpoints, viewing the values of variables, stepping through
running code, and reviewing issues found during builds or code analysis.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
63
Build-Time Configuration DetailsWhen you create a new project, it includes one or more targets, where each target specifies one build product
and the instructions for how the product is to be built. Most developers never need to change the default of
the vast majority of build settings, but there are a few basic settings that you should check for each target,
such as the deployment target (platform, OS version, and architecture), main user interface, and linked
frameworks and libraries.
You also need to set up one or more schemes to specify the targets, build configuration, and executable
configuration to use when the product specified by the target is launched. You use the project editor and the
scheme editing dialog to edit build settings and control what happens when you build and run your code.
“Building and Running Your Code” explains how to work with Xcode build settings and schemes.
For more information about using Xcode to create, configure, build, and debug your project, as well as archiving
your program to package it for distribution or submission to the Mac App Store, see Xcode 4 User Guide .
The Information Property List File
An information property list (Info.plist) file contains essential runtime-configuration information for the app.
Xcode provides a version of this file with every Mac application project and configures it with several standard
keys. Although the default keys cover several important aspects of the app’s configuration, most apps require
additional keys to specify their configuration fully.
Build-Time Configuration Details
The Information Property List File
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
64To view the contents of your Info.plist file, select it in the Groups & Files pane. Xcode displays a property
list editor similar to the one in Figure 5-1 (which is from Xcode 3.2.5). You can use this window to edit the
property values and add new key-value pairs. By default, Xcode displays a more user-friendly version of each
key name. To see the key names that Xcode adds to the Info.plist file, Control-click an item in the editor
and choose Show Raw Keys/Values from the contextual menu that appears.
Figure 5-1 The information property list editor
Xcode automatically addssome important keysto the Info.plist file of all new projects and setstheir initial
values. However, there are several keys that Mac apps use commonly to configure their launch environment
and runtime behavior. Here are some keysthat you might want to add to your app’s Info.plist file specifically
for OS X:
● LSApplicationCategoryType (required for apps distributed using the App Store)
● CFBundleDisplayName
● LSHasLocalizedDisplayName
● NSHumanReadableCopyright
● LSMinimumSystemVersion
● UTExportedTypeDeclarations
● UTImportedTypeDeclarations
Build-Time Configuration Details
The Information Property List File
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
65For detailed information about these and other keys that you can include in your app’s Info.plist file, see
Information Property List Key Reference .
The OS X Application Bundle
When you build your Mac app, Xcode packages it as a bundle. A bundle is a directory in the file system that
groupsrelated resourcestogether in one place. A Mac app bundle contains a single Contents directory, inside
of which are additional files and directories with the app’s code, resources, and localized content. Table 5-1
liststhe contents of a typical Mac app bundle, which for demonstration purposesis called MyApp. This example
is for illustrative purposes only. Some of the files listed in this table may not appear in your own application
bundles.
Table 5-1 A typical application bundle
Files Description
The executable file containing your
app’s code. The name of this file is the
same as your app name minus the
.app extension.
This file is required.
Contents/MacOS/MyApp
Also known as the information property
list file, a file containing configuration
data for the app. The system uses this
data to determine how to interact with
the app at specific times.
This file is required. For more
information, see “The Information
Property List File” (page 64).
Contents/Info.plist
Build-Time Configuration Details
The OS X Application Bundle
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
66Files Description
The English version of the app’s main
nib file. This file contains the default
interface objectsto load at app launch
time. Typically, this nib file contains
the app’s menu bar and application
delegate object. It may also contain
other controller objects that should
always be available at launch time.
(The name of the main nib file can be
changed by assigning a different value
to the NSMainNibFile key in the
Info.plist file.)
Thisfile is optional but recommended.
For more information, see “The
Information Property List File” (page
64)
Contents/Resources/English.lproj/MainMenu.nib
Nonlocalized resources are placed at
the top level of the Resources
directory (sun.png represents a
nonlocalized image file in the
example). The app uses nonlocalized
resources when no localized version
of the same resource is provided. Thus,
you can use these files in situations
where the resource is the same for all
localizations.
Contents/Resources/sun.png (or other resource files)
Build-Time Configuration Details
The OS X Application Bundle
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
67Files Description
Localized resources are placed in
subdirectories with an ISO 639-1
language abbreviation for a name plus
an .lproj suffix. Although more
human readable names (such as
English.lproj, French.lproj, and
German.lproj) can be used for
directory names, the ISO 639-1 names
are preferred because they allow you
to include an ISO 3166-1 regional
designation. (For example, the
en_GB.lproj directory contains
resources localized for English as
spoken in Great Britain, the es.lproj
directory contains resources localized
for Spanish, and the de.lproj
directory contains resources localized
for German.)
Contents/Resources/en_GB.lproj
Contents/Resources/es.lproj
Contents/Resources/de.lproj
Other language-specific project directories
A Mac app should be internationalized and have a language.lproj directory for each language it supports.
Even if you provide localized versions of your resources, though, include a default version of these files at the
top level of your Resources directory. The default version is used when a specific localization is not available.
At runtime, you can access your app’s resource files from your code using the following steps:
1. Obtain a reference to your app’s main bundle object (typically using theNSBundle class).
2. Use the methods of the bundle object to obtain a file-system path to the desired resource file.
3. Open (or access) the file and use it.
You obtain a reference to your app’s main bundle using the mainBundle class method of NSBundle. The
pathForResource:ofType: method is one of several NSBundle methods that you can use to retrieve the
location of resources. The following example shows how to locate a file called sun.png and create an image
object using it. The first line getsthe bundle object and the path to the file. The second line creates an NSImage
object that you could use to display the image in your app.
NSString* imagePath = [[NSBundle mainBundle] pathForResource:@"sun" ofType:@"png"];
NSImage* sunImage = [[NSImage alloc] initWithContentsOfFile:imagePath];
Build-Time Configuration Details
The OS X Application Bundle
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
68Note: If you prefer to use Core Foundation to access bundles, you can obtain a CFBundleRef
opaque type using the CFBundleGetMainBundle function. You can then use that opaque type
plus the Core Foundation functions to locate any bundle resources.
For information on how to access and use resources in your app, see Resource Programming Guide . For more
information about the structure of a Mac app bundle, see Bundle Programming Guide .
Internationalizing Your App
The process of preparing a project to handle content in different languages is called internationalization. The
process of converting text, images, and other content into other languages is called localization. Project
resources that are candidates for localization include:
● Code-generated text, including locale-specific aspects of date, time, and number formatting
● Static text—for example, strings you specify programmatically and display in parts of your user interface
or an HTML file containing app help
●
Icons (including your app icon) and other images when those images either contain text or have some
culture-specific meaning
● Sound files containing spoken language
● Nib files
Build-Time Configuration Details
Internationalizing Your App
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
69Users select their preferred language from the Language and Text system preference, shown in Figure 5-2.
Figure 5-2 The Language preference view
Your application bundle can include multiple language-specific resource directories. The names of these
directories consist of three components: an ISO 639-1 language code, an optional ISO 3166-1 region code, and
a .lproj suffix. For example, to designate resourceslocalized to English, the bundle would be named en.lproj.
By convention, these directories are called lproj directories.
Note: You may use ISO 639-2 language codes instead of those defined by ISO 639-1. For more
information about language and region codes, see “Language and Locale Designations” in
Internationalization Programming Topics.
Each lproj directory contains a localized copy of the app’s resource files. When you request the path to a
resource file using the NSBundle class or the CFBundleRef opaque type, the path you get back automatically
reflects the resource for the user’s preferred language.
For more information about internationalization and how you support localized content in your Mac apps, see
Internationalization Programming Topics.
Build-Time Configuration Details
Internationalizing Your App
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
70As you develop your app and your project code stabilizes, you can begin performance tuning. Of course, you
want your app to launch and respond to the user’s commands as quickly as possible. A responsive app fits
easily into the user’s workflow and feels well crafted.
Speed Up Your App’s Launch Time
You can improve your app’s performance at launch time by minimizing or deferring work until after the launch
sequence has completed. The launch of an app provides users with the first impression of your app, and it’s
something they see on a regular basis.
Your overriding goal during launch should be to display the app’s menu bar and main window and then start
responding to user commands as quickly as possible. Making your app responsive to commands quickly
provides a better experience for the user. The following sections provide some general tips on how to make
your app launch faster.
Delay Initialization Code
Many apps spend a lot of time initializing code that isn’t used until much later. Delaying the initialization of
subsystems that are not immediately needed can speed up your launch time considerably. Remember that
the goal is to display your app interface quickly, so try to initialize only the subsystems related to that goal
initially.
Once you have posted your interface, your app can continue to initialize additional subsystems as needed.
However, remember that just because your app is able to process commands does not mean you need all of
that code right away. The preferred way of initializing subsystems is on an as-needed basis. Wait until the user
executes a command that requires a particular subsystem and then initialize it. That way, if the user never
executes the command, you will not have wasted any time running the code to prepare for it.
Avoid putting a lot of extraneous initialization code in your awakeFromNib methods. The system calls the
awakeFromNib method of your main nib file before your app enters its main event loop. Use that method to
initialize the objects in that nib and to prepare your app interface. For all other initialization, use the
applicationDidFinishLaunching: method of your NSApplicationDelegate object instead. For more
information on nib files and how they are loaded, see Resource Programming Guide .
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
71
Tuning for Performance and ResponsivenessSimplify Your Main Nib File
Loading a nib file is an expensive process that can slow down your app launch time if you are not careful.
When a nib file isloaded, all of the objectsin that file are instantiated and made ready for use. The more objects
you include in your app’s main nib, the more time it takes to load that file and launch your app.
The instantiation process for objects in a nib file requires that any frameworks used by those objects must
themselves reside in memory. Thus loading a nib for a Cocoa app would likely require the loading of both the
AppKit and Foundation frameworks, if they were not already resident in memory. Similarly, if you declare a
custom class in your main nib file and that class relies on other frameworks, the system must load those
frameworks as well.
When designing your app’s main nib file, you should include only those objects needed to display your app’s
initial user interface. Usually, this would involve just your app’s menu bar and initial window. For any custom
classes you include in the nib, make sure their initialization code is as minimal as possible. Defer any
time-consuming operations or memory allocations until after the class is instantiated.
Minimize Global Variables
For both apps and frameworks, be careful not to declare global variables that require significant amounts of
initialization. The system initializes global variables before calling your app’s main routine. If you use a global
variable to declare an object, the system must call the constructor or initialization method for that object during
launch time. In general, it’s best to avoid declaring objects as global variables altogether when you can use a
pointer instead.
If you are implementing a framework or any type of reusable code module, you should also minimize the
number of global variables you declare. Each app that links to a framework acquires a copy of that framework’s
global variables. These variables might require several pages of virtual memory, which then increases the
memory footprint of the app. An increased memory footprint can lead to paging in the app, which has a
tremendous impact on performance.
One way to minimize the global variables in a framework is to store the variables in a malloc-allocated block
of memory instead. In this technique, you access the variables through a pointer to the memory, which you
store as a global variable. Another advantage of this technique is that it allows you to defer the creation of any
global variables until the first time they are actually used. See “Tips for Allocating Memory” in Memory Usage
Performance Guidelines for more information.
Tuning for Performance and Responsiveness
Speed Up Your App’s Launch Time
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
72Minimize File Access at Launch Time
Accessing a file is one of the slowest operations performed on a computer, so it is important that you do it as
little as possible, especially at launch time. There is always some file access that must occur at launch time,
such as loading your executable code and reading in your main nib file, but reducing your initial dependence
on startup files can provide significant speed improvements.
If you can delay the reading of a file until after launch time, do so. The following list includes some files whose
contents you may not need until after launch:
● Frameworks not used directly by your app—Avoid calling code that uses nonessential frameworks until
after launch.
● Nib files whose contents are not displayed immediately—Make sure your nib files and awakeFromNib:
code are not doing too much at launch time. See “Simplify Your Main Nib File” (page 72) for more
information.
● User preference files—User preferences may not be local so read them later if you can.
● Font files—Consider delaying font initialization until after the app has launched.
● Network files—Avoid reading files located on the network if at all possible.
If you must read a file at launch time, do so only once. If you need multiple pieces of data from the same file,
such as from a preferences file, consider reading all of the data once rather than accessing the file multiple
times.
Don’t Block the Main Thread
The main thread is where your app handles user events and other input, so you should keep it free as much
as possible to be responsive to the user. In particular, never use the main thread to perform long-running or
potentially unbounded tasks, such as tasks that require network access. Instead, always move those tasks onto
background threads. The preferred way to do so is to use Grand Central Dispatch (GCD) or operation objects
to perform tasks asynchronously.
For more information about doing work on background threads, see Concurrency Programming Guide .
Decrease Your App’s Code Size
In the context of performance, the more memory your app occupies, the more inefficient it is. More memory
means more memory allocations, more code, and a greater potential for paging.
Tuning for Performance and Responsiveness
Don’t Block the Main Thread
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
73Reducing your code footprint is not just a matter of turning on code optimizations in your compiler, although
that does help. You can also reduce your code footprint by organizing your code so that only the minimum
set of required functions is in memory at any given time. You implement this optimization by profiling your
code.
See “Memory Instruments” in Instruments User Guide for information about profiling your app’s memory
allocations.
Compiler-Level Optimizations
The Xcode compiler supports optimization options that let you choose whether you prefer a smaller binary
size, faster code, or faster build times. For new projects, Xcode automatically disables optimizations for the
debug build configuration and selects the Fastest, Smallest option for the release build configuration. Code
optimizations of any kind result in slower build times because of the extra work involved in the optimization
process. If your code is changing, as it does during the development cycle, you do not want optimizations
enabled. As you near the end of your development cycle, though, the release build configuration can give you
an indication of the size of your finished product, so the Fastest, Smallest option is appropriate.
Table 6-1 lists the optimization levels available in Xcode. When you select one of these options, Xcode passes
the appropriate flags to the compiler for the given group or files. These options are available at the target level
or as part of a build configuration. See the Xcode Build System Guide for information on working with build
settings for your project.
Table 6-1 Compiler optimization options
Xcode setting Description
The compiler does not attempt to optimize code. Use this option during development
when you are focused on solving logic errors and need a fast compile time. Do not
use this option for shipping your executable.
None
The compiler performs simple optimizations to boost code performance while
minimizing the impact to compile time. This option also uses more memory during
compilation.
Fast
The compiler performs nearly all supported optimizations that do not require a
space-time tradeoff. The compiler does not perform loop unrolling or function inlining
with this option. This option increases both compilation time and the performance
of generated code.
Faster
The compiler performs all optimizations in an attempt to improve the speed of the
generated code. This option can increase the size of generated code as the compiler
performs aggressive inlining of functions.
This option is generally not recommended.
Fastest
Tuning for Performance and Responsiveness
Decrease Your App’s Code Size
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
74Xcode setting Description
The compiler performs all optimizations that do not typically increase code size. This
is the preferred option for shipping code because it gives your executable a smaller
memory footprint.
Fastest,
Smallest
As with any performance enhancement, do not make assumptions about which option will give you the best
results. You should always measure the results of each optimization you try. For example, the Fastest option
might generate extremely fast code for a particular module, but it usually doesso at the expense of executable
size. Any speed advantages you gain from the code generation are easily lost if the code needs to be paged
in from disk at runtime.
Use Core Data for Large Data Sets
If your app manipulates large amounts of structured data, store it in a Core Data persistent store or in a SQLite
database instead of in a flat file. Both Core Data and SQLite provide efficient ways to manage large data sets
without requiring the entire set to be in memory all at once. Use SQLite if you deal with low-level data structures,
or an existing SQLite database. Core Data provides a high-level abstraction for efficient object-graph
management with an Objective-C interface; it is, however, an advanced framework and you shouldn't use it
until you have gained adequate experience.
For more information about Core Data, see Core Data Programming Guide and Optimizing Core Data with
Instruments.
Eliminate Memory Leaks
Your app should not have any memory leaks. You can use the Instruments app to track down leaks in your
code, both in the simulator and on actual devices. See “Memory Instruments” in Instruments User Guide for
information about finding memory leaks.
Dead Strip Your Code
For statically linked executables, dead-code stripping is the process of removing unreferenced code from the
executable file. If the code is unreferenced, it must not be used and therefore is not needed in the executable
file. Removing dead code reduces the size of your executable and can help reduce paging.
To enable dead-code stripping in Xcode, in the Linking group of Build Settings, set the Dead Code Stripping
option to Yes.
Tuning for Performance and Responsiveness
Decrease Your App’s Code Size
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
75Strip Symbol Information
Debugging symbols and dynamic-binding information can take up a lot of space and comprise a large
percentage of your executable’s size. Before shipping your code, you should strip out all unneeded symbols.
To strip debugging symbols from your executable, change the Xcode compiler code generation Generate
Debug Symbols option to No. You can also generate debugging symbols on a target-by-target basis if you
prefer. See the Xcode Help for more information on build configurations and target settings.
Tuning for Performance and Responsiveness
Decrease Your App’s Code Size
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
76This table describes the changes to Mac App Programming Guide .
Date Notes
Added a short section on adopting iCloud in a Mac app, “Integrating
iCloud Support Into Your App” (page 30).
2012-07-23
Removed the chapter on iCloud, which is superseded by iCloud Design
Guide .
Rewrote section about supporting high resolution: “Optimize for High
Resolution” (page 58).
Summarized chapter on document-based apps, added iCloud chapter,
and revised sandbox information. Made minor technical and editorial
revisions throughout. Changed title from OS X Application Programming
Guide.
2012-01-09
2011-06-27 New document describing the development process for Mac apps.
2012-07-23 | © 2012 Apple Inc. All Rights Reserved.
77
Document Revision HistoryApple Inc.
© 2012 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Bonjour, Cocoa, Finder,
Instruments, iPhoto, iTunes, Keychain, Mac,
Macintosh, Objective-C, OS X, Quartz, QuickDraw,
Sand, Spotlight, Time Machine, and Xcode are
trademarks of Apple Inc., registered in the U.S.
and other countries.
Launchpad is a trademark of Apple Inc.
iCloud is a service mark of Apple Inc., registered
in the U.S. and other countries.
App Store and Mac App Store are service marks
of Apple Inc.
OpenGL is a registered trademark of Silicon
Graphics, Inc.
UNIX is a registered trademark of The Open
Group.
iOS is a trademark or registered trademark of
Cisco in the U.S. and other countries and is used
under license.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Objective-C Runtime
Programming GuideContents
Introduction 5
Organization of This Document 5
See Also 5
Runtime Versions and Platforms 7
Legacy and Modern Versions 7
Platforms 7
Interacting with the Runtime 8
Objective-C Source Code 8
NSObject Methods 8
Runtime Functions 9
Messaging 10
The objc_msgSend Function 10
Using Hidden Arguments 13
Getting a Method Address 14
Dynamic Method Resolution 16
Dynamic Method Resolution 16
Dynamic Loading 17
Message Forwarding 18
Forwarding 18
Forwarding and Multiple Inheritance 20
Surrogate Objects 21
Forwarding and Inheritance 21
Type Encodings 24
Declared Properties 28
Property Type and Functions 28
Property Type String 29
Property Attribute Description Examples 30
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
2Document Revision History 33
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
3
ContentsFigures and Tables
Messaging 10
Figure 3-1 Messaging Framework 12
Message Forwarding 18
Figure 5-1 Forwarding 20
Type Encodings 24
Table 6-1 Objective-C type encodings 24
Table 6-2 Objective-C method encodings 26
Declared Properties 28
Table 7-1 Declared property type encodings 30
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
4The Objective-C language defers as many decisions as it can from compile time and link time to runtime.
Whenever possible, it does things dynamically. This means that the language requires not just a compiler, but
also a runtime system to execute the compiled code. The runtime system acts as a kind of operating system
for the Objective-C language; it’s what makes the language work.
This document looks at the NSObject class and how Objective-C programs interact with the runtime system.
In particular, it examines the paradigms for dynamically loading new classes at runtime, and forwarding
messages to other objects. It also provides information about how you can find information about objects
while your program is running.
You should read this document to gain an understanding of how the Objective-C runtime system works and
how you can take advantage of it. Typically, though, there should be little reason for you to need to know and
understand this material to write a Cocoa application.
Organization of This Document
This document has the following chapters:
●
“Runtime Versions and Platforms” (page 7)
●
“Interacting with the Runtime” (page 8)
●
“Messaging” (page 10)
●
“Dynamic Method Resolution” (page 16)
●
“Message Forwarding” (page 18)
●
“Type Encodings” (page 24)
●
“Declared Properties” (page 28)
See Also
Objective-C Runtime Reference describes the data structures and functions of the Objective-C runtime support
library. Your programs can use these interfaces to interact with the Objective-C runtime system. For example,
you can add classes or methods, or obtain a list of all class definitions for loaded classes.
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
5
IntroductionThe Objective-C Programming Language describes the Objective-C language.
Objective-C Release Notes describes some of the changes in the Objective-C runtime in the latest release of OS
X.
Introduction
See Also
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
6There are different versions of the Objective-C runtime on different platforms.
Legacy and Modern Versions
There are two versions of the Objective-C runtime—“modern” and “legacy”. The modern version wasintroduced
with Objective-C 2.0 and includes a number of new features. The programming interface for the legacy version
of the runtime is described in Objective-C 1 Runtime Reference ; the programming interface for the modern
version of the runtime is described in Objective-C Runtime Reference .
The most notable new feature is that instance variables in the modern runtime are “non-fragile”:
●
In the legacy runtime, if you change the layout of instance variables in a class, you must recompile classes
that inherit from it.
●
In the modern runtime, if you change the layout of instance variables in a class, you do not have to
recompile classes that inherit from it.
In addition, the modern runtime supports instance variable synthesis for declared properties (see Declared
Properties in The Objective-C Programming Language ).
Platforms
iPhone applications and 64-bit programs on OS X v10.5 and later use the modern version of the runtime.
Other programs (32-bit programs on OS X desktop) use the legacy version of the runtime.
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
7
Runtime Versions and PlatformsObjective-C programs interact with the runtime system at three distinct levels: through Objective-C source
code; through methods defined in the NSObject class of the Foundation framework; and through direct calls
to runtime functions.
Objective-C Source Code
For the most part, the runtime system works automatically and behind the scenes. You use it just by writing
and compiling Objective-C source code.
When you compile code containing Objective-C classes and methods, the compiler creates the data structures
and function calls that implement the dynamic characteristics of the language. The data structures capture
information found in class and category definitions and in protocol declarations; they include the class and
protocol objects discussed in Defining a Class and Protocols in The Objective-C Programming Language , as well
as method selectors, instance variable templates, and other information distilled from source code. The principal
runtime function is the one that sends messages, as described in “Messaging” (page 10). It’s invoked by
source-code message expressions.
NSObject Methods
Most objects in Cocoa are subclasses of the NSObject class, so most objects inherit the methods it defines.
(The notable exception is the NSProxy class; see “Message Forwarding” (page 18) for more information.) Its
methods therefore establish behaviors that are inherent to every instance and every class object. However, in
a few cases, the NSObject class merely defines a template for how something should be done; it doesn’t
provide all the necessary code itself.
For example, the NSObject class defines a description instance method that returns a string describing
the contents of the class. This is primarily used for debugging—the GDB print-object command prints the
string returned from this method. NSObject’s implementation of this method doesn’t know what the class
contains,so it returns a string with the name and address of the object. Subclasses of NSObject can implement
this method to return more details. For example, the Foundation class NSArray returns a list of descriptions
of the objects it contains.
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
8
Interacting with the RuntimeSome of the NSObject methodssimply query the runtime system for information. These methods allow objects
to perform introspection. Examples of such methods are the class method, which asks an object to identify
its class; isKindOfClass: and isMemberOfClass:, which test an object’s position in the inheritance
hierarchy; respondsToSelector:, which indicates whether an object can accept a particular message;
conformsToProtocol:, which indicates whether an object claims to implement the methods defined in a
specific protocol; and methodForSelector:, which provides the address of a method’s implementation.
Methods like these give an object the ability to introspect about itself.
Runtime Functions
The runtime system is a dynamic shared library with a public interface consisting of a set of functions and data
structuresin the header fileslocated within the directory /usr/include/objc. Many of these functions allow
you to use plain C to replicate what the compiler does when you write Objective-C code. Others form the basis
for functionality exported through the methods of the NSObject class. These functions make it possible to
develop other interfacesto the runtime system and produce toolsthat augment the development environment;
they’re not needed when programming in Objective-C. However, a few of the runtime functions might on
occasion be useful when writing an Objective-C program. All of these functions are documented in Objective-C
Runtime Reference .
Interacting with the Runtime
Runtime Functions
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
9This chapter describes how the message expressions are converted into objc_msgSend function calls, and
how you can refer to methods by name. It then explains how you can take advantage of objc_msgSend, and
how—if you need to—you can circumvent dynamic binding.
The objc_msgSend Function
In Objective-C, messages aren’t bound to method implementations until runtime. The compiler converts a
message expression,
[receiver message]
into a call on a messaging function, objc_msgSend. This function takes the receiver and the name of the
method mentioned in the message—that is, the method selector—as its two principal parameters:
objc_msgSend(receiver, selector)
Any arguments passed in the message are also handed to objc_msgSend:
objc_msgSend(receiver, selector, arg1, arg2, ...)
The messaging function does everything necessary for dynamic binding:
●
It first finds the procedure (method implementation) that the selector refers to. Since the same method
can be implemented differently by separate classes, the precise procedure that it finds depends on the
class of the receiver.
●
It then calls the procedure, passing it the receiving object (a pointer to its data), along with any arguments
that were specified for the method.
● Finally, it passes on the return value of the procedure as its own return value.
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
10
MessagingNote: The compiler generates calls to the messaging function. You should never call it directly in
the code you write.
The key to messaging lies in the structures that the compiler builds for each class and object. Every class
structure includes these two essential elements:
● A pointer to the superclass.
● A class dispatch table. This table has entries that associate method selectors with the class-specific
addresses of the methods they identify. The selector for the setOrigin:: method is associated with the
address of (the procedure that implements) setOrigin::, the selector for the display method is
associated with display’s address, and so on.
When a new object is created, memory for it is allocated, and its instance variables are initialized. First among
the object’s variables is a pointer to its class structure. This pointer, called isa, gives the object access to its
class and, through the class, to all the classes it inherits from.
Messaging
The objc_msgSend Function
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
11Note: While not strictly a part of the language, the isa pointer is required for an object to work
with the Objective-C runtime system. An object needsto be “equivalent” to a struct objc_object
(defined in objc/objc.h) in whatever fieldsthe structure defines. However, you rarely, if ever, need
to create your own root object, and objects that inherit from NSObject or NSProxy automatically
have the isa variable.
These elements of class and object structure are illustrated in Figure 3-1.
Figure 3-1 Messaging Framework
. . .
superclass
selector...address
selector...address
selector...address
. . .
superclass
selector...address
selector...address
selector...address
. . .
superclass
selector...address
selector...address
selector...address
isa
instance variable
instance variable
. . .
The object’s superclass
The root class (NSObject)
The object’s class
Messaging
The objc_msgSend Function
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
12When a message is sent to an object, the messaging function follows the object’s isa pointer to the class
structure where it looks up the method selector in the dispatch table. If it can’t find the selector there,
objc_msgSend followsthe pointer to the superclass and triesto find the selector in its dispatch table. Successive
failures cause objc_msgSend to climb the class hierarchy until it reaches the NSObject class. Once it locates
the selector, the function callsthe method entered in the table and passesit the receiving object’s data structure.
This is the way that method implementations are chosen at runtime—or, in the jargon of object-oriented
programming, that methods are dynamically bound to messages.
To speed the messaging process, the runtime system caches the selectors and addresses of methods as they
are used. There’s a separate cache for each class, and it can contain selectors for inherited methods as well as
for methods defined in the class. Before searching the dispatch tables, the messaging routine first checks the
cache of the receiving object’s class(on the theory that a method that was used once may likely be used again).
If the method selector is in the cache, messaging is only slightly slower than a function call. Once a program
has been running long enough to “warm up” its caches, almost all the messagesitsendsfind a cached method.
Caches grow dynamically to accommodate new messages as the program runs.
Using Hidden Arguments
When objc_msgSend finds the procedure that implements a method, it calls the procedure and passes it all
the arguments in the message. It also passes the procedure two hidden arguments:
● The receiving object
● The selector for the method
These arguments give every method implementation explicit information about the two halves of the message
expression that invoked it. They’re said to be “hidden” because they aren’t declared in the source code that
defines the method. They’re inserted into the implementation when the code is compiled.
Although these arguments aren’t explicitly declared, source code can still refer to them (just as it can refer to
the receiving object’s instance variables). A method refers to the receiving object as self, and to its own
selector as _cmd. In the example below, _cmd refers to the selector for the strange method and self to the
object that receives a strange message.
- strange
{
id target = getTheReceiver();
SEL method = getTheMethod();
Messaging
Using Hidden Arguments
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
13if ( target == self || method == _cmd )
return nil;
return [target performSelector:method];
}
self is the more useful of the two arguments. It is, in fact, the way the receiving object’s instance variables
are made available to the method definition.
Getting a Method Address
The only way to circumvent dynamic binding is to get the address of a method and call it directly as if it were
a function. This might be appropriate on the rare occasions when a particular method will be performed many
times in succession and you want to avoid the overhead of messaging each time the method is performed.
With a method defined in the NSObject class, methodForSelector:, you can ask for a pointer to the
procedure that implements a method, then use the pointer to call the procedure. The pointer that
methodForSelector: returns must be carefully cast to the proper function type. Both return and argument
types should be included in the cast.
The example below shows how the procedure that implements the setFilled: method might be called:
void (*setter)(id, SEL, BOOL);
int i;
setter = (void (*)(id, SEL, BOOL))[target
methodForSelector:@selector(setFilled:)];
for ( i = 0; i < 1000, i++ )
setter(targetList[i], @selector(setFilled:), YES);
The first two arguments passed to the procedure are the receiving object (self) and the method selector
(_cmd). These arguments are hidden in method syntax but must be made explicit when the method is called
as a function.
Using methodForSelector: to circumvent dynamic binding saves most of the time required by messaging.
However, the savings will be significant only where a particular message is repeated many times, as in the for
loop shown above.
Messaging
Getting a Method Address
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
14Note that methodForSelector: is provided by the Cocoa runtime system; it’s not a feature of the Objective-C
language itself.
Messaging
Getting a Method Address
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
15This chapter describes how you can provide an implementation of a method dynamically.
Dynamic Method Resolution
There are situations where you might want to provide an implementation of a method dynamically. For example,
the Objective-C declared propertiesfeature (see Declared Properties in The Objective-C Programming Language )
includes the @dynamic directive:
@dynamic propertyName;
which tells the compiler that the methods associated with the property will be provided dynamically.
You can implement the methods resolveInstanceMethod: and resolveClassMethod: to dynamically
provide an implementation for a given selector for an instance and class method respectively.
An Objective-C method is simply a C function that take at least two arguments—self and _cmd. You can add
a function to a class as a method using the function class_addMethod. Therefore, given the following function:
void dynamicMethodIMP(id self, SEL _cmd) {
// implementation ....
}
you can dynamically add it to a class as a method (called resolveThisMethodDynamically) using
resolveInstanceMethod: like this:
@implementation MyClass
+ (BOOL)resolveInstanceMethod:(SEL)aSEL
{
if (aSEL == @selector(resolveThisMethodDynamically)) {
class_addMethod([self class], aSEL, (IMP) dynamicMethodIMP, "v@:");
return YES;
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
16
Dynamic Method Resolution}
return [super resolveInstanceMethod:aSEL];
}
@end
Forwarding methods (as described in “Message Forwarding” (page 18)) and dynamic method resolution are,
largely, orthogonal. A class has the opportunity to dynamically resolve a method before the forwarding
mechanism kicksin. If respondsToSelector: or instancesRespondToSelector: isinvoked, the dynamic
method resolver is given the opportunity to provide an IMP for the selector first. If you implement
resolveInstanceMethod: but want particular selectors to actually be forwarded via the forwarding
mechanism, you return NO for those selectors.
Dynamic Loading
An Objective-C program can load and link new classes and categories while it’s running. The new code is
incorporated into the program and treated identically to classes and categories loaded at the start.
Dynamic loading can be used to do a lot of different things. For example, the various modules in the System
Preferences application are dynamically loaded.
In the Cocoa environment, dynamic loading is commonly used to allow applications to be customized. Others
can write modules that your program loads at runtime—much as Interface Builder loads custom palettes and
the OS X System Preferences application loads custom preference modules. The loadable modules extend
what your application can do. They contribute to it in ways that you permit but could not have anticipated or
defined yourself. You provide the framework, but others provide the code.
Although there is a runtime function that performs dynamic loading of Objective-C modules in Mach-O files
(objc_loadModules, defined in objc/objc-load.h), Cocoa’s NSBundle class provides a significantly more
convenient interface for dynamic loading—one that’s object-oriented and integrated with related services.
See the NSBundle classspecification in the Foundation framework reference for information on the NSBundle
class and its use. See OS X ABI Mach-O File Format Reference for information on Mach-O files.
Dynamic Method Resolution
Dynamic Loading
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
17Sending a message to an object that does not handle that message is an error. However, before announcing
the error, the runtime system gives the receiving object a second chance to handle the message.
Forwarding
If you send a message to an object that does not handle that message, before announcing an error the runtime
sends the object a forwardInvocation: message with an NSInvocation object as its sole argument—the
NSInvocation object encapsulates the original message and the arguments that were passed with it.
You can implement a forwardInvocation: method to give a default response to the message, or to avoid
the error in some other way. As its name implies, forwardInvocation: is commonly used to forward the
message to another object.
To see the scope and intent of forwarding, imagine the following scenarios: Suppose, first, that you’re designing
an object that can respond to a message called negotiate, and you want itsresponse to include the response
of another kind of object. You could accomplish this easily by passing a negotiate message to the other
object somewhere in the body of the negotiate method you implement.
Take this a step further, and suppose that you want your object’s response to a negotiate message to be
exactly the response implemented in another class. One way to accomplish this would be to make your class
inherit the method from the other class. However, it might not be possible to arrange things this way. There
may be good reasons why your class and the class that implements negotiate are in different branches of
the inheritance hierarchy.
Even if your class can’t inherit the negotiate method, you can still “borrow” it by implementing a version of
the method that simply passes the message on to an instance of the other class:
- negotiate
{
if ( [someOtherObject respondsTo:@selector(negotiate)] )
return [someOtherObject negotiate];
return self;
}
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
18
Message ForwardingThis way of doing things could get a little cumbersome, especially if there were a number of messages you
wanted your object to pass on to the other object. You’d have to implement one method to cover each method
you wanted to borrow from the other class. Moreover, it would be impossible to handle cases where you didn’t
know, at the time you wrote the code, the full set of messages you might want to forward. That set might
depend on events at runtime, and it might change as new methods and classes are implemented in the future.
The second chance offered by a forwardInvocation: message provides a less ad hoc solution to this
problem, and one that’s dynamic rather than static. It workslike this: When an object can’t respond to a message
because it doesn’t have a method matching the selector in the message, the runtime system informsthe object
by sending it a forwardInvocation: message. Every object inherits a forwardInvocation: method from
the NSObject class. However, NSObject’s version of the method simply invokes
doesNotRecognizeSelector:. By overriding NSObject’s version and implementing your own, you can
take advantage of the opportunity that the forwardInvocation: message provides to forward messages
to other objects.
To forward a message, all a forwardInvocation: method needs to do is:
● Determine where the message should go, and
● Send it there with its original arguments.
The message can be sent with the invokeWithTarget: method:
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
if ([someOtherObject respondsToSelector:
[anInvocation selector]])
[anInvocation invokeWithTarget:someOtherObject];
else
[super forwardInvocation:anInvocation];
}
The return value of the message that’s forwarded is returned to the original sender. All types of return values
can be delivered to the sender, including ids, structures, and double-precision floating-point numbers.
A forwardInvocation: method can act as a distribution center for unrecognized messages, parceling them
out to different receivers. Or it can be a transfer station, sending all messages to the same destination. It can
translate one message into another, or simply “swallow” some messages so there’s no response and no error.
A forwardInvocation: method can also consolidate several messages into a single response. What
forwardInvocation: doesis up to the implementor. However, the opportunity it providesfor linking objects
in a forwarding chain opens up possibilities for program design.
Message Forwarding
Forwarding
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
19Note: The forwardInvocation: method gets to handle messages only if they don’t invoke an
existing method in the nominal receiver. If, for example, you want your object to forward negotiate
messages to another object, it can’t have a negotiate method of its own. If it does, the message
will never reach forwardInvocation:.
For more information on forwarding and invocations, see the NSInvocation class specification in the
Foundation framework reference.
Forwarding and Multiple Inheritance
Forwarding mimics inheritance, and can be used to lend some of the effects of multiple inheritance to
Objective-C programs. As shown in Figure 5-1 (page 20), an object that responds to a message by forwarding
it appears to borrow or “inherit” a method implementation defined in another class.
Figure 5-1 Forwarding
isa
. . .
– forwardInvocation: – negotiate
negotiate isa
. . .
Warrior Diplomat
In this illustration, an instance of the Warrior class forwards a negotiate message to an instance of the
Diplomat class. The Warrior will appear to negotiate like a Diplomat. It will seem to respond to the negotiate
message, and for all practical purposes it does respond (although it’s really a Diplomat that’s doing the work).
The object that forwards a message thus“inherits” methodsfrom two branches of the inheritance hierarchy—its
own branch and that of the object that responds to the message. In the example above, it appears as if the
Warrior class inherits from Diplomat as well as its own superclass.
Message Forwarding
Forwarding and Multiple Inheritance
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
20Forwarding provides most of the features that you typically want from multiple inheritance. However, there’s
an important difference between the two: Multiple inheritance combines different capabilities in a single
object. It tends toward large, multifaceted objects. Forwarding, on the other hand, assigns separate
responsibilitiesto disparate objects. It decomposes problemsinto smaller objects, but associatesthose objects
in a way that’s transparent to the message sender.
Surrogate Objects
Forwarding not only mimics multiple inheritance, it also makes it possible to develop lightweight objects that
represent or “cover” more substantial objects. The surrogate standsin for the other object and funnels messages
to it.
The proxy discussed in “Remote Messaging” in The Objective-C Programming Language is such a surrogate. A
proxy takes care of the administrative details of forwarding messages to a remote receiver, making sure
argument values are copied and retrieved across the connection, and so on. But it doesn’t attempt to do much
else; it doesn’t duplicate the functionality of the remote object but simply gives the remote object a local
address, a place where it can receive messages in another application.
Other kinds of surrogate objects are also possible. Suppose, for example, that you have an object that
manipulates a lot of data—perhaps it creates a complicated image or reads the contents of a file on disk.
Setting this object up could be time-consuming, so you prefer to do it lazily—when it’s really needed or when
system resources are temporarily idle. At the same time, you need at least a placeholder for this object in order
for the other objects in the application to function properly.
In this circumstance, you could initially create, not the full-fledged object, but a lightweight surrogate for it.
This object could do some things on its own, such as answer questions about the data, but mostly it would
just hold a place for the larger object and, when the time came, forward messages to it. When the surrogate’s
forwardInvocation: method first receives a message destined for the other object, it would ensure that
the object existed and would create it if it didn’t. All messages for the larger object go through the surrogate,
so, as far as the rest of the program is concerned, the surrogate and the larger object would be the same.
Forwarding and Inheritance
Although forwarding mimics inheritance, the NSObject class never confuses the two. Methods like
respondsToSelector: and isKindOfClass: look only at the inheritance hierarchy, never at the forwarding
chain. If, for example, a Warrior object is asked whether it responds to a negotiate message,
if ( [aWarrior respondsToSelector:@selector(negotiate)] )
...
Message Forwarding
Surrogate Objects
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
21the answer is NO, even though it can receive negotiate messages without error and respond to them, in a
sense, by forwarding them to a Diplomat. (See Figure 5-1 (page 20).)
In many cases, NO is the right answer. But it may not be. If you use forwarding to set up a surrogate object or
to extend the capabilities of a class, the forwarding mechanism should probably be astransparent asinheritance.
If you want your objects to act as if they truly inherited the behavior of the objects they forward messages to,
you’ll need to re-implement the respondsToSelector: and isKindOfClass: methods to include your
forwarding algorithm:
- (BOOL)respondsToSelector:(SEL)aSelector
{
if ( [super respondsToSelector:aSelector] )
return YES;
else {
/* Here, test whether the aSelector message can *
* be forwarded to another object and whether that *
* object can respond to it. Return YES if it can. */
}
return NO;
}
In addition to respondsToSelector: and isKindOfClass:,the instancesRespondToSelector:method
should also mirror the forwarding algorithm. If protocols are used, the conformsToProtocol: method should
likewise be added to the list. Similarly, if an object forwards any remote messages it receives, it should have a
version of methodSignatureForSelector: that can return accurate descriptions of the methods that
ultimately respond to the forwarded messages; for example, if an object is able to forward a message to its
surrogate, you would implement methodSignatureForSelector: as follows:
- (NSMethodSignature*)methodSignatureForSelector:(SEL)selector
{
NSMethodSignature* signature = [super methodSignatureForSelector:selector];
if (!signature) {
signature = [surrogate methodSignatureForSelector:selector];
}
return signature;
}
Message Forwarding
Forwarding and Inheritance
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
22You might consider putting the forwarding algorithm somewhere in private code and have all these methods,
forwardInvocation: included, call it.
Note: Thisis an advanced technique,suitable only forsituations where no othersolution is possible.
It is not intended as a replacement for inheritance. If you must make use of this technique, make
sure you fully understand the behavior of the class doing the forwarding and the class you’re
forwarding to.
The methods mentioned in this section are described in the NSObject class specification in the Foundation
framework reference. For information on invokeWithTarget:, see the NSInvocation class specification
in the Foundation framework reference.
Message Forwarding
Forwarding and Inheritance
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
23To assist the runtime system, the compiler encodes the return and argument types for each method in a
character string and associates the string with the method selector. The coding scheme it uses is also useful
in other contexts and so is made publicly available with the @encode() compiler directive. When given a type
specification, @encode() returns a string encoding that type. The type can be a basic type such as an int, a
pointer, a tagged structure or union, or a class name—any type, in fact, that can be used as an argument to
the C sizeof() operator.
char *buf1 = @encode(int **);
char *buf2 = @encode(struct key);
char *buf3 = @encode(Rectangle);
The table below lists the type codes. Note that many of them overlap with the codes you use when encoding
an object for purposes of archiving or distribution. However, there are codes listed here that you can’t use
when writing a coder, and there are codesthat you may want to use when writing a coder that aren’t generated
by @encode(). (See the NSCoder class specification in the Foundation Framework reference for more
information on encoding objects for archiving or distribution.)
Table 6-1 Objective-C type encodings
Code Meaning
c A char
i An int
s A short
A long
l is treated as a 32-bit quantity on 64-bit programs.
l
q A long long
C An unsigned char
I An unsigned int
S An unsigned short
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
24
Type EncodingsCode Meaning
L An unsigned long
Q An unsigned long long
f A float
d A double
B A C++ bool or a C99 _Bool
v A void
* A character string (char *)
@ An object (whether statically typed or typed id)
# A class object (Class)
: A method selector (SEL)
[array type ] An array
{name=type...} A structure
(name=type...) A union
bnum A bit field of num bits
^type A pointer to type
? An unknown type (among other things, this code is used for function pointers)
Important: Objective-C does not support the long double type. @encode(long double) returns d,
which is the same encoding as for double.
The type code for an array is enclosed within square brackets; the number of elements in the array is specified
immediately after the open bracket, before the array type. For example, an array of 12 pointers to floats
would be encoded as:
[12^f]
Structures are specified within braces, and unions within parentheses. The structure tag is listed first, followed
by an equal sign and the codes for the fields of the structure listed in sequence. For example, the structure
Type Encodings
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
25typedef struct example {
id anObject;
char *aString;
int anInt;
} Example;
would be encoded like this:
{example=@*i}
The same encoding results whether the defined type name (Example) or the structure tag (example) is passed
to @encode(). The encoding for a structure pointer carriesthe same amount of information about the structure’s
fields:
^{example=@*i}
However, another level of indirection removes the internal type specification:
^^{example}
Objects are treated like structures. For example, passing the NSObject class name to @encode() yields this
encoding:
{NSObject=#}
The NSObject class declares just one instance variable, isa, of type Class.
Note that although the @encode() directive doesn’t return them, the runtime system uses the additional
encodings listed in Table 6-2 for type qualifiers when they’re used to declare methods in a protocol.
Table 6-2 Objective-C method encodings
Code Meaning
r const
n in
N inout
Type Encodings
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
26Code Meaning
o out
O bycopy
R byref
V oneway
Type Encodings
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
27When the compiler encounters property declarations (see Declared Properties in The Objective-C Programming
Language ), it generates descriptive metadata that is associated with the enclosing class, category or protocol.
You can accessthis metadata using functionsthatsupport looking up a property by name on a class or protocol,
obtaining the type of a property as an @encode string, and copying a list of a property's attributes as an array
of C strings. A list of declared properties is available for each class and protocol.
Property Type and Functions
The Property structure defines an opaque handle to a property descriptor.
typedef struct objc_property *Property;
You can use the functions class_copyPropertyList and protocol_copyPropertyList to retrieve an
array of the properties associated with a class (including loaded categories) and a protocol respectively:
objc_property_t *class_copyPropertyList(Class cls, unsigned int *outCount)
objc_property_t *protocol_copyPropertyList(Protocol *proto, unsigned int *outCount)
For example, given the following class declaration:
@interface Lender : NSObject {
float alone;
}
@property float alone;
@end
you can get the list of properties using:
id LenderClass = objc_getClass("Lender");
unsigned int outCount;
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
28
Declared Propertiesobjc_property_t *properties = class_copyPropertyList(LenderClass, &outCount);
You can use the property_getName function to discover the name of a property:
const char *property_getName(objc_property_t property)
You can use the functions class_getProperty and protocol_getProperty to get a reference to a property
with a given name in a class and protocol respectively:
objc_property_t class_getProperty(Class cls, const char *name)
objc_property_t protocol_getProperty(Protocol *proto, const char *name, BOOL
isRequiredProperty, BOOL isInstanceProperty)
You can use the property_getAttributes function to discover the name and the @encode type string of
a property. For details of the encoding type strings, see “Type Encodings” (page 24); for details of this string,
see “Property Type String” (page 29) and “Property Attribute Description Examples” (page 30).
const char *property_getAttributes(objc_property_t property)
Putting these together, you can print a list of all the properties associated with a class using the following
code:
id LenderClass = objc_getClass("Lender");
unsigned int outCount, i;
objc_property_t *properties = class_copyPropertyList(LenderClass, &outCount);
for (i = 0; i < outCount; i++) {
objc_property_t property = properties[i];
fprintf(stdout, "%s %s\n", property_getName(property),
property_getAttributes(property));
}
Property Type String
You can use the property_getAttributes function to discover the name, the @encode type string of a
property, and other attributes of the property.
Declared Properties
Property Type String
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
29The string starts with a T followed by the @encode type and a comma, and finishes with a V followed by the
name of the backing instance variable. Between these, the attributes are specified by the following descriptors,
separated by commas:
Table 7-1 Declared property type encodings
Code Meaning
R The property is read-only (readonly).
C The property is a copy of the value last assigned (copy).
& The property is a reference to the value last assigned (retain).
N The property is non-atomic (nonatomic).
The property defines a custom getter selector name. The name follows the G (for
example, GcustomGetter,).
G
The property defines a custom setter selector name. The name follows the S (for
example, ScustomSetter:,).
S
D The property is dynamic (@dynamic).
W The property is a weak reference (__weak).
P The property is eligible for garbage collection.
t Specifies the type using old-style encoding.
For examples, see “Property Attribute Description Examples” (page 30).
Property Attribute Description Examples
Given these definitions:
enum FooManChu { FOO, MAN, CHU };
struct YorkshireTeaStruct { int pot; char lady; };
typedef struct YorkshireTeaStruct YorkshireTeaStructType;
union MoneyUnion { float alone; double down; };
Declared Properties
Property Attribute Description Examples
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
30the following table shows sample property declarations and the corresponding string returned by
property_getAttributes:
Property declaration Property description
@property char charDefault; Tc,VcharDefault
@property double doubleDefault; Td,VdoubleDefault
@property enum FooManChu enumDefault; Ti,VenumDefault
@property float floatDefault; Tf,VfloatDefault
@property int intDefault; Ti,VintDefault
@property long longDefault; Tl,VlongDefault
@property short shortDefault; Ts,VshortDefault
@property signed signedDefault; Ti,VsignedDefault
T{YorkshireTeaStruct="pot"i"lady"c},VstructDefault
@property struct YorkshireTeaStruct
structDefault;
T{YorkshireTeaStruct="pot"i"lady"c},VtypedefDefault
@property YorkshireTeaStructType
typedefDefault;
T(MoneyUnion="alone"f"down"d),VunionDefault
@property union MoneyUnion unionDefault;
@property unsigned unsignedDefault; TI,VunsignedDefault
@property int (*functionPointerDefault)(char T^?,VfunctionPointerDefault
*);
@property id idDefault; T@,VidDefault
Note: the compiler warns: no 'assign', 'retain',
or 'copy' attribute is specified - 'assign'
is assumed"
@property int *intPointer; T^i,VintPointer
@property void *voidPointerDefault; T^v,VvoidPointerDefault
Declared Properties
Property Attribute Description Examples
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
31Property declaration Property description
@property int intSynthEquals; Ti,V_intSynthEquals
In the implementation block:
@synthesize intSynthEquals=_intSynthEquals;
Ti,GintGetFoo,SintSetFoo:
,VintSetterGetter
@property(getter=intGetFoo,
setter=intSetFoo:) int intSetterGetter;
@property(readonly) int intReadonly; Ti,R,VintReadonly
@property(getter=isIntReadOnlyGetter, Ti,R,GisIntReadOnlyGetter
readonly) int intReadonlyGetter;
@property(readwrite) int intReadwrite; Ti,VintReadwrite
@property(assign) int intAssign; Ti,VintAssign
@property(retain)ididRetain; T@,&,VidRetain
@property(copy)ididCopy; T@,C,VidCopy
@property(nonatomic) int intNonatomic; Ti,VintNonatomic
@property(nonatomic, readonly, copy) id T@,R,C,VidReadonlyCopyNonatomic
idReadonlyCopyNonatomic;
T@,R,&,VidReadonlyRetainNonatomic
@property(nonatomic, readonly, retain) id
idReadonlyRetainNonatomic;
Declared Properties
Property Attribute Description Examples
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
32This table describes the changes to Objective-C Runtime Programming Guide .
Date Notes
2009-10-19 Made minor editorial changes.
2009-07-14 Completed list of types described by property_getAttributes.
2009-02-04 Corrected typographical errors.
2008-11-19 New document that describesthe Objective-C 2.0 runtime support library.
2009-10-19 | © 2009 Apple Inc. All Rights Reserved.
33
Document Revision HistoryApple Inc.
© 2009 Apple Inc.
All rights reserved.
No part of this publication may be reproduced,
stored in a retrievalsystem, or transmitted, in any
form or by any means, mechanical, electronic,
photocopying, recording, or otherwise, without
prior written permission of Apple Inc., with the
following exceptions: Any person is hereby
authorized to store documentation on a single
computer for personal use only and to print
copies of documentation for personal use
provided that the documentation contains
Apple’s copyright notice.
No licenses, express or implied, are granted with
respect to any of the technology described in this
document. Apple retains all intellectual property
rights associated with the technology described
in this document. This document is intended to
assist application developers to develop
applications only for Apple-labeled computers.
Apple Inc.
1 Infinite Loop
Cupertino, CA 95014
408-996-1010
Apple, the Apple logo, Cocoa, iPhone, Mac,
Objective-C, and OS X are trademarks of Apple
Inc., registered in the U.S. and other countries.
Even though Apple has reviewed this document,
APPLE MAKES NO WARRANTY OR REPRESENTATION,
EITHER EXPRESS OR IMPLIED, WITH RESPECT TO THIS
DOCUMENT, ITS QUALITY, ACCURACY,
MERCHANTABILITY, OR FITNESS FOR A PARTICULAR
PURPOSE.ASARESULT, THISDOCUMENT IS PROVIDED
“AS IS,” AND YOU, THE READER, ARE ASSUMING THE
ENTIRE RISK AS TO ITS QUALITY AND ACCURACY.
IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL,OR CONSEQUENTIAL
DAMAGES RESULTING FROM ANY DEFECT OR
INACCURACY IN THIS DOCUMENT, even if advised of
the possibility of such damages.
THE WARRANTY AND REMEDIES SET FORTH ABOVE
ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL
OR WRITTEN, EXPRESS OR IMPLIED. No Apple dealer,
agent, or employee is authorized to make any
modification, extension, or addition to this warranty.
Some states do not allow the exclusion or limitation
of implied warranties or liability for incidental or
consequential damages, so the above limitation or
exclusion may not apply to you. This warranty gives
you specific legal rights, and you may also have other
rights which vary from state to state.
Universal Binary Programming Guidelines,
Second Edition
(Legacy)Contents
Introduction 8
Who Should Read This Document? 8
Organization of This Document 8
Assumptions 9
Conventions 10
Building a Universal Binary 11
Build Assumptions 11
Building Your Code 12
Debugging 16
Troubleshooting Your Built Application 16
Determining Whether a Binary Is Universal 18
Build Options 18
Default Compiler Options 19
Architecture-Specific Options 19
Autoconf Macros 20
See Also 20
Architectural Differences 21
Alignment 21
Bit Fields 21
Byte Order 21
Calling Conventions 22
Code on the Stack: Disabling Execution 22
Data Type Conversions 23
Data Types 23
Divide-By-Zero Operations 24
Extensible Firmware Interface (EFI) 24
Floating-Point Equality Comparisons 24
Structures and Unions 25
See Also 25
Swapping Bytes 26
Why Byte Ordering Matters 26
Retired Document | 2009-02-04 | © 2005, 2009 Apple Inc. All Rights Reserved.
2Guidelines for Swapping Bytes 28
Byte-Swapping Routines 29
Byte-Swapping Strategies 30
Constants 30
Custom Apple Event Data 31
Custom Resource Data 31
Floating-Point Values 32
Integers 33
Network-Related Data 34
OSType-to-String Conversions 35
Unicode Text Files 36
Values in an Array 38
Writing a Callback to Swap Data Bytes 38
See Also 45
Guidelines for Specific Scenarios 46
Aliases 46
Archived Bit Fields 46
Automator Scripts 46
Bit Shifting 47
Bit Test, Set, and Clear Functions: Carbon and POSIX 47
