Comprendre les anciennes structures de projet

Welcome! In this lesson, we'll explore the typical file and folder structures of older Objective-C iOS applications. Understanding these patterns is the first step to effectively maintaining or modernizing a legacy codebase.

These projects often predate modern Swift conventions and utilize patterns that were standard years ago. Getting familiar with them will help you navigate unfamiliar territory with confidence.

An Xcode project is defined by a .xcodeproj file. This isn't a single file, but a folder containing project settings, configurations, and references to your source files.

• .xcodeproj: Contains all settings, build configurations, and references to your code and resources.
• .xcworkspace: If you see this, it means your project uses CocoaPods or another dependency manager. It bundles one or more .xcodeproj files, allowing them to be built together.

Always open the .xcworkspace if it exists.

Every Objective-C application has a single entry point: the main.m file. This is where the application's execution begins, similar to main() in C or C++.

It typically sets up the application delegate and starts the main event loop. Let's look at a common example:

The AppDelegate is a crucial class that manages the application's lifecycle and global events. It conforms to the UIApplicationDelegate protocol.

• App Lifecycle: Methods like application:didFinishLaunchingWithOptions:, applicationDidEnterBackground:, and applicationWillEnterForeground: are handled here.
• Central Hub: In older apps, it often became a "God object" holding references to many key components or even global data.

Understanding the AppDelegate helps you grasp the app's overall flow.

The user interface (UI) of an iOS app is built using views and view controllers. Each screen or major section of an app typically has its own view controller.

• UIViewController: Manages a screen's content view and coordinates interactions.
• UIView: The basic building block for all UI elements (buttons, labels, images, etc.).

You'll often find pairs of .h (header) and .m (implementation) files for each custom view controller and view.

Older Objective-C apps heavily adopted the Model-View-Controller (MVC) architectural pattern. Files were often organized with this in mind, even if not strictly enforced.

• Model: Data and business logic (e.g., a User class).
• View: What the user sees (e.g., a UIButton, UILabel).
• Controller: Mediates between Model and View, handling user input and updating the View (e.g., a ViewController).

Recognizing these roles helps you locate relevant code.

While modern Xcode projects often use more feature-based organization, older Objective-C projects frequently grouped files by their MVC role or type:

• Models: Classes representing data structures (e.g., User.h/.m).
• Views: Custom UI elements (e.g., CustomButton.h/.m).
• Controllers: View controllers (e.g., HomeViewController.h/.m).
• Utilities: Helper classes, categories, or managers.
• Resources: Images, sound files, storyboards, .xib files.

These groups are logical, not necessarily physical folders.

The Info.plist (Property List) file is an essential configuration file for every iOS application. It contains metadata about your app.

• App Name & Version: Basic identification.
• Icons & Launch Screens: Paths to your app's visual assets.
• Permissions: Explanations for why your app needs access to things like photos or location.
• URL Schemes: How other apps can interact with yours.

Always check this file for fundamental app settings.

In many older Objective-C projects, you'll find a .pch (prefix header) file. This file was automatically precompiled and included in every source file.

• Global Imports: Used to import commonly used frameworks (like UIKit) or custom headers once.
• Macros: Define global macros or constants.

While deprecated in modern Xcode projects, understanding its role is key when navigating legacy codebases to avoid missing important global declarations.

Which of the following files or components are fundamental to the structure and initial setup of a typical older Objective-C iOS application?

Great job! You've learned to identify the core structural elements of older Objective-C iOS projects:

• The purpose of .xcodeproj and .xcworkspace.
• The app's entry point in main.m.
• The central role of AppDelegate.
• How UI is built with UIView and UIViewController.
• The influence of MVC and common file groupings.
• The importance of Info.plist and the historical use of .pch files.

This foundational knowledge will be invaluable as you delve deeper into legacy codebases. Next, we'll look at identifying common legacy patterns within the code itself.