Bundle Programming Guide: Introduction
`11/27/22, 11:13 PM
`1070
`The Wayback Machine - https://web.archive.org/web/20100525020133/http://developer.apple.com:80/mac/library/documentati…
`R. Surati
`Mac OS X Reference Library Apple Developer
`12/01/2022
`Search
`Search Mac OS X Reference Library
`
`□
`Download IconCompanion File PDF
`
`•
`
`Table of Contents
`
`Next
`
`Introduction
`
`Bundles are a fundamental technology in Mac OS X and iPhone OS that are used to encapsulate code and resources. Bundles
`simplify the developer experience by providing known locations for needed resources while alleviating the need to create
`compound binary files. Instead, bundles use directories and files to provide a more natural type of organization—one that can
`also be modified easily both during development and after deployment.
`
`To support bundles, both Cocoa and Core Foundation provide programming interfaces for accessing the contents of bundles.
`Because bundles use an organized structure, it is important that all developers understand the fundamental organizing principles
`of bundles. This document provides you with the foundation for understanding how bundles work and for how you use them
`during development to access your resource files.
`Organization of This Document
`This document contains the following chapters:
`
`•
`
`•
`
`•
`
`“About Bundles” introduces the concept of bundles and packages and how they are used by the system.
`
`“Bundle Structures” describes the structure and contents of the standard bundle types.
`
`“Accessing a Bundle's Contents” shows you how to use the Cocoa and Core Foundation interfaces to get information
`about a bundle and its contents.
`
`•
`
`“Document Packages” describes the notion of document packages (which are loosely related to bundles) and how you
`use them.
`See Also
`Although the information in this document applies to all types of bundles, if you are working with more specialized types of
`bundles (such as frameworks and plug-ins), you should also consult the following documents:
`
`Framework Programming Guide provides detailed information about creating and using custom frameworks.
`
`Code Loading Programming Topics for Cocoa provides information about writing plug-ins using the Objective-C language.
`
`Plug-ins provides information about writing plug-ins using the C language.
`
`•
`
`•
`
`•
`
`Next
`
`Mac Dev Center
`
` Mac OS X Reference Library
`►
`►
`
`Last updated: 2009-07-14
` Data Management: File Management
` Bundle Programming Guide
`►
`
`Petitioner Apple Inc., Ex. 1070
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`Page 0001
`
`https://web.archive.org/web/20100525020133/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/Introductio… 1/2
`
`Petitioner Apple Inc., Ex. 1070, p. 1
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`11/27/22, 11:13 PM
`
`Bundle Programming Guide: Introduction
`Did this document help you? Yes
`It's good, but... Not helpful...
`
`-
`
`Shop the Apple Online Store (1-800-MY-APPLE), visit an Apple Retail Store, or find a reseller.
`
`Mailing Lists
`
`RSS Feeds
`
`Copyright © 2010 Apple Inc. All rights reserved.
`
`Terms of Use
`
`Privacy Policy
`
`Mac Dev Center
`
` Mac OS X Reference Library
`
` Data Management: File Management
`
` Bundle Programming Guide
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0002
`
`https://web.archive.org/web/20100525020133/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/Introductio… 2/2
`
`Petitioner Apple Inc., Ex. 1070, p. 2
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: About Bundles
`11/27/22, 11:14 PM
`The Wayback Machine - https://web.archive.org/web/20100518063556/http://developer.apple.com:80/mac/li…
`Mac OS X Reference Library Apple Developer
`Search
`Search Mac OS X Reference Library
`
`□
`Download IconCompanion File PDF
`~
`
`Table of Contents
`
`. .__ I __ _ J
`
`•
`
`NextPrevious
`
`About Bundles
`
`Bundles are a convenient way to deliver software in Mac OS X and iPhone OS. Bundles provide a simplified
`interface for end users and at the same time provide support for development. This chapter provides an
`introduction to bundles and discusses the role they play in Mac OS X and iPhone OS.
`Bundles and Packages
`Although bundles and packages are sometimes referred to interchangeably, they actually represent very
`distinct concepts:
`
`•
`
`A package is any directory that the Finder presents to the user as if it were a single file.
`
`•
`
`A bundle is a directory with a standardized hierarchical structure that holds executable code and the
`resources used by that code.
`
`Packages provide one of the fundamental abstractions that makes Mac OS X easy to use. If you look at an
`application or plug-in on your computer, what you are actually looking at is a directory. Inside the package
`directory are the code and resource files needed to make the application or plug-in run. When you interact
`with the package directory, however, the Finder treats it like a single file. This behavior prevents casual users
`from making changes that might adversely affect the contents of the package. For example, it prevents users
`from rearranging or deleting resources or code modules that might prevent an application from running
`correctly.
`
`Note: Even though packages are treated as opaque files by default, it is still possible for users to view and
`modify their contents. On the contextual menu for package directories is a Show Package Contents
`command. Selecting this command displays a new Finder window set to the top level of the package directory.
`The user can use this window to navigate the package's directory structure and make changes as if it were a
`regular directory hierarchy.
`
`Whereas packages are there to improve the user experience, bundles are geared more toward helping
`developers package their code and to helping the operating system access that code. Bundles define the
`basic structure for organizing the code and resources associated with your software. The presence of this
`structure also helps facilitate important features such as localization. The exact structure of a bundle depends
`on whether you are creating an application, framework, or plug-in. It also depends on other factors such as
`the target platform and the type of plug-in.
`
`The reason bundles and packages are sometimes considered to be interchangeable is that many types of
`bundles are also packages. For example, applications and loadable bundles are packages because they are
`usually treated as opaque directories by the system. However, not all bundles are packages and vice versa.
`
`How the System Identifies Bundles and Packages
`Mac Dev Center
` Mac OS X Reference Library
` Data Management: File Management
`►
`►
`►
`
` Bundle Programming Guide
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0003
`
`https://web.archive.org/web/20100518063556/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/AboutBun… 1/5
`
`Petitioner Apple Inc., Ex. 1070, p. 3
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: About Bundles
`11/27/22, 11:14 PM
`The Finder considers a directory to be a package if any of the following conditions are true:
`
`•
`
`•
`
`The directory has a known filename extension: .app, .bundle, .framework, .plugin, .kext, and so
`on.
`
`The directory has an extension that some other application claims represents a package type; see
`“Document Packages.”
`
`•
`
`The directory has its package bit set.
`
`The preferred way to specify a package is to give the package directory a known filename extension. For the
`most part, Xcode takes care of this for you by providing templates that apply the correct extension. All you
`have to do is create an Xcode project of the appropriate type.
`
`Most bundles are also packages. For example, applications and plug-ins are typically presented as a single
`file by the Finder. However, this is not true for all bundle types. In particular, a framework is a type of bundle
`that is treated as a single unit for the purposes of linking and runtime usage, but framework directories are
`transparent so that developers can view the header files and other resources they contain.
`
`About Bundle Display Names
`Display names give the user some control over how bundles and packages appear in the Finder without
`breaking clients that rely on them. Whereas a user can rename a file freely, renaming an application or
`framework might cause related code modules that refer to the application or framework by name to break.
`Therefore, when the user changes the name of a bundle, the change is superficial only. Rather than change
`the bundle name in the file system, the Finder associates a separate string (known as the display name) with
`the bundle and displays that string instead.
`
`Display names are for presentation to the user only. You never use display names to open or access
`directories in your code, but you do use them when displaying the name of the directory to the user. By
`default, a bundle’s display name is the same as the bundle name itself. However, the system may alter the
`default display name in the following cases:
`
`•
`
`•
`
`If the bundle is an application, the Finder hides the .app extension in most cases.
`
`If the bundle supports localized display names (and the user has not explicitly changed the bundle
`name), the Finder displays the name that matches the user’s current language settings.
`
`Although the Finder hides the .app extension for applications most of the time, it may display it to prevent
`confusion. For example, if the user changes the name of an application and the new name contains another
`filename extension, the Finder shows the .app. extension to make it clear that the bundle is an application.
`For example, if you were to add the .mov extension to the Chess application, the Finder would display
`Chess.mov.app to prevent users from thinking Chess.mov is a QuickTime file.
`
`For more information about display names and specifying localized bundle names, see File System Overview.
`The Advantages of Bundles
`Bundles provide the following advantages for developers:
`
`•
`
`Because bundles are directory hierarchies in the file system, a bundle just contains files. Therefore,
`you can use all of the same file-based interfaces to open your bundle resources as you do to open
`other types of files.
`
`•
`
`The bundle directory structure makes it easy to support multiple localizations. You can easily add new
`localized resources or remove unwanted ones.
`
`Bundles can reside on volumes of many different formats, including multiple fork formats like HFS,
`•
`HFS+, and AFP, and single-fork formats like UFS, SMB, and NFS.
`Mac Dev Center
` Mac OS X Reference Library
` Data Management: File Management
` Bundle Programming Guide
`►
`►
`►
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0004
`
`https://web.archive.org/web/20100518063556/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/AboutBun… 2/5
`
`Petitioner Apple Inc., Ex. 1070, p. 4
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: About Bundles
`11/27/22, 11:14 PM
`Users can install, relocate, and remove bundles simply by dragging them around in the Finder.
`
`•
`
`•
`
`•
`
`•
`
`Bundles that are also packages, and are therefore treated as opaque files, are less susceptible to
`accidental user modifications, such as removal, modification, or renaming of critical resources.
`
`A bundle can support multiple chip architectures (PowerPC, Intel) and different address space
`requirements (32-bit/64-bit). It can also support the inclusion of specialized executables (for example,
`libraries optimized for a particular set of vector instructions).
`
`Most (but not all) executable code can be bundled. Applications, frameworks (shared libraries), and
`plug-ins all support the bundle model. Static libraries, dynamic libraries, shell scripts, and UNIX
`command line tools do not use the bundle structure.
`
`•
`
`A bundled application can run directly from a server. No special shared libraries, extensions, and
`resources need to be installed on the local system.
`Types of Bundles
`Although all bundles support the same basic features, there are variations in the way you define and create
`bundles that define their intended usage:
`
`•
`
`•
`
`Application - An application bundle manages the code and resources associated with a launchable
`process. The exact structure of this bundle depends on the platform (iPhone OS or Mac OS X) that you
`are targeting. For information about the structure of application bundles, see “Application Bundles.”
`
`Frameworks - A framework bundle manages a dynamic shared library and its associated resources,
`such as header files. An application can link against one or more frameworks to take advantage of the
`code they contain. For information about the structure of framework bundles, see “Anatomy of a
`Framework Bundle.”
`
`•
`
`Plug-Ins - Mac OS X supports plug-ins for many system features. Plug-ins are a way for an application
`to load custom code modules dynamically. The following list identifies some of the key types of plug-ins
`you might want to develop:
`
`0
`
`0
`
`0
`
`0
`
`0
`
`0
`
`0
`
`0
`
`Custom plug-ins are plug-ins you define for your own purposes; see “Anatomy of a Loadable
`Bundle.”
`
`Image Unit plug-ins add custom image-processing behaviors to the Core Image technology;
`see Image Unit Tutorial.
`
`Interface Builder plug-ins contain custom objects that you want to integrate into Interface
`Builder’s library window; see Interface Builder Plug-In Programming Guide.
`
`Preference Pane plug-ins define custom preferences that you want to integrate into the
`System Preferences application; see Preference Pane Programming Guide.
`
`Quartz Composer plug-ins define custom patches for the Quartz Composer application; see
`Quartz Composer Custom Patch Programming Guide.
`
`Quick Look plug-ins support the display of custom document types using Quick Look; see
`Quick Look Programming Guide.
`
`Spotlight plug-ins support the indexing of custom document types so that those documents
`can be searched by the user; see Spotlight Importer Programming Guide.
`
`Sync Schema plug-ins identify custom information that can be synchronized with the system;
`see Sync Services Programming Guide.
`
`Mac Dev Center
`
` Mac OS X Reference Library
`►
`►
`
` Data Management: File Management
`►
`
` Bundle Programming Guide
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0005
`
`https://web.archive.org/web/20100518063556/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/AboutBun… 3/5
`
`Petitioner Apple Inc., Ex. 1070, p. 5
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: About Bundles
`11/27/22, 11:14 PM
`WebKit plug-ins extend the content types supported by common web browsers; see WebKit
`Plug-In Programming Topics.
`
`0
`
`0
`
`Widgets add new HTML-based applications to Dashboard; see Dashboard Programming
`Topics.
`
`Although document formats can leverage the bundle structure to organize their contents, documents are
`generally not considered bundles in the purest sense. A document that is implemented as a directory and
`treated as an opaque type is considered to be a document package, regardless of its internal format. For
`more information about document packages, see “Document Packages.”
`Creating a Bundle
`For the most part, you do not create bundles or packages manually. When you create a new Xcode project (or
`add a target to an existing project), Xcode automatically creates the required bundle structure when needed.
`For example, the application, framework, and loadable bundle targets all have associated bundle structures.
`When you build any of these targets, Xcode automatically creates the corresponding bundle for you.
`
`Note: Some Xcode targets (such as shell tools and static libraries) do not result in the creation of a bundle or
`package. This is normal and there is no need to create bundles specifically for these target types. The
`resulting binaries generated for those targets are intended to be used as is.
`
`If you use make files (instead of Xcode) to build your projects, there is no magic to creating a bundle. A
`bundle is just a directory in the file system with a well-defined structure and a specific filename extension
`added to the end of the bundle directory name. As long as you create the top-level bundle directory and
`structure the contents of your bundle appropriately, you can access those contents using the programmatic
`support for accessing bundles. For more information on how to structure your bundle directory, see “Bundle
`Structures.”
`Programmatic Support for Accessing Bundles
`Programs that refer to bundles, or are themselves bundled, can take advantage of interfaces in Cocoa and
`Core Foundation to access the contents of a bundle. Using these interfaces you can find bundle resources,
`get information about the bundle’s configuration, and load executable code. In Objective-C applications, you
`use the NSBundle class to get and manage bundle information. For C-based applications, you can use the
`functions associated with the CFBundleRef opaque type to manage a bundle.
`
`Note: Unlike many other Core Foundation and Cocoa types, NSBundle and CFBundleRef are not toll-free
`bridged data types and cannot be used interchangeably. However, you can extract the bundle path
`information from either object and use it to create the other.
`
`For information about how to use the programmatic support in Cocoa and Core Foundation to access
`bundles, see “Accessing a Bundle's Contents.”
`Guidelines for Using Bundles
`Bundles are the preferred organization mechanism for software in Mac OS X and iPhone OS. The bundle
`structure lets you group executable code and the resources to support that code in one place and in an
`organized way. The following guidelines offer some additional advice on how to use bundles:
`
`•
`
`Always include an information-property list (Info.plist) file in your bundle. Make sure you include the
`keys recommended for your bundle type. For a list of all keys you can include in this file, see Runtime
`Configuration Guidelines.
`
`•
`
`If an application cannot run without a specific resource file, include that file inside the application
`bundle. Applications should always include all of the images, strings files, localizable resources, and
`plug-ins that they need to operate. Noncritical resources should similarly be stored inside the
`Mac Dev Center
` Mac OS X Reference Library
` Data Management: File Management
` Bundle Programming Guide
`►
`►
`►
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0006
`
`https://web.archive.org/web/20100518063556/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/AboutBun… 4/5
`
`Petitioner Apple Inc., Ex. 1070, p. 6
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: About Bundles
`11/27/22, 11:14 PM
`application bundle whenever possible but may be placed outside the bundle if needed. For more
`information about the bundle structure of applications, see “Application Bundles.”
`
`•
`
`•
`
`•
`
`•
`
`If you plan to load C++ code from a bundle, you might want to mark the symbols you plan to load as
`extern "C". Neither NSBundle nor the Core Foundation CFBundleRef functions know about C++
`name mangling conventions, so marking your symbols this way can make it much easier to identify
`them later.
`
`You cannot use the NSBundle class to load Code Fragment Manager (CFM) code. If you need to load
`CFM-based code, you must use the functions for the CFBundleRef or CFPlugInRef opaque types. You
`may load CFM-based plugins from a Mach-O executable using this technique.
`
`You should always use the NSBundle class (as opposed to the functions associated with the
`CFBundleRef opaque type) to load any bundle containing Java code.
`
`When loading bundles containing Objective-C code, you may use either the NSBundle class or the
`functions associated with the CFBundleRef opaque type in Mac OS X v10.5 and later, but there are
`differences in behavior for each. If you use the Core Foundation functions to load a plug-in or other
`loadable bundle (as opposed to a framework or dynamic shared library), the functions load the bundle
`privately and bind its symbols immediately; if you use NSBundle, the bundle is loaded globally and its
`symbols are bound lazily. In addition, bundles loaded using the NSBundle class cause the generation
`of NSBundleDidLoadNotification notifications, whereas those loaded using the Core Foundation
`functions do not.
`
`NextPrevious
`
`Last updated: 2009-07-14
`
`Did this document help you? Yes
`
`It's good, but... Not helpful...
`
`-
`
`Shop the Apple Online Store (1-800-MY-APPLE), visit an Apple Retail Store, or find a
`reseller.
`
`Mailing Lists
`
`RSS Feeds
`
`Copyright © 2010 Apple Inc. All rights reserved.
`
`Terms of Use
`
`Privacy Policy
`
`Mac Dev Center
`
` Mac OS X Reference Library
`►
`►
`
` Data Management: File Management
`►
`
` Bundle Programming Guide
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0007
`
`https://web.archive.org/web/20100518063556/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/AboutBun… 5/5
`
`Petitioner Apple Inc., Ex. 1070, p. 7
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: Bundle Structures
`11/27/22, 11:14 PM
`The Wayback Machine - https://web.archive.org/web/20100515101347/http://developer.apple.com:80/mac/li…
`Mac OS X Reference Library Apple Developer
`Search
`Search Mac OS X Reference Library
`
`□
`Download IconCompanion File PDF
`~
`
`Table of Contents
`
`.__ I __ _____ J
`
`•
`
`NextPrevious
`
`Bundle Structures
`
`Bundle structures can vary depending on the type of the bundle and the target platform. The following sections
`describe the bundle structures used most commonly in both Mac OS X and iPhone OS.
`
`Note: Although bundles are one way of packaging executable code, they are not the only way that is
`supported. UNIX shell scripts and command-line tools do not use the bundle structure, neither do static and
`dynamic shared libraries.
`Application Bundles
`Application bundles are one of the most common types of bundle created by developers. The application
`bundle stores everything that the application requires for successful operation. Although the specific structure
`of an application bundle depends on the platform for which you are developing, the way you use the bundle is
`the same on both platforms. This chapter describes the structure of application bundles in both iPhone OS
`and Mac OS X.
`
`What Files Go Into an Application Bundle?
`Table 2-1 summarizes the types of files you are likely to find inside an application bundle. The exact location of
`these files varies from platform to platform and some resources may not be supported at all. For examples
`and more detailed information, see the platform-specific bundle sections in this chapter.
`
`Table 2-1 Types of files in an application bundle
`
`File
`
`Description
`
`Info.plist
`file
`
`(Required) The information property list file is a structured file that contains configuration
`information for the application. The system relies on the presence of this file to identify
`relevant information about your application and any related files.
`
`Executable
`
`(Required) Every application must have an executable file. This file contains the application’s
`main entry point and any code that was statically linked to the application target.
`
`Resource
`files
`
`Mac Dev Center
`
`Resources are data files that live outside your application’s executable file. Resources
`typically consist of things like images, icons, sounds, nib files, strings files, configuration files,
`and data files (among others). Resource files can be localized for a particular language or
`region or shared by all localizations.
` Mac OS X Reference Library
` Data Management: File Management
`►
`►
`►
`
` Bundle Programming Guide
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0008
`
`https://web.archive.org/web/20100515101347/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/BundleTy… 1/19
`
`Petitioner Apple Inc., Ex. 1070, p. 8
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: Bundle Structures
`11/27/22, 11:14 PM
`The placement of resource files in the bundle directory structure depends on whether you are
`developing an iPhone or Mac OS X application.
`
`Other
`support files
`
`Mac OS X applications can embed additional high-level resources such as private
`frameworks, plug-ins, document templates, and other custom data resources that are integral
`to the application. Although you can include custom data resources in your iPhone application
`bundles, you cannot include custom frameworks or plug-ins.
`
`Although most of the resources in an application bundle are optional, this may not always be the case. For
`example, iPhone applications typically require additional image resources for the application’s icon and default
`screen. And although not explicitly required, most Mac OS X applications include a custom icon instead of the
`default one provided by the system.
`
`Anatomy of an iPhone Application Bundle
`The project templates provided by Xcode do most of the work necessary for setting up your iPhone application
`bundle during development. However, understanding the bundle structure can help you decide where you
`should place your own custom files. The bundle structure of iPhone applications is geared more toward the
`needs of a mobile device. It uses a relatively flat structure with few extraneous directories in an effort to save
`disk space and simplify access to the files.
`
`The iPhone Application Bundle Structure
`
`A typical iPhone application bundle contains the application executable and any resources used by the
`application (for instance, the application icon, other images, and localized content) in the top-level bundle
`directory. Listing 2-1 shows the structure of a simple iPhone application called MyApp. The only files that are
`required to be in subdirectories are those that need to be localized; however, you could create additional
`subdirectories in your own applications to organize resources and other relevant files.
`
`Listing 2-1 Bundle structure of an iPhone application
`
`MyApp.app
`
` MyApp
`
` Icon.png
`
` Info.plist
`
` Default.png
`
` MainWindow.nib
`
` Settings.bundle
`
` Icon-Settings.png
`Mac Dev Center
` Mac OS X Reference Library
`
`..
`
` Data Management: File Management
`
`..
`
` Bundle Programming Guide
`
`..
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0009
`
`https://web.archive.org/web/20100515101347/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/BundleTy… 2/19
`
`Petitioner Apple Inc., Ex. 1070, p. 9
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`Bundle Programming Guide: Bundle Structures
`
`11/27/22, 11:14 PM
` iTunesArtwork
`
` en.lproj
`
` MyImage.png
`
` fr.lproj
`
` MyImage.png
`
`Table 2-2 describes the contents of the application shown in Listing 2-1. Although the application itself is for
`demonstration purposes only, many of the files it contains represent specific files that iPhone OS looks for
`when scanning an application bundle. Your own bundles would include some or all of these files depending on
`the features you support.
`
`Table 2-2 Contents of a typical iPhone application bundle
`
`File
`
`Description
`
`MyApp
`
`(Required) The executable file containing your application’s code. The name of this file
`is the same as your application name minus the .app extension.
`
`Icon.png
`
`(Required) The 57 x 57 pixel icon used to represent your application on the device
`home screen. This icon should not contain any glossy effects. The system adds those
`effects for you automatically.
`
`Info.plist
`
`(Required) This file contains configuration information for the application, such as its
`bundle ID, version number, and display name. See “The Information Property List File”
`for further information.
`
`Default.png
`
`The 480 x 320 pixel image to display when your application is launched. The system
`uses this file as a temporary background until your application loads its window and
`user interface. If your application does not provide this file, a black background is
`displayed while the application launches.
`
`MainWindow.nib
`
`The application’s main nib file contains the default interface objects to load at
`application launch time. Typically, this nib file contains the application’s main window
`object and an instance of the application delegate object. Other interface objects are
`then either loaded from additional nib files or created programmatically by the
`application. (The name of the main nib file can be changed by assigning a different
`value to the NSMainNibFile key in the Info.plist file. See “The Information Property
`List File” for further information.)
`
`Settings.bundle The Settings bundle is a special type of plug-in that contains any application-specific
`Mac Dev Center
` Mac OS X Reference Library
` Data Management: File Management
` Bundle Programming Guide
`
`..
`
`..
`
`..
`
`IPR2022-00031 / IPR2022-00032 / IPR2022-00033 / PGR2022-00006
`
`Page 0010
`
`https://web.archive.org/web/20100515101347/http://developer.apple.com/mac/library/documentation/corefoundation/conceptual/CFBundles/BundleTy… 3/19
`
`Petitioner Apple Inc., Ex. 1070, p. 10
`Apple Inc. v. MemoryWeb, LLC, IPR2022-00032
`
`

`

`11/27/22, 11:14 PM
`
`Bundle Programming Guide: Bundle Structures
`preferences that you want to add to the Settings application. This bundle contains
`property lists and other resource files to configure and display your preferences.
`
`Icon-
`Settings.png
`
`The 29 x 29 pixel icon used to represent your application in the Settings application. If
`your application includes a settings bundle, this icon is displayed next to your
`application name in the Settings application. If you do not specify this icon file, the
`Icon.png file is scaled and used instead.
`
`iTunesArtwork
`
`The 512 x 512 icon for an application that is distributed using ad-hoc distribution. This
`icon would normally be provided by the App Store; because applications distributed in
`an ad-hoc manner do not go through the App Store, however, it must be present in the
`application bundle instead. iTunes uses this icon to represent your application. (The file
`you specify for this property should be the same one you would have submitted to the
`App Store (typically a JPEG or PNG file), were you to distribute your application that
`way. The filename must be the one shown at left and must not include a filename
`extension.)
`
`Custom resource
`files
`
`Nonlocalized resources are placed at the top level directory and localized resources are
`placed in language-specific subdirectories of the application bundle. Resources consist
`of nib files, images, sound files, configuration files, strings files, and any other custom
`data files you need for your application. For more information about resources, see
`“Resources in an iPhone Application.”
`
`An iPhone application should be internationalized and have a language.lproj folder for each language it
`supports. In addition to providing localized versions of your application’s custom resources, you can also
`localize your application icon (Icon.png), default image (Default.png), and Settings icon (Icon-
`Settings.png) by placing files with the same name in your language-specific project directories. Even if you
`provide localized versions, however, you should always include a default version of these files at the top-level
`of your application bundle. The default version is used in situations where a specific localization is not
`available. For more information about localized resources, see “Localized Resources in Bundles.”
`
`The Information Property List File
`
`Every iPhone application must have an information property list (Info.plist) file containing the application’s
`confirmation information. When you create a new iPhone application project, Xcode creates this file
`automatically and sets the value of some of the key properties for you. Table 2-3 lists some additional keys
`that you should set explicitly. (Xcode obscures actual key names by default, so the string displayed by Xcode
`is also listed in parenthesis where one is used. You can see the real key names for all keys by Control-clicking
`the Information Property List key in the editor and choosing Show Raw Keys/Values from the contextual menu
`that appears.)
`
`Table 2-3 Required keys for the Info.plist file
`
`Key
`
`Value
`
`CFBundleDisplayName
`(Bundle display name)
`
`The bundle display name is the name displayed underneath the application icon.
`This value should be localized for all supported languages.
`
`The bundle identifier string identifies your application to the system. This s