Xcode 4 iOS Development Beginner's Guide

In order to develop for the iPhone or any other iOS device, you will need to download and install the Xcode developer tools. You can find these development tools on the CDs that come with your Mac. However, it is always best to download the latest version of the developer tools from the Apple website at http://developer.apple.com/.

Before you proceed to download these tools, Apple requires you to register as an iOS developer at http://developer.apple.com/programs/register/. The registration is free and provides you with access to the iOS SDK (software development kit) and other resources that are useful for getting started.

Xcode 4 is a complete toolset for building Mac OS X (Cocoa-Based) and iOS applications. The new single-windowed development interface has been redesigned to be a lot easier and even more helpful to use than it has been in previous releases. It can now also identify mistakes in both syntax and logical errors, and will even fix your code for you.

It provides you with the tools to enable you to speed up your development process, therefore becoming more productive. It also automates deployment of both your Mac OS X and iOS applications.

The Integrated Development Environment (IDE) allows you to do the following:

Xcode incorporates many new features and improvements, apart from the redesigned user interface; it features a new and improved LLVM (Low Level Virtual Machine) compiler that has been supercharged to run three times faster and 2.5 times more efficiently.

This new compiler is the next generation compiler technology designed for high-performance projects and completely supports C, Objective-C, and now C++. It is also incorporated into the Xcode IDE and compiles twice as fast and quickly as GCC and your applications will run faster.

The list below includes the many improvements made to this release:

Xcode allows you to create a number of build configurations to test your iOS applications, for debugging using the Static Analyzer, or profiling using the Instruments application. Xcode also allows you to archive your application in order to submit to the Apple App Store for review.

It supports several source-code management tools, namely, CVS "Version control software which is an important component of the Source Configuration Management (SCM)" and Subversion that allows you to add files to a repository, commit changes, get updated versions, and compare versions using the Version Editor tool.

The iPhone Simulator is a very useful tool that enables you to test your applications without using your actual device, whether this is your iPhone or any other iOS device. You do not need to launch this application manually, as this is done when you Build and Run your application within the Xcode Integrated Development Environment (IDE). Xcode installs your application on the iPhone Simulator for you automatically.

The iPhone Simulator also has the capability of simulating different versions of the iPhone OS, and this can become extremely useful if your application needs to be installed on different iOS platforms, as well as testing and debugging errors reported in your application when run under different versions of the iOS.

Apple describes the set of frameworks and technologies that are currently implemented within the iOS operating system as a series of layers. Each of these layers is made up of a variety of different frameworks that can be used and incorporated into your applications:

We will now go into detail and explain each of the different layers of the iOS Architecture; this will give you a better understanding of what is covered within each of the Core layers.

Cocoa is defined as the development framework used for the development of most native Mac OS X applications. A good example of a Cocoa-related application is Mail or Text Edit.

This framework consists of a collection of shared object code libraries known as the Cocoa frameworks. It consists of a runtime system and a development environment. This set of frameworks provides you with a consistent and optimized set of pre-built code modules that will speed up your development process.

Cocoa provides you with a rich layer of functionality, as well as a comprehensive object-oriented like structure and APIs on which you can build your applications. Cocoa uses the Model-View-Controller (MVC) design pattern.

We will just touch on this subject briefly as this will be covered in Chapter 5, Designing Application Interfaces using MVC. Basically, the Model-View-Controller (MVC) comprises of a logical way of dividing up the code that makes up the GUI (Graphical User Interface) of an application. Object-Oriented applications like Java and .Net have adopted the MVC design pattern.

The MVC model comprises of three distinctive categories:

Object-Oriented programming (OOP), provides an abstraction layer of the data on which you operate. It provides a concrete foundation between the data and the operations that you perform with the data, in effect, giving the data behavior.

By using the power of Object-Oriented programming, we can create classes and later extend its characteristics to incorporate additional functionality. Objects within a class can be protected to prevent those elements from being exposed; this is called "Data Hiding".

public class Dog {
// public - a violation of data hiding 'rules'
  public string name;

// private - not visible outside the class
  Private float age;
  .
  .
  .

public class Dog {
  private String name;
  private String gender;
  private String breed; 
  private float weight;
  private float height;
  private float age;

// Here are 'get' and 'set' methods for the private variable declared above.
  public void setName(String name){
    this.name = name;  
  }
  public String getName() { return name;}
  public void setGender (String gender){
    this.gender = gender;  
  }
  public String getGender() { return gender;}
  public void setBreed (String breed){
    this.breed = breed;  
  }
  public String getBreed() { return breed;}
  public void setHeight(float height ) {
     If (height >= 0) { this.height = height;}
  } 
  public float getHeight() { return height;}
  public void setWeight(float weight){
    if (weight >= 0) { this.weight = weight;}
  }
  public float getWeight() { return weight;}
  public float getAge() { return age;}
  public void setAge(float age){
    if (age >= 0) { this.age = age;}
  }
}

public class Main {

  /**
  * @param args the command line arguments
  */
  public static void main(String[] args) {
    Dog myDog = new Dog();

    // Use the 'set' method to assign each property.
    myDog.setName("Frodo");
    myDog.setGender("Male");
    myDog.setBreed("Pug");
    myDog.setWeight((float)9.0);
    myDog.setHeight((float)36.0)
    myDog.setAge((float)10.0);

    // Output each of the values using the Getters. 
    System.out.println("Name   = " + myDog.getName ());
    System.out.println("Gender = " + myDog.getGender());
    System.out.println("Breed  = " + myDog.getBreed());
    System.out.println("Weight = " + myDog.getWeight());
    System.out.println("Height = " + myDog.getHeight());
    System.out.println("Age  = " + myDog.getAge());
  }
}

When I first started to develop for the iPhone, I realised that I needed to learn Objective-C, as this is the development language for Mac and iOS. I found it to be one of the strangest looking languages I had ever come across. Today, I really enjoy developing and working with it, so will you too.

Objective-C is an object-oriented programming language used by Apple primarily for programming Mac OS X, iPhone, and other iOS applications. It is an extension of the C Programming Language. If you have not done any OOP programming before, I would seriously recommend that you read the OOP document from the Apple Developer website.

On the other hand, if you have used and are familiar with C++, .Net or Java, learning Objective-C should be relatively easy for you to understand.

Objective-C consists of two types of files:

Most Object-Oriented development environments consist of the following parts:

For example, here is a piece of code written in Objective-C:

-(int)method:(int)i {
  return [self square_root: i];
}

Now, let's examine the code line by line to understand what is happening.

We declare a function called method and a variable i, which is passed in as a parameter. We then pass the value to a function called square_root to calculate the value and the calculated result is returned.

If we were to compare this same code to how it would be written within C, it would look like this:

int function(int i) {
  return square_root(i);
}

#import <UIKit/UIKit.h>
@Interface myClass : NSObject{
}
@end

#import "MyClass.h"
@implementation MyClass
@end

A Class can simply be defined as a representation of a type of object; think of it as a blueprint that describes the object. Just as a single blueprint can be used to build multiple versions of a car engine, a class can be used to create multiple copies of an object. In Objective-C, you will spend most of your time dealing with classes and class objects. An example of a class object is the NSObject class. NSObject is the root class of most of the Objective-C classes. It defines the basic interface of a class and contains methods that are common to all classes that inherit from it.

@interface MyClass : NSObject {
}

#import "MyClass.h"
@implementation MyClass
@end

MyClass *myClass = [MyClass alloc];

MyClass myClass = new MyClass();

The Xcode developer set of tools comprise of the Xcode Integrated Development Environment (IDE), Interface Builder, iPhone Simulator, and Instruments for Performance Analysis. These tools have been designed to integrate and work harmoniously together.

The Welcome to Xcode screen

To launch Xcode, double-click on the Xcode icon located in the /Developer/Applications folder. Alternatively, you can use Spotlight to search for this: simply type Xcode into the search box and Xcode should be displayed in the list at the top.

When Xcode is launched, you should see the Welcome to Xcode screen as shown in the screenshot below. From this screen, you are able to create new projects, check out existing projects from the SCM, and modify those files within the Xcode integrated development environment. It also contains some information about learning Xcode as well as Apple Developer resources.

The panel to the right-hand side of the screen will display any recent projects which you have opened. These can be opened and loaded into the IDE by clicking on them:

The Xcode Integrated Development Environment

The Xcode Integrated Development Environment is what you will be using to start to code your iPhone applications.

This consists of a single-window user interface, consisting of the Project Window, Jump and Navigation Bars, and the newly integrated Interface Builder designer. We will talk more about the Xcode 4 workspace environment in Chapter 2, Introducing the Xcode 4 Workspace:

Features of the iPhone Simulator

The "iPhone Simulator" simulates various features of a real iOS device.

The screenshot below displays the iPhone 4 simulator:

Below we list some of the features which you are able to test using the iPhone Simulator:

TYPE	DESCRIPTION
Screen Rotation:	Left, Top, and Right
Support for gestures:	Tap
	Touch and Hold
	Double Tap
	Swipe
	Flick
	Drag
	Pinch
Low-Memory warning simulations	Notifies all running applications whenever the amount of free memory falls below a safe threshold. This can happen when memory is allocated to objects, but never released.

Although the iPhone simulator is just a simulator to simulate certain tasks, it does come with the following limitations:

• Making phone calls

• Accessing the Accelerometer/Gyroscope

• Sending and receiving SMS messages.

• Installing applications from the App Store

• Accessibility to the camera

• Use of the microphone

• Several core OpenGL ES features

These tools are classified as profiling tools which are the instruments that handle the following:

The Xcode instruments allow you to dynamically trace and profile the performance of your Mac OS X, iPhone, and iPad applications. You can also create your own Instruments using DTrace and the Instruments custom builder.

Through the use of instruments, you can achieve the following:

The iOS4 SDK comes with over 1,500 APIs that contain some high quality enhancements and improvements which allow endless possibilities for developers to create some stunning applications. The table below provides an overview of these features:

In this chapter, hopefully you have gained a good understanding of Xcode and the development tools and the new and improved single-windowed development IDE. We have also covered some of the basics relating to Object-Oriented Programming and Objective-C. It will soon become apparent why Objective-C was chosen as the language of choice for developing Mac OS X and iOS applications.

Now that we've learned about what comprises the Xcode developer tools, we are now ready to get stuck into and learn about the new Xcode 4 workspace and development environment.

In the next chapter, we will dive right in and take a closer look at the Xcode 4 workspace environment as well as using some of the tools we have explained in this chapter. We will also start to develop a simple application using Xcode and Interface Builder.