Apple Developer

Testing iOS 4 Apps on the iPhone – Developer Certificates and Provisioning Profiles (Xcode 4)

2012-05-12T10:27:00.000+07:00

Joining the iOS Developer Program

Being a member of the iOS Developer Program should not be confused with being a registered Apple developer. Being a registered Apple developer only gives you the ability to download the iOS SDK and access to additional developer related information. Membership of the iOS Developer Program, however, allows you to set up certificates and provisioning profiles to test apps on physical devices and, ultimately, submit completed apps for possible acceptance into the Apple App Store.

Enrollment into this program currently costs $99 per year. It is also possible that your employer already has membership, in which case contact the program administrator in your company and ask them to send you an invitation to join. Once they have done this Apple will send you an email entitled "You Have Been Invited to Join an Apple Developer Program" containing a link to activate your membership. If you or your company is not already a program member, you can enroll online at:

http://developer.apple.com/programs/ios/

Having completed the enrollment process, navigate to http://developer.apple.com and click on the Member Center link located near the top right hand corner of the screen. On the resulting page enter the Apple ID and password associated with your iOS Developer Program membership to access the member center home page as illustrated in the following figure:

]]

Having gained access to the iOS Developer Program the next step is to create and install a certificate on the Mac OS X system on which you are developing your iPhone apps.

Creating an iOS Development Certificate Signing Request

Any apps that are to be installed on a physical iPhone device must first be signed using an iOS Development Certificate. In order to generate a certificate the first step is to generate a Certificate Signing Request (CSR). Begin this process by opening the Keychain Access tool on your Mac system. This tool can be found in the Applications -> Utilities folder. Once launched, the Keychain Access main window will appear as follows:

Within the Keychain Access utility, perform the following steps:

1. Select the Keychain Access -> Preferences menu and select Certificates in the resulting dialog:

2. Within the Preferences dialog make sure that the online Certificate Status Protocol (OCPS) and Certificate Revocation List (CRL) settings are both set to Off, then close the dialog.

3. Select the Keychain Access -> Certificate Assistant -> Request a Certificate from a Certificate Authority… menu option and enter your email and name exactly as registered with the iOS Developer Program. Leave the CA Email Address field blank and select the Saved to Disk and Let me specify key pair information options:

4. Clicking the Continue button will prompt for a file and location into which the CSR is to be saved. Either accept the default settings, or enter alternative information as desired at which point the Key Pair Information screen will appear as illustrated in the following figure:

iPhone iOS 5
Development
Essentials eBook

$12.99

eBookFrenzy.com

5. Verify that the 2048 bits key size and RSA algorithm are selected before clicking on the Continue button. The certificate request will be created in the file previously specified and the Conclusion screen displayed. Click Done to dismiss the Certificate Assistant window.

Submitting the iOS Development Certificate Signing Request

Having created the Certificate Signing Request (CSR) the next step is to submit it for approval. This is performed within the iOS Provisioning Portal which is accessed from the Member Center of the Apple developer web site. Under Developer Program Resources on the main member center home page select iOS Provisioning Portal. Within the portal, select the Certificates link located in the left hand panel to display the following page:

Click on the Request a Certificate button, scroll down to the bottom of the text under the heading Create an iOS Development Certificate and click on the Choose File button. In the resulting file selection panel, navigate to the certificate signing request file created in the previous section and click on Choose. Once your file selection is displayed next to theChoose File button, click on the Submit button located in the bottom right hand corner of the web page. At this point you will be returned to the main Certificates page where your certificate will be listed as Pending Approval:

If you are not the Team Administrator, you will need to wait until that person approves your request. If, on the other hand, you are the administrator for the iOS Developer Program membership you may approve your own certificate request by clicking on the Approve button located in the Action column of the Your Certificate table. Your certificate is now active and the table will refresh to include a button to Download the certificate.

Installing an iOS Development Certificate

Once a certificate has been requested and approved it must be installed on the development system so that Xcode can access it and use it to sign any applications you develop. The first step in this process is to download the certificate from the iOS Provisioning Portal by clicking on the Download button located on the certificates page outlined in the previous section. Once the file has downloaded, double click on it to load it into the Keychain Access tool. The certificate will then be listed together with a status (hopefully one that reads This certificate is valid):

Your certificate is now installed into your Keychain and you are ready to move on to the next step.

Assigning Devices

Once you have a development certificate installed, the next step is to specify which devices are to be used to test the iOS apps you are developing. This is achieved by entering the Unique Device identifier (UDID) for each device into the Provisioning Portal. Note that Apple restricts developers to 100 devices per year.

A new device may be added to the list of supported test devices either from within the Xcode Organizer window, or by logging into the iOS Developer Portal and manually adding the device. To add a device to the portal from within Organizer, simply connect the device, open the Organizer window in Xcode using the Organizer toolbar button, select the attached device from the left hand panel and click on the Add to Portal button. The Organizer will prompt for the developer portal login and password and then connect and enable the device for testing.

Manually adding a device, on the other hand, requires the use of the iPhone’s UDID. This may be obtained either via Xcode or iTunes. Begin by connecting the device to your computer using the docking connector. Once Xcode has launched the Organizer screen will appear displaying summary information about the device (or may be opened by selecting Organizer button in the Xcode toolbar). The UDID is listed next to the Identifier label as illustrated in the following figure:

Alternatively, launch iTunes, select the device in the left hand pane and review the Summary information page. One of the fields on this page will be labeled as Serial Number. Click with the mouse on this number and it will change to display the UDID.

Having identified the UDIDs of any devices you plan to use for app testing, select the Devices link located in the left hand panel of the iOS Provisioning Portal, and click on Add Devices in the resulting page. On the Add Devices page enter a descriptive name for the device and the 40 character UDID:

In order to add more than one device at a time simply click on the “+” button to create more input fields. Once you have finished adding devices click on the Submit button. The newly added devices will now appear on the main Devices page of the portal.

Creating an App ID

The next step in the process is to create an App ID for each app that you create. This ID allows your app to be uniquely identified within the Apple iOS application infrastructure. To create an App ID, select the App IDs link in the provisioning portal and click on the New App ID button to display the Create App ID screen as illustrated below:

Enter a suitably descriptive name into the Description field and then make a Bundle Seed ID selection. If you have not created any previous Seed IDs then leave the default Generate New selection unchanged. If you have created a previous App ID and would like to use this for your new app, click on the menu and select the desired ID from the drop down list. Finally enter the Bundle Identifier. This is typically set to the reversed domain name of your company followed by the name of the app. For example, if you are developing an app called MyApp, and the URL for your company is www.mycompany.com then your Bundle identifier would be entered as:

com.mycompany.MyApp

If you would like to create an App ID that can be used for multiple apps then the wildcard character (*) can be substituted for the app name. For example:

com.mycompany.*

Having entered the required information, click on the Submit button to return to the main App ID page where the new ID will be listed.

Creating an iOS Development Provisioning Profile

The Provisioning Profile is where much of what we have created so far in the chapter is pulled together. The provisioning profile defines which developer certificates are allowed to install an app on a device, which devices can be used and which apps can be installed. Once created, the provisioning profile must be installed on each device on which the designated app is to be installed. To create a provisioning profile, select the Provisioning link in the Provisioning Portal and click on the New profile button. In the resulting Create iPhone Provisioning Profile screen, perform the following tasks:

1. In the Profile Name field enter a suitably descriptive name for profile you are creating.

2. Set the check box next to each certificate to specify which developers are permitted to use this particular profile.

3. Select an App ID from the menu.

4. Select the devices onto which the app is permitted to be installed.

5. Click on the Submit button.

Now that the provisioning profile has been created, the next step is to download and install it. To do so, click on the Download button next to your new profile and save it to your local system (note that the file will have a .mobileprovision file name extension). Once saved, either drag and drop the file to the Xcode icon in the dock or into the Xcode Organizer window, which may be accessed using the Xcode Organizer toolbar button. Once the provisioning profile is installed, it should appear in the Organizer window as follows:

Enabling an iPhone Device for Development

With the provisioning profile installed select the target device in the left hand panel of Organizer window and click on the Use for Development button. The Organizer will then prompt you for your Apple developer login and password:

Once a valid login and password have been entered, the Organizer will perform the steps necessary to install the provisioning profile on the device and enable it for application testing.

Associating an App ID with an App

Before we can install our own app directly onto a device, we must first embed the App ID created in the iOS Provisioning Portal and referenced in the provisioning profile into the app itself. To achieve this:

1. In the left hand panel of the main Xcode window, select the project navigator toolbar button and select the top item (the application name) from the resulting list.

2. Select the Info tab from in the center panel:

In the Bundle Identifier field enter the App ID you created in the iOS Provisioning Portal. This can either be in the form of your reverse URL and app name (for example com.mycompany.HelloWorld) or you can have the product name substituted for you by entering com.mycompany.${PRODUCT_NAME:rfc1034indentifer} as illustrated in the previous figure.

Once the App ID has been configured the next step is to build the application and install it onto the iPhone or iPod Touch device.

iOS and SDK Version Compatibility

Before attempting to install and run an application on a physical iPhone device it is important to be aware of issues relating to version compatibility between the SDK used for the development and the operating system running on the target device. For example, if the application was developed using version 4.3 of the iOS SDK then it is important that the iPhone on which the app is to be installed is running iOS version 4.3 or later. An attempt to run the app on an iPhone with an older version of iOS will result in an error reported by Xcode that reads “Xcode cannot run using the selected device. No Provisioned iOS devices are available. Connect an iOS device or choose an iOS simulator as the destination”.

The absence in this message of any indication that the connected device simply has the wrong version of iOS installed on it may lead the developer to assume that a problem exists either with the connection or with the certification or provisioning profile. If you encounter this error message, therefore, it is worth checking version compatibility before investing what typically turns into many hours of effort trying to resolve non-existent connectivity and provisioning problems.

Installing an App onto a Device

Located in the top left hand corner of the main Xcode window is drop down menu which, when clicked, provides a menu of options to control the target run environment for the current app.

If either the iPhone or iPad Simulator option is selected then the app will run within the corresponding simulated environment when it is built. To instruct Xcode to install and run the app on device itself, simply change this menu to the iOS Device setting. Assuming the device is connected, click on the Run button and watch the status updates as Xcode compiles the source code. Once the code is built, Xcode will need to sign the app using your developer certificate. If prompted with a message that reads “codesign wants to sign using key “<key name>” in your keychain select either Allow or Always Allow (if you do not wish to be prompted during future builds). Once signing is complete the status will change to “Installing <appname>.app on iPhone…”. After a few seconds the app will be installed and will automatically start running on the device where it may be tested in a real world environment.

Deploying Your App to Your Own iPhone / iPad / iPod

2012-05-12T10:26:00.002+07:00

When I first learned how to write an iOS application, I found that the biggest challenge wasn't in learning Objective-C, nor was it in becoming familiar with the Xcode IDE. Instead, the main difficulty was in getting my app on to my own device! Unfortunately, many of the books and tutorials assume you'll figure this out on your own... and as I learned, the process was not trivial:

I had to create a public/private key pair (via "Keychain"),
Generate a certificate request (via "Keychain"),
Login to the Provisional Portal at the Apple Developer Site,
Create and download a development certificate with the certificate request,
Find & register the UDID of my device,
Create an "App ID",
Create and download a provisional profile which links my developer certificate, UDID, and App ID together,
Install the certificate & profile into Xcode...

... all for the simple purpose of testing out my app on my iPhone!

Well, thankfully, Apple has reduced this complexity with the release of Xcode 4. Here are the steps you need to take, in order to deploy your apps to your own device (for the purpose of developing & testing only... Ad Hoc & iTunes App Store distribution is still a much more involved process):

Register as a Paid Apple Developer. Only paid accounts can deploy to actual devices.
Open up Xcode 4's Organizer, and select "Provisioning Profiles" in the left side menu:
On the bottom of the right side, 'check' the checkbox labeled "Automatic Device Provisioning":
Plug your device into your computer. Select your device in the left side menu, and click the "Use for Development" button:
You will be prompted to log in to your Apple Developer account. Enter your credentials here:
Xcode will likely you tell you that it doesn't recognize the version of iOS. Allow it to collect the necessary information when prompted:
After this has finished, you're done! You should now see your device listed in the top left list of "Schemes" in Xcode:

That's it - no more dealing with keys, certificates, UDIDs, App IDs, etc (at least for testing on your own device). Also, note that you shouldn't need to repeat these steps for the same device on the same computer. Once your device has been configured, it should be available for all of your Xcode iOS projects!

Learn Objective-C: Day 4

2012-05-05T01:27:00.003+07:00

Welcome to part four of this series on Objective-C. So far, we’ve looked a lot at theory and the principles and functionality of the language to get a good idea of how it works. Today, we will be making a simple class similar to the car example we looked at in previous parts of this series. Our class will take the details of a car, allowing us to get and set the values held. After today’s example you should be able to create your own classes in Xcode and toy around with them.

So far, we have had some great feedback via email, twitter and comments. Itʼs great to see so many people are interested in this subject and itʼs even better to see that so many of you are trying it out for yourself and asking some great questions. Keep it up!

Getting Started

Start by firing up Xcode and creating a new project. Under the Mac OS X separator, click Application, then click Command Line Tool. Finally, change the drop down box to set the type to Foundation.

Save the project as whatever you want, I called mine CarApp. Once the project window appears, we need to create a new class. Hit Command-N (or File > New File), navigate to Cocoa Class under Mac OS X and select Objective-C class. Make sure Subclass of is set to NSObject and press Next. Name your class SimpleCar and ensure that a .h file will be created, then save it.

Our class now exists, but it does nothing. Let’s change that by giving it some code. Remember that in Objective-C we split our code into two parts: interface and implementation. It makes logical sense to work on the interface first, so that’s where we’ll start.

Coding the Interface

Open up the SimpleCar.h file and in its current state it should look like this (I’ve omitted the comment header from below)

view plaincopy to clipboardprint?
#import <Cocoa/Cocoa.h>  
  
@interface SimpleCar : NSObject {  
  
}  
  
@end  

First of all, we’re including Cocoa.h, which gives us access to such things as NSString, NSMutableString, etc. Then, we create our class (SimpleCar) as a subclass of NSObject.

Now we need to decide on what information our class needs to store. Since we’re using a car as our example we need to store car-related information, such as:

Make
Model
VIN

There’s a lot more we could go into, but for now that will do. For each of these properties, we need to store them in a variable suited for that type of data. Make and model will be a range of characters (such as text, number and possibly punctuation) so it makes sense to use a string. The VIN (Vehicle Identification Number) will only be a number so that’s what we’ll use. Our code now looks like this (header omitted):

@interface SimpleCar : NSObject {  
    NSString* make;  
    NSString* model;  
    NSNumber* vin;  
}  
  
@end  

We previously said that in order to get or set data from a class, a method should be used. So to set the variables, we need to add methods. To do this, we’ll make four: one will set the make, one the model, one the VIN, and a final method will set both make AND model (just to show you how to use multiple arguments).

view plaincopy to clipboardprint?
@interface SimpleCar : NSObject {  
    NSString* make;  
    NSString* model;  
    NSNumber* vin;  
}  
  
// set methods  
- (void) setVin:   (NSNumber*)newVin;  
- (void) setMake:  (NSString*)newMake;  
- (void) setModel: (NSString*)setModel;  
  
// convenience method  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel;  
  
@end  

We declare methods after the curly bracket and before @end. By placing a dash (minus sign) before the method, we tell the compiler we’re about to declare an instance method. An instance method is a method executed on our instance. Conversely, a plus sign indicates that the method being invoked is a class method that does not need an individual object instance to execute -more on this later.

Our first method returns void, is called setVin and takes an NSNumber as an argument. Our second method is similar, it returns void, is call setMake, and takes an NSString as an argument. The third is the same, with a different name.

Our final method also returns void but takes two parameters: newMake and newModel, both of which should be NSString. The naming used in this method is similar to how most Objective-C methods are named: in plain English. So when you read the method allowed it’s obvious that the method will “Set make and model.” It’s important to remember that the method name in this case is ‘setMake:andModel:’ – all the argument titles are included in the method name.

An important note is that we use (void) because our methods do not need to return anything. Since all they are doing is setting data and do not need to return anything back (such as a success message) we simply use void.

Next, we will add the methods we will use to get the values. Although we call our methods get and set methods, we only usually use “set” in the title and omit “get.” How you name your methods is ultimately up to you, but dropping “get” is common and helps avoid confusion.

Our new set of methods looks like this:

view plaincopy to clipboardprint?
// set methods  
- (void) setVin:   (NSNumber*)newVin;  
- (void) setMake:  (NSString*)newMake;  
- (void) setModel: (NSString*)newModel;  
  
// convenience method  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel;  
  
// get methods  
- (NSString*) make;  
- (NSString*) model;  
- (NSNumber*) vin;  

Notice that the get methods use the same names as the variables in the class. This will make it simple when we fetch the variables. It will be as if we’re accessing the variables directly, essentially making the get methods appear transparent.

Coding the Implementation

So now that the interface is in place and we know what the class will do, we need to implement our methods. Looking back, we have four methods we need to implement: setVin, setMake, setModel and setMake:andModel. Before we move files, copy the method declarations to your clipboard (Cmd+C). Now close SimpleCar.h and fire up SimpleCar.m in the editor, pasting the method declarations in between the @implementation and @end, like so:

view plaincopy to clipboardprint?
@implementation SimpleCar  
  
// set methods  
- (void) setVin:   (NSNumber*)newVin;  
- (void) setMake:  (NSString*)newMake;  
- (void) setModel: (NSString*)newModel;  
  
// convenience method  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel;  
  
// get methods  
- (NSString*) make;  
- (NSString*) model;  
- (NSNumber*) vin;  
  
@end  

Obviously this isn’t right, so what we need to do is swap the semi-colons for curly brackets where the inner workings of the method will go, like this:

view plaincopy to clipboardprint?
@implementation SimpleCar  
  
// set methods  
- (void) setVin: (NSNumber*)newVin {  
  
}  
  
- (void) setMake: (NSString*)newMake {  
  
}  
  
- (void) setModel: (NSString*)newModel {  
  
}  
  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel {  
  
}  
  
// get methods  
- (NSString*) make {  
  
}  
  
- (NSString*) model {  
  
}  
  
- (NSNumber*) vin {  
  
}  
  
@end

Now we need to give our methods some code. Let’s start with the getter methods as they’re straightforward enough. For each getter method, all we need to do is make sure that the function returns what it is intended to return. For this reason, our getter methods look like this:

view plaincopy to clipboardprint?
- (NSString*) make {  
    return make;  
}  
  
- (NSString*) model {  
    return model;  
}  
  
- (NSNumber*) vin {  
    return vin;  
}  

Remember: the methods are returning the variables we defined in the interface file. Don’t get confused between the method names and the variable names.

That’s pretty straightforward, when we call make (for example), then make returns the pointer to an NSString – in this case to the make variable. The same happens for model and vin (except of course vin returns a number).

Now for the setter methods, first we’ll look at the code and then we’ll go through it afterwards. Our setter methods look like this:

view plaincopy to clipboardprint?
// set methods  
- (void) setVin: (NSNumber*)newVin {  
  
    [vin release];  
    vin = [[NSNumber alloc] init];  
    vin = newVin;  
  
}  
  
- (void) setMake: (NSString*)newMake {  
  
    [make release];  
    make = [[NSString alloc] initWithString:newMake];  
  
}  
  
- (void) setModel: (NSString*)newModel {  
  
    [model release];  
    model = [[NSString alloc] initWithString:newModel];  
  
}  
  
// convenience method  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel {  
  
    // Reuse our methods from earlier  
    [self setMake:newMake];  
    [self setModel:newModel];  
  
}  

The set methods are a bit trickier than our get methods. We want to alloc the values that are passed into each method so that they are owned by the class. We first release these variables in case they are already alloc’d. If they are not alloc’d, then they are nil, and nil objects ignore messages passed to them. We will cover these issues more when we discuss memory management.

Because we actually allocated memory for our objects in the setter methods, we need to be sure we release them when the object is released from memory. To do this, we need to add a custom dealloc method, like so:

view plaincopy to clipboardprint?
-(void) dealloc  
{  
    [vin release];  
    [make release];  
    [model release];  
    [super dealloc];  
}  

Testing the Class

Congratulations! If you followed everything above then you should now have a working class (if not, download the source files available with this article). So, let’s test it out.

Open up the main file of your project (mine is called CarApp.m) which by default should look something like this:

view plaincopy to clipboardprint?
#import <Foundation/Foundation.h>  
  
int main (int argc, const char * argv[]) {  
  
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];  
  
    // Insert custom code here...  
    NSLog(@"Hello, World!");  
  
    [pool drain];  
    return 0;  
}  

Delete the comment and NSLog line as we won’t be needing them right now.

In order to begin using our class, we need to pull it into the program. Underneath the original #import line add the following line:

view plaincopy to clipboardprint?
#import "SimpleCar.h"  

Our class is now available for use, but we need to create an instance of it in order to test it out. Here’s the code used in total:

view plaincopy to clipboardprint?
#import <Foundation/Foundation.h>  
#import "SimpleCar.h"  
  
int main (int argc, const char * argv[]) {  
  
  NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];  
  
    SimpleCar *myCar = [[SimpleCar alloc] init];  
  
    NSNumber *newVin = [NSNumber numberWithInt:123];  
  
    [myCar setVin:newVin];  
    [myCar setMake:@"Honda" andModel:@"Civic"];  
  
    NSLog(@"The car is: %@ %@", [myCar make], [myCar model]);  
    NSLog(@"The vin is: %@", [myCar vin]);  
  
    [myCar release];  
  
  [pool drain];  
  
  return 0;  
}  

First of all we create a pointer to an instance of SimpleCar called myCar. Next we use alloc and init – these will be discussed later on down the line.

Next, since we need to pass an NSNumber to the setVin method, we make one here. Again we create a pointer to an NSNumber instance called newVin and we initiate it with the integer value of 123. The constant ’123′ is an integer, which is why we use numberWithInt.

Next, we invoke our methods, first of all we put who should receive the message (myCar) and then we use the method setVin. After the colon is the value we are supplying to the method which is the NSNumber we created before. Next we do the same but call the setMake method with two parameters. The reason these parameters are preceded by an @ sign is to tell the compiler that the following is a string.

Finally, we release myCar as we are done with it – more on this later in the series under memory management.

Our class is now working, and in order to see the proof, we added some NSLog statements to print the values to the console. If you open up the console (Run > Console) and then build and run your app, you should see output similar to this:

Property and Synthesize

If you look at the code above, a lot of it seems quite pointless and excessive. For example, in our getter methods all we are doing is returning an instance variable – but this takes up three lines of code to do something simple. Also, in our setter methods, we are just setting instance variables – essentially all of our methods, except our method that takes two arguments, seem bloated and in the way. Objective-C solves this with @property and @synthesize, which replace our accessor methods and make for much neater coding.

This is what our new interface file looks like using properties:

view plaincopy to clipboardprint?
#import <cocoa cocoa.h="">  
  
@interface SimpleCar : NSObject {  
    NSString* make;  
    NSString* model;  
    NSNumber* vin;  
}  
  
@property(readwrite, retain) NSString* make;  
@property(readwrite, retain) NSString* model;  
@property(readwrite, retain) NSNumber* vin;  
  
// convenience method  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel;  
  
@end  
</cocoa>  

Wow, that really is a lot shorter. So what’s happening with the @property declarations? First we tell the compiler we are declaring a property by using @property, then we follow with attributes for this property. The attributes are the read/write status of a property and some memory management. We have used readwrite for all, which means getter and setter methods are dynamically created for our instance variables (we could of used writeonly or readonly for just one or the other). The reason we use retain will become clear next time when we cover memory management.

Before this can work, we need to implement it in our implementation file, we do this using @synthesize. Our new implementation file looks like this:

view plaincopy to clipboardprint?
#import "SimpleCar.h"  
  
@implementation SimpleCar  
  
@synthesize make, model, vin;  
  
- (void) setMake: (NSString*)newMake  
        andModel: (NSString*)newModel {  
  
    [self setMake:newMake];  
    [self setModel:newModel];  
  
}  
  
@end  

Doesn’t that look better? Think of it like this, @property replaces all of the interface method declarations for getters and setters, and @synthesize replaces the actual methods themselves. The getters and setters are now dynamically created and we don’t need to waste time creating them unless we need to do something really special.

Wrapping Up

You should now have a firm grip of classes, objects and instances. Sure, you’re not creating classes that will change the world yet, but this stuff takes time. It’s better to learn by example, so if you’re not coding as you go along then be sure to at least download the source files and have a read through (and a compile) to ensure you’re 100% on what’s going on.

Next Time

We’ve mentioned memory management a lot in this tutorial, it’s a very important subject that needs to be addressed (pun intended), so we’ll dive in to that next time. True, it isn’t the most fun subject or the easiest to come to terms with, but it’s absolutely crucial if you want to become a skilled Objective-C programmer.

Challenge

This week’s challenge may be a little tricky, but we’ll see how you get on. First of all, if you haven’t copied all the code above, download the source files that are included with this article. The challenge is to add another class to the project, but this time it should be a subclass of SimpleCar (remember, we define the parent class in the interface file). If you can do that, play around and use the inherited methods and try to add your own for things such as: engine size, doors or height.

Remember: if you have any questions or queries, drop a comment below or shoot me a message on Twitter. The only stupid question is the one you didn’t ask – this series is about learning so feel free to ask away!

Installing Tomcat on Mac OS X

2012-05-04T10:04:00.000+07:00

To get Tomcat, visit the following link: http://tomcat.apache.org/. Once there, click on the Tomcat 5.5 link under the Download heading. Under Core, select the tar.gz file.

Download the tar.gz file. Mac OS X will probably extract the file to a .tar file in your downloads directory. Move this .tar file to a location on your computer where you would like tomcat. For purposes of this guide, the location will be /Users/user. Double-click the tar to extract it. This should create a directory in /Users/user named something like apache-tomcat . . . Rename this to something simple like tomcat. At this point, you should have the following directory on your machine:

/Users/user/tomcat

There is a file called startup.sh located in the the /Users/user/tomcat/bin directory that needs edited. Open EditRocket and open startup.sh Add the following two lines after the line in startup.sh that starts with EXECUATBLE. Note that for Snow Leopard, you can use 1.6 instead of 1.5 after the Versions text in the first line listed below.

export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home
export CATALINA_HOME=/Users/user/tomcat

To start Tomcat, open up a Terminal window (Applications -> Utilities -> Terminal). cd to the tomcat bin directory by typing the following:

cd /Users/user/tomcat/bin

Type the following:

sh startup.sh

This will start Tomcat. To shutdown tomcat, type sh shutdown.sh

To test the tomcat installation, enter the following in your web browser:

http://localhost:8080/

If the apache tomcat page shows up, the installation was successful.

There is a sample web application called jsp-examples located in the webapps directory under the tomcat installation directory. This location can be used to test your own JSP pages, or you can use the files contained in this directory as a template for creating your own web application.

The jsp-examples can be accessed in your web browser using the following URL: http://localhost:8080/jsp-examples/

"EGO" Xcode Theme for Xcode 4 + EGOv2

2012-05-03T00:26:00.000+07:00

Almost two years ago now, we posted our Xcode theme, "EGO". It's been significantly more popular than I ever thought, we've seen a lot tweets about, we've seen it in screen casts, and it even made an appearance in the product launch video for robotcat's Outside app. There's no real metric for these things, but it seems to be one of the more popular third party Xcode things (we're number one in Google!).

So, with the GM release of Xcode 4, we've gone ahead and ported our original EGO theme to the new Xcode 4 file format.

We're also posting a alternative version of EGO, EGOv2. It's based on EGO but has some key differences: New background color, new comment colors, themed console, and other minor tweaks and slight HSB adjustments. Here's a comparison:

Original EGO Theme

New EGOv2 Theme

To install the themes, run the following blocks of code in Terminal:

Original EGO

mkdir -p ~/Library/Developer/Xcode/UserData/FontAndColorThemes; cd ~/Library/Developer/Xcode/UserData/FontAndColorThemes; curl -O http://developers.enormego.com/assets/egotheme/EGO.dvtcolortheme

New EGOv2

mkdir -p ~/Library/Developer/Xcode/UserData/FontAndColorThemes; cd ~/Library/Developer/Xcode/UserData/FontAndColorThemes; curl -O http://developers.enormego.com/assets/egotheme/EGOv2.dvtcolortheme

Now just restart Xcode, go to Preferences > Fonts & Colors, and select "EGO" or "EGOv2" from the color theme drop down.

Note: Both themes now use Menlo Bold 13pt. This might not be for everyone, but I've found it much easier on the eyes and the bold seems to render nicer than regular, to me. Feel free to change!

from: http://developers.enormego.com/view/ego_xcode_theme_for_xcode_4_egov2

Learn Objective-C: Day 3

2012-05-02T23:31:00.000+07:00

Welcome to part three of this series -I hope youʼre enjoying it! Last week we looked at how we separate classes in to separate files (interface and implementation), this week weʼre going to look at classes again, but a little bit more in depth. Weʼll also take a peak at inheritance and how it works, along with variable scope.

In Review: Classes & Objects

Letʼs review what we have learned about classes in this series so far. If you donʼt know any of this, feel free to skim back to the last tutorial to re-cap. Ok, so, what are classes?

A class is a collection of encapsulated data and custom methods. A class may hold many different kinds of data, and the class methods usually (but not always) perform action related to that data. In Objective-C, a class is usually composed of two files: an interface file and an implementation file. The interface file uses the .h file extension by convention and is where the person using the class can quickly find the methods and data members available to the class. The implementation file uses the .m file extension by convention and is where the majority of the code resides because it contains the actual implementation of all the functions declared in the interface.

So, what makes a class different from an object? What is an object? An object is an instance of a class. Think back to our example with the car in the last part of the series. Where car is the class, then myCar,dansCar, and yourCar would all be objects because they are instances of the car class.

Classes from Apple (and some history)

Before we carry on, Iʼd like to share a few (of many) common classes youʼll be using a lot that are provided by Apple, but first a quick history lesson.

Many classes Apple provides are prepended by the abbreviation “NS”, which stands for NextStep. When Steve Jobs left Apple, he founded NeXT, creating workstation computers that ran on its operating system. The object orientated programming language used on those machines was called NeXTSTEP, which is where we get the “NS” from. When Apple ʻacquiredʼ (another history lesson in itself) NeXTSTEP, they decided to base Mac OS X on NeXTSTEP.

Here are some simple, common classes weʼll see a lot of:

NSString is a string of text that is immutable.
NSMutableString is a string of text that is mutable.
NSArray is an array of objects that is immutable.
NSMutableArray is an array of objects that is mutable.
NSNumber holds a numeric value.

Weʼll learn many more later on, but for now the above will come in handy. Youʼre probably wondering what mutable and immutable means, which is an entirely reasonable question. If an object is immutable that means when we create the object and assign a value then it is static. The value can not be changed. If an object is mutable then it is dynamic, meaning the value can be changed after creation.

Pointers and Initializing

Letʼs say we want to make a static string of text and log it, how would we go about it? In our code it would look something like this:

view plaincopy to clipboardprint?
#import <Foundation/Foundation.h>  
  
int main (int argc, const char * argv[]) {  
  
    NSString *testString;  
    testString = [[NSString alloc] init];  
    testString = @"Here's a test string in testString!";  
    NSLog(@"testString: %@", testString);  
  
    return 0;  
  
}  

I created this file in XCode by going to File > New Project > Mac OS X > Application > Command Line Tool > Type: Foundation (quite a journey!) and editing the implementation (extension: .m) file in the project.

There are quite a few things here that are new, so letʼs examine the above piece by piece.

First of all, we import the foundation library (this is because we set type to Foundation in the new project window before).

view plaincopy to clipboardprint?
int main (int argc, const char * argv[]) {  

This declares the initial function that will be called when our program begins execution. The two parameters separated by a comma are for passing arguments to our application. For now, donʼt worry about these as we wonʼt be needing them right now.

NSString *testString; testString = [[NSString alloc] init];  

We now create a pointer to an NSString object called testString. Once the first line of this is finished, no string exists yet, only a pointer to a string that we have not yet created. On the next line, we create the string our pointer points to.

We could have alternatively written the last line like this;

testString = [NSString alloc];  
[testString init];  

This may seem a little confusing at first. In the first version, we have nested the statements within brackets on the same line, whereas in the second we have separated the statements into two lines. The method init initializes all the instance variables in the class.

view plaincopy to clipboardprint?
testString = @"Here's a test string in testString!";  

This line is pretty self explanatory, the reason we prepend the quotes with an @ sign is to tell the compiler that the following text is an NSString.

NSLog(@”testString: %@”, testString);

Here we log some information to console. XCode has a debugger built in that you can find under the Run menu. It is very useful when developing an application to log when events are happening and the values of certain variables – it can help when troubleshooting your application and debugging problems. This method works like printf (remember from the first week?) where we supply a string of text with a replacement character (%@ means an Objective-C object).

Finally we return 0, which we know just tells the operating system that the application ended with no problems.

Inheritance

Remember when we made our NSString earlier, we used the init method? Well NSMutableString, NSArray and in fact, every single NS class, also uses init. Seems a lot of wasted code to put the init method in each class, right? It would be, thatʼs why init is usually only implemented once, in the root class known as NSObject. Because classes inherit from each other, a class that is created as a child of another, parent class will automatically gain access to the parent class methods.

Letʼs take NSMutableString for example. NSMutableString has NSString for a parent (making it a child), meaning it inherits from NSString. Meanwhile. NSString has NSObject as a parent, so it inherits from NSObject.

So for example, NSObject has a method called init, so each subclass has this method implemented – which is called a class method. As a matter of fact, the init method in NSObject doesn’t actually do anything it simply returns self. The reason for this is that methods can be overwritten. So the NSArray class may override the init that it inherits to add functionality to it – such as making sure memory is available or preparing any instance variables it may need.

As demonstrated, this is useful because it means that in addition to inheriting from classes we can also extend classes. When we extend a class, we take an existing class and add additional functionality to what is already available. This means you could create your own version of NSString with additional methods, such as a method to fill the string with random text or perform some sort of character encoding.

Summary

At this point, the fundamentals of how classes work should be clear. To test your comprehension, see if you can answer the following questions in your mind:

What is the difference between a class and an object?
Why do we use classes?
Why is inheritance useful?

Since classes are such an important part of Objective-C, itʼs important to really feel comfortable working with them. Last week we started looking at classes and this week we have gone into more depth. Next week, you may be glad to hear, weʼre going to move away from the theoretical side and start working on our own simple class or two to perform simple tasks.

Homework

Since we have mainly done theory so far, your homework this week is to surf Appleʼs developer website (you should have done this last week) and look at some of the classes available. If you donʼt know where to start, start with something such as NSString. Youʼll become more comfortable with the details of the parent class, the methods, and so on. This will be important later on when youʼre using classes outside of this series and you want to know what methods they inherit or use.

Next Time

Weʼll get more practical next week with some class coding. Classes really are central to Objective-C, so itʼs mega important that you come to grips with them and the goal of this series is to really ensure that you do!

As usual, if you have any questions or comments, you can reach me by dropping a comment or email. If youʼd like to get in touch with me personally and get a quick answer, send me a tweet!

Learn Objective-C: Day 2

2012-05-01T13:17:00.003+07:00

Welcome to part two of this introductory series on Objective-C. After spending last week reviewing the fundamentals of the C language upon which Objective-C is built, this week we will transition to focusing on what makes Objective-C such a great language for software development. Specifically, we will discuss the fundamentals of Object Oriented Programming (OOP) and demonstrate how to create a class and send messages to objects in Objective-C.

Object Orientated Programming

Why do we have Objective-C? Why not just use the underlying C language? The reason we have Objective-C is to give us an object oriented playground within which to build our applications. OOP is a programming paradigm that attempts to allow developers to think about software design in terms of objects and attributes instead of variables and functions. Specifically, OOP attempts to obtain data abstraction, encapsulation, modularity, polymorphism, and inheritance. The topic of OOP could easily fill a book (or a tutorial series) on its own, so instead I’ll introduce you to the basic principles by way of example.

Imagine that you have a car. You can think of your car as an object. There are many other cars in the world and you might even own more than one. Your car has various properties to it: make, model, color, engine type, and many more. In Object Oriented Programming terms, we would call the abstract concept of a car a “class” and the individual car that you own an object or instance (instantiated object) of the class. When a new car is manufactured, a new instance of the car class is instantiated (or created) and given its own set of properties.

Still a little fuzzy? Another great analogy is that of the cookie and the cookie cutter. The class is the cookie cutter, and the object is the cookie.

So, why think in terms of objects? One of the best reasons is because this is how your brain naturally conceptualizes life in the real world, and there are many benefits to being able to abstract software development in similar terms.

Classes (and hence objects) are made up of methods and attributes. If you come from another programming language, you may be more familiar equating methods with functions and attributes with variables. We will discuss each in turn next.

Methods

So we have an “instance” of a car, now that what do we do with it? Well, we drive it and fill it with petrol, among other things. Driving and filling with petrol apply only to the cars that we use, meaning that when we fill up a car or drive a car, we are only impacting one instance, and not all the cars in the world. Therefore, filling up the car instance is considered an instance method. Itʼs something we do to our instance and only our instance.

On the other hand, if we ask the original car class how many colors of car are available, this is a class method because we are no longer only talking about the car we drive around but all cars in general.

Many of these principles become more clear with use, so letʼs look at a little bit of syntax.

In Objective-C, we call object methods by passing messages. When we want to know how much gas is in our instance of car, then we send a message to our instance and the message is the method we want to apply. Programmatically it looks like this:

[recipient message];  

The brackets indicate we are sending a message. The first parameter is who should receive this message and the second parameter is what the message actually is. Finally, we end with a semi-colon as is common to most programming languages.

So, with our previous example in mind, this is how we would interact with our instance of car to add gas to the tank;

[dansCar addGas];  

The example above assumes that we have instantiated an instance of the Car class and named it “dansCar.” We then pass the “addGas” message to the object “dansCar,” which is the equivalent of calling a function. In another language, this line might look like:

dansCar.addGas();  

Attributes

Letʼs say our car class has a gas tank thatʼs stored as a percentage. For example, if the gas tank is at 50% then it is half-full and if it is at 100%, it means it is full to the brim. Now, if we want to know how much gas is in the tank, we donʼt just directly take that information from an attribute. Instead, we would use an accessor method to access the internal variable for us. Likewise, when we want to fill the tank, we donʼt just give the gas tank attribute a new percentage, we use a setter to update the attribute for us. This process is known as data encapsulation.

What we mean by data encapsulation is that data is contained (so to speak) by methods meaning to access it we need to use methods. Some of you who have programmed in other languages and havenʼt heard of data encapsulation may be wondering why we do things this way. The answer is that by encapsulating data, there is a nice cushion between the developer of a class and the user of a class. Because the class methods manage and maintains the attributes within the class, they can more easily maintain data integrity. Another major benefit is that when a developer distributes his class, the people using it donʼt have to worry about the internals of the class at all. A developer may update a method to make it faster or more efficient, but this update is transparent to the user of the class as he/she still uses the same method with no change to his/her code.

This brings us nicely on to the next section weʼre going to look at, which is how Objective- C separates interface from implementation.

Interface and Implementation

When you create or work with a simple class in Objective-C you will see that it, by default, has two files. One is the implementation file which is a file that ends with a suffix of .m and the interface file which is a file that ends with a suffix of .h.

Interface

view plaincopy to clipboardprint?
#import <cocoa cocoa.h="">  
  
@interface Car : NSObject {  
  
    //This is where attributes go  
    float fillLevel;  
  
}  
  
//This is where methods go  
- (void)addGas;   
  
@end  
</cocoa>  

First of all, weʼre importing Cocoa.h which is a standard library with a lot of reusable code that we can use inside our app.

Next, weʼre declaring that this is the interface for the Car, but weʼre also putting NSObject into that declaration. Adding “: NSObject” means that the Car class inherits from the NSObject class. We’ll talk more about inheritance in a future tutorial.

Our instance variable “fillLevel” is declared next, and we specify that it is of the “float” data type so we can easily represent a percentage.

The next line declares our “addGas” method. The “-” indicates that this is an instance method, not a class method. The “(void)” portion means that the method will not return anything back when it finishes executing. If the class was going to return an integer, this would be changed to “(int)” and the same for any other data type. Finally, we finalize the method declaration with a semicolon.

Implementation

view plaincopy to clipboardprint?
#import "Car.h"   
  
@implementation Car  
  
-(void) addGas {  
    // code goes here to add gas  
}  
  
@end  

The implementation in this case contains the method to add gas to the tank. We also import Car.h, which is the interface file. Where our addGas method sits, we could add many more methods, but today’s scope is to simply get you to understand how classes work rather than make a fully-fledged class.

Next Time

Next time weʼll be looking more in depth at methods and at using variables with methods (as well as the basics of managing variables in Objective-C). This tutorial wasn’t too long as itʼs often a bit confusing for new developers as to why we separate classes in to more than one file. If youʼre feeling at all confused then please re-read the above or ask questions in the comments section below. Classes will be a constant reoccurrence in this series and itʼs important you understand how they work.

Challenge

Seeing as this part of the series was fairly theoretical, thereʼs not too much you can do to practice. However, I do recommend this week that you sign up for Appleʼs developer website as itʼs an invaluable reference. Once youʼve done that, have a snoop around some of their downloadable classes and download a few simple ones. You donʼt need to understand all of the code, just look at how the classes are formed and separated across files.

Learn Objective-C: Day 1

2012-04-30T13:00:00.000+07:00

Welcome to my series on coming to grips with the awesome language that is Objective-C. Throughout this small series of articles, my aim is to take you from no prior experience with Objective-C to using it confidently in your own applications. This isnʼt a rush job – so donʼt expect to just skim through the basics and be away – weʼll be going through not just the bare essentials, but also the best practices you can apply to ensure your code is the best it can be. Letʼs jump straight in!

What is Objective-C?

If youʼre reading this series then Iʼll hazard a guess that you already know, but for those of you who donʼt, donʼt worry as by the end of this part youʼll know what it is back-to-front and inside-out.

Objective-C is an object oriented language which lies on top of the C language (but I bet you guessed that part!). Itʼs primary use in modern computing is on Mac OS X as a desktop language and also on iPhone OS (or as it is now called: iOS). It was originally the main language for NeXTSTEP OS, also known as the operating system Apple bought and descended Mac OS X from, which explains why its primary home today lies on Appleʼs operating systems.

Because Objective-C is a strict superset of C, we are free to use C in an Objective-C file and it will compile fine. Because any compiler of Objective-C will also compile any straight C code passed into it, we have all the power of C along with the power of objects provided by Objective-C.

If youʼre a little confused at this point, think of it this way: everything C can do, Objective-C can do too, but not the other way around.

What will I need?

Throughout this series, we will not focus on building applications for the iPhone. Instead, we will concentrate more on the language itself and for this reason all you will need is a Mac with a compiler such as GCC. If youʼve installed the developer tools from Apple (Xcode, Interface Builder, etc), then GCC should already be installed. If not, then head to Appleʼs developer website and get yourself a free copy.

As far as prerequisites go, while I donʼt expect you to have a full background in computer science, some knowledge of programming in general or of C in particular would definitely be a bonus. If you donʼt have much prior programming experience, donʼt worry -youʼll pick it up in no time!

If youʼre running Windows (which is unlikely as this tutorial is aimed at iPhone developers) you can still compile Objective-C on your system using a compiler such as CygWin or MinGW. This tutorial series is catered to Mac users, but if you are using Windows and encounter any problems then be sure to leave a comment and Iʼll see if I can help.

Compiling your code

Before you can see your code in action, you need to be able to compile it into something executable. Hopefully you now have your copy of GCC ready. Compiling is really easy, a simple one line command.

NOTE:
Compiling is the process of “translating” a high-level computer language, like Objective-C or PHP, into a low-level machine code that can be processed by a computer when the program is executed.

All the programs that we see running in our fancy Mac OS operating system consist of a series of instructions that are visually displayed to us in a GUI, or Graphical User Interface. In contrast to the GUI program interaction with a mouse that most of us are familiar with, it is possible to issue commands directly to the operating system through a text-based interface known as a “terminal” or “command line.”

The command line application in Mac OS is called Terminal and can be found in Applications -> Utilities. Go ahead and open Terminal now (you can also search for it in Spotlight). Terminal has several basic commands you should be aware of in order to properly utilize it. One of the most important commands to know is cd, which stands for “change directory.” This command allows us to change where in the filesystem Terminal is reading from. We canʼt just tell Terminal to compile our file if we donʼt show it where the file is first! To switch to a desired directory, you can use a full path such as:

cd /Users/MyName/Desktop/Test  

You can also use relative paths, allowing you to only type a single folder name in some cases. For example, if youʼre already in your Desktop folder, you could simply type:

cd Test  

to get to the Test folder.

What if you want to see where you currently are? The immediate folder name is displayed before the prompt (the bit where you type). For example, if your prompt says Dan- Walkers-MacBook: Desktop iDemonix$ I can assume Iʼm in the Desktop folder. If you aren’t sure, you can also type pwd to display the absolute filepath of the current location.

If you want to list what files and folders are in the current folder, use the list command: ls. Finally, if you wish to go up a directory to a parent folder, type “cd .. “. So, if we were in the Test folder, which is inside the Desktop folder, but we wanted to go to the Desktop folder instead, we could type cd .. to go up to the parent directory, Desktop. If we wanted to get to the home directory we would type cd ../.. to go up two levels. Alternatively, to get to the home directory you can just type cd ~ from anywhere.

When using the Terminal application, compiling looks like this:

gcc inputfile.m -o outputfile  

Youʼve probably already guessed how it works: inputfile.m contains our code (.m is the extension used for Objective-C files) and -o tells gcc we want our executable to be called whatever we specify next, which in the example above is outputfile. To run our creation after compiling, we simply type:

./outputfile  

Simple.

When you compile, the compiler will generate any errors, notifications or warnings related to the syntax of your code. Errors generated when compiling are understandably referred to as “compile-time” errors, and this is often the most stressful part of writing an application (especially when your code isnʼt compiling because you put a single character in the wrong place or forgot to end a line with a semi-colon). Compiling can also take time when youʼre writing large applications consisting of multiple files, which is also another reason why compiling can be a tedious experience. This fact has led to a ubiquitous programmer joke often seen on the t-shirts of men with unkempt beards: “I’m not slacking off. My code is compiling.”

The Basics

Objective-C itself isnʼt that hard to learn. Once you get to grips with the basic principles, you can pick the rest up as you go along pretty easily. You do need to have an understanding of the fundamentals of C programming though, and that is what the rest of this tutorial will cover.

Letʼs look at a basic application in C:

view plaincopy to clipboardprint?
#include <stdio.h>  
int main(){  
    printf("Hello World\n");  
    return 0;  
}  

All this application will do when you run it is display the string “Hello World” in Terminal and exit.

NOTE:
Curious about the “return 0″ statement? Because we told the compiler that the function main() will return an integer, we return the constant integer value ’0′ at the end of the function. By convention, returning ’0′ signals to the calling program that our program finished execution without any errors.

To try this for yourself, fire up Xcode and make a new Objective-C class. Delete all the code Xcode gives you by default and stick the above code in. Once youʼve done that, you can compile it using Terminal. Open Terminal and change to the location where your file is, if you saved to the desktop then simply type cd desktop so that Terminal is now reading from your Desktop. Then type this command:

gcc program1.m -o program1  

Your program should compile with no errors. To run it, simply type:

./program1  

Then hit return.

Awesome, so what actually happened there? Well, first we imported a library called stdio which manages the standard i/o (input output) functions, like printf(). We then create a function called main which should return an int or integer which is basically a number with no decimal point. We then use the printf() function to output ʻHello Worldʼ in to terminal. The \n we use tells Terminal to put a newline after the text. Finally, we return 0 (remember we said main should return an integer) which tells the operating system everything went fine. We use the name main because this is triggered automatically when the program is executed.

So far everything should be pretty simple: we wanted to write some text to Terminal, so we imported a library with a function for writing text, then we used a function from that library to write the text. Imagine that what you import is a physical library and printf() is one of the books available.

Variables

Soldiering ahead, weʼre now on to variables. One of the fundamental things we need to be able to do in our applications is temporarily store data. We do this using variables, which are containers that can hold various types of data and be manipulated in various ways. We use variables to store all sorts of data, but we must first tell the compiler what weʼre going to store in it. Here are several of the most important variables that you should know about for now:

int – for storing integers (numbers with no decimal point)
char – for storing a character
float – for storing numbers with decimal points
double – same as a float but double the accuracy

When weʼre not using variables, weʼre often using constants. A constant will never change: we always know what the value will be. If we combine constants we get a constant expression, which we will always know the result of. For example:

view plaincopy to clipboardprint?
123 + 2 = 125  

This is a constant expression, 123 + 2 will always equal 125, no matter what. If we substituted a constant for a variable, the new expression would look like this:

view plaincopy to clipboardprint?
123 + i = ?  

Because i is a dynamic variable, we do not definitely know the result of this equation. We can change i to whatever we want and get a different result. This should give you an idea of how variables work.

One thing we still need to know is how do we display variables like we displayed “Hello World” above? We still use the printf() function, except it changes a little this time:

view plaincopy to clipboardprint?
#include <stdio.h>  
int main(){  
    int someNumber = 123;  
    printf("My number is %i \n", someNumber);  
    return 0;  
}  

What weʼve done here is told the function printf() where we want our integer to appear, then where it can be found. This is different to a lot of languages such as PHP where you could just place the variable in the text.

We are not just limited to just one variable in printf(). The function can accept multiple parameters separated by commas, so we can pass in as many as we have formatting signs for in the text. Above we use %i as a formatting sign because we were including an integer. Other variables have their own format specifiers:

%i – integer
%f – float
%e – double
%c – char

One thing I want to touch on before we move on is the char type. A variable of type char can only handle single characters, when thatʼs all we need this is great, but if we need a string of text itʼs pretty useless. To get round this, we use something called a character array.

Imagine you have a sentence that is 11 characters long (like ʻHello Worldʼ – donʼt forget to include the space), a character array is like having 11 charʼs but all glued together. This means that the value of the character array overall is ʻHello Worldʼ but char[0] is ʻHʼ. In brackets is the char youʼre after, because we put 0 we get the first character. Donʼt forget that counting in arrays usually starts from 0, not 1.

Conditionals

When an application needs to make a decision, we use a conditional. Without conditionals, every time you ran your application it would be exactly the same, like watching a movie. By making decisions based on variables, input or anything else, we can make the application change – this could be as simple as a user entering a serial number or pressing a button more than 10 times.

There are a few different types of conditionals, but for now weʼre just going to look at the most common and basic: the if statement. An if statement does what it sounds like, it checks to see if something is true, then acts either way. For example:

view plaincopy to clipboardprint?
#include <stdio.h>  
int main()  
{  
    if(1 == 1) { // This is always true  
        // Do some stuff here  
    }  
  
    return 0;  
}  

If 1 is equal to 1, then whatever is between the brackets is executed. You might also be wondering why we used two equals signs instead of one. Using two equal signs is an equality operator, which checks to see if the two are equal to each other. If we use a single equal sign then weʼre trying to assign the first value to the second value.

Above, since 1 will always be the same as 1, whatever is in the brackets would be executed. What if we wanted to do something if this wasnʼt true though? Thatʼs where else comes in. By using else we can run code when the if conditional returns false, like so:

view plaincopy to clipboardprint?
int main(){  
    if(1==1){  
        // Do some stuff here.  
    }  
    else{  
        // The universe is broken!  
    }  
  
    return 0;  
}  

Of course, in real life, we wouldn’t be checking to make sure 1 is the same as 1, but the point is made. Consider an application that closes if you press the close button three times (annoying but relevant). You could check in the brackets to see how many times it has been pushed. If it is lower than 3, then your else block could execute code to tell the user how many more times the button must be pushed to exit.

Weʼll look at conditionals more when we come to use them in our applications further along in the series.

Loops

Now let’s investigate a programming loop. Loops, as the name suggests, let us loop through a piece of code and execute it multiple times. This can come in very handy in situations such as populating a list or repeating a piece of code until a conditional returns true.

There are three types of loops, in order of most common: for, while, and do. Each one is used to repeat execution of a block of code, but they function differently. Here are examples of each:

view plaincopy to clipboardprint?
// if loop  
int main () {  
    int i = 9;  
    int x = 0;  
  
    for (x = 0; x < i; x++){  
        printf("Count is: %i\n", x);  
    }  
  
    return 0;  
}  

This may look a little complex at first, but it really isnʼt. In the parentheses after for is the initiator, a conditional, and the action. When the for loop starts it executes the initiator, which in our case above sets x to 0. Each time the loop runs (including the very first time) it checks the conditional, which is "is x smaller than i?" Finally, after each loop through the code, the loop runs the action - which above increments x by one. Simple. Since x is increasing by one each time, x will soon no longer be less than i and the loop will finish and the program will carry on running.

view plaincopy to clipboardprint?
// while loop  
int main () {  
    int x = 0;  
    while (x < 10){  
        printf("Count is: %i\n", x); //Watch OUT! Something is missing.  
    }   
  
    return 0;  
}  

Similar to the for loop, the while loop will execute the code between the brackets until the conditional is false. Since x is 0 and we don't change it in the code block, the above would run forever, creating an "infinite loop." If you wish to increment x, then in the case of our while loop you would do this between the brackets:

view plaincopy to clipboardprint?
// while loop  
int main () {  
    int x = 0;  
    while (x < 10){  
        x++;  
        printf("Count is: %i\n", x);  
    }  
  
    return 0;  
}  

The do loop is essentially the while loop, except the conditional runs after the block of code. What this means is when using a do loop, the code is guaranteed to run at least once:

view plaincopy to clipboardprint?
// do loop  
int main () {  
    int x = 0;  
    do {  
        x++;  
        printf("Count is: %i\n", x);  
    } while(x < 10);  
  
    return 0;  
}  

Pointers

Pointers can cause a lot of confusion with newcomers to programming or just newcomers to C. It is also not immediately clear to some people how they are useful, but youʼll gradually learn this over time. So, what is a pointer?

As the name implies, pointers point to a location. Specifically, locations in computer memory. Think of it like this, when we create a variable (let's say it's an integer called ʻfooʼ as is so popular with programming theory) and give it a value of, for example 123, we have just that - a variable with a value of 123. Now, if we setup a pointer to foo, then we have a way of indirectly accessing it. That is, we have a pointer of type int that points to foo which holds the value '123.' This would be done in code like so:

view plaincopy to clipboardprint?
int foo = 123; // This is an integer variable  
int *ptr = &foo; // This is a pointer to an integer variable  

Clear as mud? Donʼt sweat it. Pointers are hard - often considered the hardest thing to learn when picking up the C language. Pointers will eventually become second nature to you though, and there will be more on pointers within Objective-C further in this series.

Wrapping Up

You've just been given a crash-course overview of the C language fundamentals. This part of the series was intended to be a quick primer on C to get you ready and prepared for the rest of the series, and should have been especially useful to those who are already familiar with programming in another language. If you are new to programming in general or are still in doubt about any basic of C, re-read the above and feel free to leave questions in the comments.

Before next time, be sure to try and compile your own programs using the code above. Set yourself small challenges, such as making a loop execute 10 times and count each time through the loop using printf. Thereʼs no harm in trying and experimenting, if it goes wrong then itʼs probably even better as itʼll get you on the right track to troubleshooting your own code.

Challenge

For this week, we will end on a simple challenge. You are to create three programs that count to 10 using each type of loop. Since we will use loops often in Objective-C, itʼs good that you learn to create them by heart. That should be pretty easy, so try to count down from 10 to 1 afterwards (if ++ increments by one, what could be the code to decrement by 1?).

Next Time

In the next installment of this series, Iʼll provide an overview of how Objective-C works. Weʼll also look at object orientated programming and its uses, as well as really drill down into classes, instances, methods, inheritance and more.

Next week should really help you to understand what makes Objective-C such a great language and why it really extends the C language in so many useful ways.

Creating A Cydia Repository/Source For iOS! [Covering Everything A-Z]

2012-04-28T00:27:00.002+07:00

This tutorial will explain the process of creating a Cydia repository from start to finish. We will cover everything from the initial preparation all the way to the hosting and publishing of your Cydia repository. This tutorial will get moderately technical and is not recommended for users who are new to computers or new to the whole jailbreaking scene. I will provide support for this tutorial through the comments section, but you can also contact me directly at: jaden@ijailbreak.com

What is a Cydia Repository?

Well if you are following this tutorial I would like to hope that you have some knowledge of what a Cydia repository is, but if you do not then here is a quick summery. A Cydia repository for short is just a Debian APT repository, and this meaning that anything you can install (ie through Cydia) is considered to be a package. These so called packages exist in the form of .deb files, which have a rather interesting internal format. At a high level, a .deb contains the files that are going to be installed on your ipodtouch/iphone, which is a part of the package and also “control” information which comprises of metadata about the package (its name, size, and other details). The construction of such a file is done by using a tool called dpkg-deb. Users of Debian (or Fink on a Macintosh, which is also based on APT) will already have this package installed, but users of almost any other platform are able to install it easily.

Table of Contents

pre-requirements
Installing a Virtual Machine
Creating Files for your Repository – A Theme, An Application or a Ringtone
Prepping Ubuntu to create a Cydia Repository
Creating the Cydia Repository
Creating a unique Depiction Page (Coming Soon)

1) Web Server/Hosting Space - A Cydia repository is a Debian APT repository that is hosted on server, so users can then browse through the contents of your repository and download the packages that are hosted on your repository to their iPod Touch/iPhone. In order for you to create your own Cydia repository you will need to have some kind of a server or hosting space available to you.
2) A Computer with Linux/Ubuntu 8.10 plus - If you are running either windows or Mac there are many ways to run Ubuntu without disturbing your current operating system. In this tutorial I will show you how to set up a virtual machine running Ubuntu that will run on both Windows and Mac OSX operating systems. There is also the option of dual booting your computer to run Ubuntu however I will not be going into detail on this subject. **Note fink on Macintosh will work, but because I don’t have a mac to test it on I can not guarantee anything… You can DOWNLOAD UBUNTU HERE.
3) Patience and an hour or two – Creating a Cydia repository (especially if your new to this sort of thing), can be very challenging and time consuming. Don’t give up if you are getting frustrated, if at any point during this tutorial you need help please post any questions/comments in the comments section below.

Cocoa: Binding. GUI application without outlets

2012-04-25T15:07:00.003+07:00

Outlet in Cocoa is a persistent reference to a GUI control. For example, it is a common way to create the outlet to the text field and change the text in this field via the outlet. Now, in 64-bit Xcode, you add a property with IBOutlet keyword, synthesize it, and set new text via that property:

1. In interface declaration:

@property (retain) IBOutlet NSTextField * text;

2. In the implementation section:

@synthesize text;

3. Set new text to the text field:

text.stringValue = @"Hello, World!";

4. Get value:

NSString* str = text.stringValue;

Same can be done without coding. Sometimes it can be needed and interesting. Let's make a test application:
1. Create new Mac OS X Cocoa project in Xcode:

I named the project as TextNoOutlet (shown on the screenshots above).
2. In the application delegate class we add a string property:

Initially the application delegate class declared as (TextNoOutletAppDelegate.h file):

#import

@interface TextNoOutletAppDelegate : NSObject {

NSWindow *window;

}

@property (assign) IBOutlet NSWindow *window;

@end

Replace it for:

#import

@interface TextNoOutletAppDelegate : NSObject

@property (assign) IBOutlet NSWindow *window;

@property (copy) NSString *text;

@end

Control-S to save the header file. Alt-Cmd-Up to switch to the m-file. Synthesize the property:

#import "TextNoOutletAppDelegate.h"

@implementation TextNoOutletAppDelegate

@synthesize window;

@synthesize text;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {

// Insert code here to initialize your application

}

@end

Here I added only one line shown in bold. Control-S here to save the modification.

3. In Interface Builder (click twice on the MainWindow.xib file) will put the Text Field on the prototype window. Let's put Label under this text field. Arrange the size and locations.

4. The binding.
Select the text field in the prototype window. Press Command-4 to open the Binding Inspector:

In the Value section check the checkbox and set "text" in the Modal Key Path field.

Select the label. Command-3 to switch to the Binding Inspector. Check the checkbox and modify the Modal Key Path in the same way as for the text field.

Save your work in Interface Builder (Control-S or Save in the File menu).
5. Build and Run the program:

Try to type a text in the text field, press Enter and see the text reflected in the label.

Let's apply the binding to the application window:
In Interface Builder select the window object in the Document window, press Command-4 to switch to the Binding Inspector and bind the title of the window in the same way as the label before:

Save the change and Build and Run the program:

I'd Like to show one more interesting example with the slider control. Same principle: we will add a property, for example value to the application delegate class and bind it with the slider control and a label. The property added to the application delegate is shown in the bold:

#import

@interface TextNoOutletAppDelegate : NSObject

@property (assign) IBOutlet NSWindow *window;

@property (copy) NSString *text;

@property (assign) NSInteger value;

@end

It should be synthesized in the implementation file:

#import "TextNoOutletAppDelegate.h"

@implementation TextNoOutletAppDelegate

@synthesize window;

@synthesize text;

@synthesize value;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {

// Insert code here to initialize your application

}

@end

In Interface Builder I add the slider and one more Label. Then I bind the slider with "value" property:

I'd like to set "Continuos" for the slider control:

Now I select the new label in the prototype window and will bind it in a bit different way - via "Value with Pattern"

Save my work, switch to Xcode and Build and Run my program:

This "simplification" of the GUI work (do not use outlet for a GUI control and connect many GUI controls to the same property) is possible because of the nice feature of Objective-C 2.0 - Key-Value Coding or KVC. It is a simple protocol allowing to set and get values indirectly. In the first example, that uses the outlet, I call a method to get or to set values to/from the text field. Then, in the next examples, I specify a key that is used by Cocoa to figure out which property match up to this key: the property text was added to the application delegate class and key 'text' was used to bind the GUI controls with the application delegate.

Cocoa: show Alert

2012-04-25T15:06:00.002+07:00

Show Alert in a Cocoa application:

- (IBAction)showAlert:(id)sender

{

NSString *question = NSLocalizedString(@"Do you see this alert?",

@"Let's verify that I see this question");

NSString *info = NSLocalizedString(@"I hope, I see this alert",

@"Here is an info");

NSString *cancelButton = NSLocalizedString(@"Cancel",

@"Cancel button title");

NSAlert *alert = [[NSAlert alloc] init];

[alert setMessageText:question];

[alert setInformativeText:info];

[alert addButtonWithTitle:cancelButton];

NSInteger answer = [alert runModal];

[alert release];

alert = nil;

}

Cocoa: NSScanner

2012-04-25T15:05:00.002+07:00

sscanf is a standard C function. We use it so rarely, but it exists and can be the fastest method to parse a string. In order to remind I post this short program that uses sscanf to retrieve two float number from a string:

#include <stdio.h>

int main (int argc, const char * argv[]) 
{
    float x, y;
    const char* string = "3.1415 6.28";
    sscanf(string, "%f %f", &x, &y);
    printf("x = %.4f, y = %.2f\n", x, y);
    return 0;
}

How to parse this string in Objective-C?
Firstly, this is Objective-C, so the same code will work:

#import <Foundation/Foundation.h>
#include <stdio.h>

int main (int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    float x,y;
    const char* string = "3.1415 6.28";
    sscanf(string, "%f %f", &x, &y);
    
    NSLog(@"x = %.4f, y = %.2f", x, y);
    
    [pool drain];
    return 0;
}

Secondly, this is Objectve-C. So there is a special class NSScanner that does the work.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    float x, y;
    NSString* str = @"3.1415 6.28";
    NSScanner* scanner = [NSScanner scannerWithString:str];
    [scanner scanFloat: &x];
    [scanner scanFloat: &y];
    NSLog(@"x = %.4f, y = %.2f", x, y);
    [pool drain];
    return 0;
}

Let's make a more complicated example. The following program will create a text file and save three basic graphical structures in it: NSPoint, NSSize and NSRect.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    NSString* fileName = @"coordinate.txt";
    NSError* err = nil;
    
    NSPoint point;
    NSSize size;
    NSRect rect;

    // Write NSPoint, NSSize and NSRect to file.
    point = NSMakePoint( 3.1415, 6.28 );
    size = NSMakeSize( 2, 14 );
    rect = NSMakeRect( 10, 10, 200, 100 );
    
    NSString* outString = [NSString

stringWithFormat:@"point = %@; size = %@; rectangle = %@;",

      NSStringFromPoint(point), NSStringFromSize(size), NSStringFromRect(rect) ];
    
    [outString writeToFile: fileName

atomically: NO encoding: NSASCIIStringEncoding error: &err];
    
    [pool drain];
    return 0;
}

The output file looks so:

Of course, this file can be parsed in the standard C with the simple sscanf. The next Objective-C program does it with NSScanner class:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    NSString* fileName = @"coordinate.txt";
    NSError* err = nil;
    
    NSPoint point;
    NSSize size;
    NSRect rect;

    NSStringEncoding encoding;
    NSString* inString = [NSString stringWithContentsOfFile: fileName 
                                               usedEncoding: &encoding 
                                                      error: &err];
    
    NSString* strPoint = @"point =";
    NSString* strSize = @"size =";
    NSString* strRect = @"rectangle =";
    
    if ( err == nil )
    {
        if ([inString length] > 0)
        {
            NSString* str;
            NSScanner* scanner = [NSScanner scannerWithString: inString];
            
            if ( [ scanner scanString: strPoint intoString: NULL] )
            {
                [scanner scanUpToString: @";" intoString: &str];
                [scanner scanString: @";" intoString: NULL];
                point = NSPointFromString( str );
            }
            
            if ( [scanner scanString: strSize intoString: NULL])
            {
                [scanner scanUpToString: @";" intoString: &str];
                [scanner scanString: @";" intoString: NULL];
                size = NSSizeFromString( str );
            }
            
            if ( [scanner scanString:strRect intoString: NULL] )
            {
                str = [inString substringFromIndex: [scanner scanLocation]];
                rect = NSRectFromString( str );
            }
            
            NSLog( @"point = %@", NSStringFromPoint( point ) );
            NSLog( @"size = %@", NSStringFromSize( size ) );
            NSLog( @"rectangle = %@", NSStringFromRect( rect ) );
        }
    }
    
    [pool drain];
    return 0;
}

Program output:

Program loaded.

run

[Switching to process 57339]

Running…

2010-07-18 21:48:24.201 CoordinatesToString[57339:a0f] point = {3.1415, 6.28}

2010-07-18 21:48:24.205 CoordinatesToString[57339:a0f] size = {2, 14}

2010-07-18 21:48:24.206 CoordinatesToString[57339:a0f] rectangle = {{10, 10}, {200, 100}}

Mac OS X Reference Library:
NSScanner Class Reference
String Programming Guide. Scanners.

Template program to learn Cocoa graphics

2012-04-25T15:04:00.007+07:00

The standard way to learn new programming language is very boring for me - endless reading of heavy books, typing useless programs that calculates factorials,... Since my student times, since GWBASIC I begin from the graphics, simple graphic, rectangles, circles - the graphic primitives. When I know how to draw them, I can go on and learn the basic language constructions, language semantic and programming techniques.
This way works for me in my Cocoa period. In this post I'd like to show two methods to create a template project that allows to learn the Cocoa graphical primitives. This template can grow in your hands and become a real Cocoa (or Coco Touch) application.
As any Cocoa application this application has a main window and a view inside. That's all. First method uses Interface Builder. The second one fully ignores the Interface Builder.

Method with Interface Builder.
1. Create new project in Xcode from the Cocoa Application template, add new Objective-C class derived from NSView, give a name to this class, for example DrawingView.
2. Launch Interface Builder by pressing on the MainMenu.xib file. Find "custom view" in the Library, drag and drop it onto the application window. Set the view size - almost the whole window. In the Size Inspector (Cmd+3) set the autosizing options. In the Identity Inspector (Cmd+6) set the view name as DrawingView. Save the project (Ctrl+S).
3. Switch to Xcode and open DrawingView.m file. In -drawRect method we can add our drawing code. For example:

- (void)drawRect:(NSRect)dirtyRect {
    // Drawing code here.
    
    [NSGraphicsContext saveGraphicsState];
    
    NSRect rect = NSInsetRect([self bounds], 5, 5 );
    [[NSColor blueColor] set];
    NSRectFill( rect );
    
    [NSGraphicsContext restoreGraphicsState];
}

The application runs:

Method without Interface Builder.
1. The first item is the same - create new project in Xcode from the Cocoa Application template, add new Objective-C class derived from NSView.
2. Open the implementation of the application delegate class (AppDelegate.m) and create the view object in the launching method:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
    // Insert code here to initialize your application 
    DrawingView *view = [[DrawingView alloc] 
                         initWithFrame: [self.window.contentView bounds]];
    [self.window.contentView addSubview: view];
    [view setAutoresizingMask: ( NSViewWidthSizable | NSViewHeightSizable) ];
    [view release];
}

3. Open the view implementation class and add the drawing code.
Launch the application.

Cocoa: Implicit Animation

2012-04-25T15:04:00.003+07:00

This program will help to begin with the Core Animation.
1. In Xcode create Max OS X Cocoa Application.
2. In the Application delegate implementation file (automatically created by Xcode on Snow Leopard) add a button to the content view:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification 
{
    // Create new button in content view.
    NSRect frame = NSMakeRect(10, 40, 90, 40);
    NSButton* pushButton = [[NSButton alloc] initWithFrame: frame];
    pushButton.bezelStyle = NSRoundedBezelStyle;
    [pushButton setTitle: @"Move"];
    [self.window.contentView addSubview: pushButton];
    
    // Set the button target and action.
    pushButton.target = self;
    pushButton.action = @selector(move:);
    
    [pushButton release];
}

3. As you see from the code above the method -move is set as the button action. So add IBAction move to the application delegate class. The interface should look so:

#import <Cocoa/Cocoa.h>

@interface ImplicitAnimationAppDelegate : NSObject <NSApplicationDelegate> 

@property (assign) IBOutlet NSWindow *window;

- (IBAction)move: (id)sender;

@end

And -move method in the implementation file:

- (IBAction)move: (id) sender
{
    // The button frame.
    NSRect senderFrame = [sender frame];
    
    //The view bounds. The button belongs to this view.
    NSRect superBounds = [[sender superview] bounds];
    
    // Calculate new position within the view bounds.
    senderFrame.origin.x = (superBounds.size.width -
                            senderFrame.size.width) * drand48();
    senderFrame.origin.y = (superBounds.size.height -
                            senderFrame.size.height) * drand48();
    
    // Move the button.
    //[sender setFrame: senderFrame];
    [[sender animator] setFrame: senderFrame];
}

The commented line [sender setFrame: senderFrame]; simply moves the button. Line [[sender animator] setFrame: senderFrame]; creates an animation effect - the location change was split up for few movements.
Short description: each thread maintain an automation context. It is possible to object the object of this context as:
[NSAnimationContext currentContext];
Then, it is possible to customize this object, for example, change the duration:
[[NSAnimation currentContext] setDuration: 1.0];

Save and Load UIImage in Documents directory on iPhone

2012-04-25T15:02:00.001+07:00

The following function saves UIImage in test.png file in the user Document folder:

- (void)saveImage: (UIImage*)image
{
    if (image != nil)
    {
        NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, 
                      NSUserDomainMask, YES);
        NSString *documentsDirectory = [paths objectAtIndex:0];
        NSString* path = [documentsDirectory stringByAppendingPathComponent: 
                       [NSString stringWithString: @"test.png"] ];
        NSData* data = UIImagePNGRepresentation(image);
        [data writeToFile:path atomically:YES];
    }
}


The following function loads UIImage from the test.png file:
- (UIImage*)loadImage
{
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, 
                      NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    NSString* path = [documentsDirectory stringByAppendingPathComponent: 
                      [NSString stringWithString: @"test.png"] ];
    UIImage* image = [UIImage imageWithContentsOfFile:path];
    return image;
}

Create Bitmap Graphics Context on iPhone

2012-04-25T15:01:00.003+07:00

The following function creates an UIImage object:

- (UIImage*)makeImage: (CGRect)rect
{
    CGFloat width = CGRectGetWidth(rect);
    CGFloat height = CGRectGetHeight(rect);
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    
    size_t bitsPerComponent = 8;
    size_t bytesPerPixel    = 4;
    size_t bytesPerRow      = (width * bitsPerComponent * bytesPerPixel + 7) / 8;
    size_t dataSize         = bytesPerRow * height;
    
    unsigned char *data = malloc(dataSize);
    memset(data, 0, dataSize);

    CGContextRef context = CGBitmapContextCreate(data, width, height, 
                bitsPerComponent, 
                bytesPerRow, colorSpace, 
                kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);

    
    CGColorSpaceRelease(colorSpace);
    CGImageRef imageRef = CGBitmapContextCreateImage(context);
    UIImage *result = [[UIImage imageWithCGImage:imageRef] retain];
    CGImageRelease(imageRef);
    CGContextRelease(context);
    free(data);    
    return result;
}

In this function I create a Bitmap Graphics Context:

CGContextRef context = CGBitmapContextCreate(...)

and then the image:

CGImageRef imageRef = CGBitmapContextCreateImage(context);
    UIImage *result = [[UIImage imageWithCGImage:imageRef] retain];

The created graphics context works fine and, for a test, I can add a drawing code:

- (UIImage*)makeImage: (CGRect)rect
{
    CGFloat width = CGRectGetWidth(rect);
    CGFloat height = CGRectGetHeight(rect);
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    
    size_t bitsPerComponent = 8;
    size_t bytesPerPixel    = 4;
    size_t bytesPerRow      = (width * bitsPerComponent * bytesPerPixel + 7) / 8;
    size_t dataSize         = bytesPerRow * height;
    
    unsigned char *data = malloc(dataSize);
    memset(data, 0, dataSize);

    CGContextRef context = CGBitmapContextCreate(data, width, height, 
                bitsPerComponent, 
                bytesPerRow, colorSpace, 
                kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);

    
    // a drawing for a test.
    CGContextSetRGBFillColor (context, 1, 0, 0, 1);
    CGContextFillRect (context, CGRectMake (0, 0, 200, 100 ));
    CGContextSetRGBFillColor (context, 0, 0, 1, .5);
    CGContextFillRect (context, CGRectMake (0, 0, 100, 200));
    
    CGColorSpaceRelease(colorSpace);
    CGImageRef imageRef = CGBitmapContextCreateImage(context);
    UIImage *result = [[UIImage imageWithCGImage:imageRef] retain];
    CGImageRelease(imageRef);
    CGContextRelease(context);
    free(data);    
    return result;
}

This way allows a low-level access to the separate pixels of the image. For example:

for (int y = 20; y < 100; ++y)
    {
        for (int x = 20; x < 100; ++x)
        {
            int byteIndex = (bytesPerRow * y) + x * bytesPerPixel;
            data[byteIndex + 0] = 0;
            data[byteIndex + 1] = 127;
            data[byteIndex + 2] = 127;
            data[byteIndex + 3] = 127;
        }
    }

Probably, this code above contains a mistake. But I see a rectangle on the screen:

This method allows to draw on another image:

-(UIImage*)modify: (UIImage*)source
{
    CGImageRef sourceRef = source.CGImage;
    size_t width = CGImageGetWidth(sourceRef);
    size_t height = CGImageGetHeight(sourceRef);
    
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    
    size_t bitsPerComponent = 8;
    size_t bytesPerPixel    = 4;
    size_t bytesPerRow      = (width * bitsPerComponent * bytesPerPixel + 7) / 8;
    size_t dataSize         = bytesPerRow * height;
    
    unsigned char *data = malloc(dataSize);
    memset(data, 0, dataSize);
    
    
    CGContextRef context = CGBitmapContextCreate(data, width, height, 
                  bitsPerComponent, bytesPerRow, colorSpace, 
                  kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
    
    CGContextDrawImage(context, CGRectMake(0, 0, width, height), sourceRef);
    
    // a drawing for a test.
    CGContextSetRGBFillColor (context, 1, 0, 0, 1);
    CGContextFillRect (context, CGRectMake (0, 0, 200, 100 ));
    CGContextSetRGBFillColor (context, 0, 0, 1, .5);
    CGContextFillRect (context, CGRectMake (0, 0, 100, 200));
    
    // draw a rectange in a such strange way:
    for (int y = 120; y < 200; ++y)
    {
        for (int x = 20; x < 100; ++x)
        {
            int byteIndex = (bytesPerRow * y) + x * bytesPerPixel;
            data[byteIndex + 0] = 0;
            data[byteIndex + 1] = 200;
            data[byteIndex + 2] = 200;
            data[byteIndex + 3] = 200;
        }
    }
    
    CGColorSpaceRelease(colorSpace);
    CGImageRef imageRef = CGBitmapContextCreateImage(context);
    UIImage *result = [[UIImage imageWithCGImage:imageRef] retain];
    CGImageRelease(imageRef);
    CGContextRelease(context);
    free(data);    
    return result;
}

Of course, without this function will look better, if we will not try to draw a rectangle in a strange way via the pixels. For example:

-(UIImage *)oneMore:(UIImage*)source
{
    CGSize size = [source size];
    UIGraphicsBeginImageContext(size);
    
    CGRect rect = CGRectMake(0.0f ,0.0f, size.width, size.height);
    [source drawInRect:rect];

    // a drawing for a test.
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextSetRGBFillColor (context, 1, 0, 0, 1);
    CGContextFillRect (context, CGRectMake (0, 0, 200, 100 ));
    CGContextSetRGBFillColor (context, 0, 0, 1, .5);
    CGContextFillRect (context, CGRectMake (0, 0, 100, 200));
    
    //get image
    UIImage *result = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    
    return (result);
}

I call this function in applicationDidFinishLaunching:

- (void)applicationDidFinishLaunching: (UIApplication*)application
{
    CGRect rect = [[UIScreen mainScreen] bounds];
    UIWindow* window = [[UIWindow alloc] initWithFrame: rect];
    [window setBackgroundColor: [UIColor whiteColor]];
    
    rect = [[UIScreen mainScreen] applicationFrame];    
    //image = [self makeImage: rect];
    
    UIImage* source = [UIImage imageNamed:@"Abackground.png"];
    image = [self modify: source];
    
    UIImageView* contentView = [[UIImageView alloc] initWithFrame: rect];
    [contentView setImage:image];

    [window addSubview: contentView];
    [contentView release]; 
    
    [window makeKeyAndVisible];
}

Reference:
iOS Reference Library. Quartz 2D Programming Guide

Make a snapshot from an iPhone application

2012-04-25T15:00:00.004+07:00

Today I needed to make a snapshot programmatically. I thought it's easy:
[iPhone developer:tips];. Screen Capture using UIGetScreenImage.
Unfortunately, this approach does not work for me. People say that this API is private.
Ok. Let's make our own function.
I will add this function to my application delegate class. It looks so:

@interface myDelegate : NSObject<UIApplicationDelegate>
{
    UIWindow* window;
}

- (void) makeSnapshot;

@end

I save the snapshot in the camera roll and I have a callback notifying me about an error:

- (void)image:(UIImage *)image didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo
{
    UIAlertView *alert;
    
    // Unable to save the image  
    if (error)
        alert = [[UIAlertView alloc] initWithTitle:@"Error" 
                               message:@"Unable to save image to Photo Album." 
                              delegate:self cancelButtonTitle:@"Ok" 
                     otherButtonTitles:nil];
    else // All is well
        alert = [[UIAlertView alloc] initWithTitle:@"Success" 
                                           message:@"Image saved to Photo Album." 
                                          delegate:self cancelButtonTitle:@"Ok" 
                                 otherButtonTitles:nil];
    [alert show];
    [alert release];
}

Now from my code I can make the snapshots:

myDelegate *appDelegate = (myDelegate *)[[UIApplication sharedApplication] delegate]; 
[appDelegate makeSnapshot];

Of course these methods could be added to a UIView class in my application. So makeSnapshot will look as the following:

- (void) makeSnapshot
{
    UIGraphicsBeginImageContext([self frame].size);
    [[self layer] renderInContext:UIGraphicsGetCurrentContext()];
    UIImage *screenImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    
    // Save the captured image to photo album
    UIImageWriteToSavedPhotosAlbum(screenImage, self, 
                   @selector(image:didFinishSavingWithError:contextInfo:), nil);
}

Now, I can call this makeSnapshot method, for example, from touchesBegan:

- (void) touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event 
{
    [self makeSnapshot]; 
}

If I want to handle the touch event I needto send setUserInteractionEnabled message to the view:

[contentView setUserInteractionEnabled:YES];

Probably, this code will fail with an OpenGL ES application. I think so, because I see this thread on Cocos2d forum. Seems like people there have found a solution.

Cocoa. Date and Time

2012-04-25T15:00:00.000+07:00

This small program below detects the current date:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

     NSDate* today = [[NSDate alloc] init];
     NSLog(@"today is: %@", today);
    
    [today release];        
    [pool drain];
    return 0;
}

In the console you'll see:

run
[Switching to process 12401 local thread 0x3f03]
Running…
2010-03-06 17:05:45.217 DayOfToday[12401:a0f] today is: 2010-03-06 17:05:45 +0200

The Blocks

2012-04-25T14:59:00.001+07:00

Apple introduced blocks (a segment of code that can be executed any time) in C and Objective-c. It happened in Mac OS X 10.6. Later on this feature was back-ported to Mac OS X 10.5 and iPhone by Plausible Labs. The blocks are also called closures, because they close around variables. Also the blocks can be called lambdas.
I'd say that the blocks are the same as the regular function pointers in C. From a very general point of view, the main difference is just the symbol caret (^) before the block name instead of the asterisk (*) before the function pointer. Here is a trivial example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        void (^now)(void) = ^{ 
            NSDate* moment = [NSDate date];
            NSLog(@"Now: %@", moment);
        };
        
        
        now();
    }
    return 0;
}

The program output is: [Switching to process 41322 thread 0x0] 2011-11-26 18:07:25.202 block4[41322:707] Now: 2011-11-26 16:07:25 +0000 Program ended with exit code: 0 The following program simply creates and synchronously performs a block:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        void (^theBlock)(int) = ^(int x) {
            printf("x = %d\n", x);
        };
        
        theBlock(12);
        
    }
    return 0;
}

typedef can be used with the blocks:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        typedef NSInteger (^Multiply)(NSInteger, NSInteger);
        
        Multiply multiply = ^(NSInteger x, NSInteger y) 
        { 
            NSLog(@"Entering %s", __FUNCTION__);
            NSInteger z = x * y;
            return z; 
        };
        
        NSLog(@"%li * %li = %li", 5, 6, multiply(5, 6));
    }
    return 0;
}

The main purpose of the blocks is the dispatching them in Grand Central Dispatch. For example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        printf("Hello\r");
        dispatch_queue_t queue = dispatch_get_global_queue ( DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        dispatch_sync(queue,  ^{ printf("This is the block\n"); } );
    }
    return 0;
}

and here is the output console:

[Switching to process 38217 thread 0x0]

Hello

This is the block

Program ended with exit code: 0

In a more formal way, that the block is a self-contained unit of a work, an arranged part of the source code, very similar to the C-style function. The block may contain own variables and can access the variables from outside its own lexical scope. The block can read values of variables defined in the parent scope. Variables, accessed by the block, are copied to the block data structure and can be used by the block later. It's preferred to keep these variables in the read-only format. However, the blocks can use variables declared with the keyword __block in the parent scope prepended to return data back from the blocks.

That's, actually, it. And this is an example of practical use of the blocks - enumeration of the array:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSArray* array = [NSArray arrayWithObjects:@"First", @"Second", @"Third", nil];
        [array enumerateObjectsUsingBlock:^(id object, NSUInteger index, BOOL* stop)
         {
             NSLog(@"%@", object);
         }];
    }
    return 0;

The following example is interesting because the block is used here as a parameter in the method of a class:

#import <Foundation/Foundation.h>

@interface Test : NSObject

- (NSInteger)calculate:(NSInteger)number withBlock:(NSInteger (^)(NSInteger))block;

@end

@implementation Test

- (NSInteger)calculate:(NSInteger)number withBlock:(NSInteger (^)(NSInteger))block
{
    NSLog(@"the number is %li", number);
    NSInteger result = block(number);
    return result;
}

@end

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        Test* test = [[Test alloc] init];
        NSInteger result = [test calculate:5 withBlock:^(NSInteger number) {
            return number * number;
        }];
        NSLog(@"the result is %li", result);
        [test release];
    }
    return 0;
}

The output:

[Switching to process 41948 thread 0x0]

2011-11-26 18:33:44.383 block5[41948:707] the number is 5

2011-11-26 18:33:44.385 block5[41948:707] the result is 25

Program ended with exit code: 0

More about the blocks:
1. iOS Developer Library. A Short Practical Guide to Blocks.
2. iOS Developer Library. Blocks Programming Topics.
3. Language Specifications For Blocks.

Sort String Array

2012-04-25T14:58:00.002+07:00

The following code demonstrates how to sort an array of strings in Objective-C:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {
        
        NSArray *stringsArray = [NSArray arrayWithObjects:
                                 @"string 1",
                                 @"String 21",
                                 @"string 12",
                                 @"String 11",
                                 @"String 02", nil];
        static NSStringCompareOptions comparisonOptions = NSCaseInsensitiveSearch | NSNumericSearch |
        NSWidthInsensitiveSearch | NSForcedOrderingSearch;
        NSLocale *currentLocale = [NSLocale currentLocale];
        NSComparator finderSort = ^(id string1, id string2) {
            NSRange string1Range = NSMakeRange(0, [string1 length]);
            return [string1 compare:string2 options:comparisonOptions range:string1Range locale:currentLocale];
        };
        
        NSArray* sortedArray = [stringsArray sortedArrayUsingComparator:finderSort];
        NSLog(@"finderSort: %@", sortedArray);        
    }
    return 0;
}

This code is taken from iOS Developer Library.

Accelerometer. It's simple

2012-04-25T14:57:00.001+07:00

The simplest way to use accelerometer in an iPhone application is UIAccelerometer class:

UIAccelerometer* accelerometer = [UIAccelerometer sharedAccelerometer];

This code above shows how to get the accelerometer instance in the code.
The following line sets up the update interval:

[accelerometer setUpdateInterval: 1.0 / 10.0f];

[accelerometer setDelegate:self];

each 0.1 second the accelerometer will update the program that implements delegate method:

- (void)accelerometer:(UIAccelerometer *)acel didAccelerate:(UIAcceleration *)aceler

{

NSLog(@"acceleration.x = %+.6f", aceler.x);

NSLog(@"acceleration.y = %+.6f", aceler.y);

NSLog(@"acceleration.z = %+.6f", aceler.z);

}

Do not forget to add UIAccelerometerDelegate, for example, to a view controller class:

@interface ViewController : UIViewController <UIAccelerometerDelegate>

So here is the step-by-step scenario for beginners:

1. Create new Single-View project in Xcode.

2. In ViewController.h file add <UIAccelerometerDelegate> after UIViewController.

3. In ViewController.m file, modify viewDidLoad method:

- (void)viewDidLoad

{

[super viewDidLoad];

UIAccelerometer* accelerometer = [UIAccelerometer sharedAccelerometer];

[accelerometer setUpdateInterval: 1.0 / 10.0f];

[accelerometer setDelegate:self];

}

4. In ViewController.m file, add new method:

- (void)accelerometer:(UIAccelerometer *)acel didAccelerate:(UIAcceleration *)aceler

{

NSLog(@"acceleration.x = %+.6f", aceler.x);

NSLog(@"acceleration.y = %+.6f", aceler.y);

NSLog(@"acceleration.z = %+.6f", aceler.z);

}

This program works on iPhone. It does not make much sense to test it simulator.

Objective-C. Class Extensions.

2012-04-25T14:56:00.000+07:00

Few years ago, I was writing my first program in Objective-C, I was surprised that there is no way to add a private method to my class. Encapsulation, one of the basic principles of the OO programming, does not work in Objective-C? Unbelievable.
I found a way to declare a private category in the class main implementation class:

@interface MyClass (Private)
- (void)privateMethod;
@end

Once, by mistake, probably because of this annoying spell checker helping to type code in Xcode, I forgot the category name:

@interface MyClass ()

- (void)privateMethod;

@end

I thought it's a bug in the compiler. I decided to not use this way - one day the bug will be fixed. Than, in the github I found a few programs using this way (the category without a name), moreover, people declare instance variables in such anonymous category.

I found the explanation in iOS Developer Library:
Categories and Extensions

Objective-C 2.0 has a mechanism allowing to add private methods and private variables to a class (the encapsulation in Objective-C is on the highest level). The name of the feature is Class Extensions.
Class Extensions is a great place to redeclare a property publicly declared as read only - in the extension the property can be redeclared with the read-write attribute.

Singleton in iOS Programming

2012-04-25T14:55:00.003+07:00

What Apple says about Singleton:
Cocoa Core Competencies.Singleton
Creating a Singleton Instance

What other people say:
Singletons in Cocoa/Objective-C
Implementing a Singleton in iOS
Implementing a Singleton in Objective-C / iOS
Singleton Classes
A note on Objective-C singletons
Singletons, AppDelegates and top-level data.

A long discussion about it in Stackoverflow: What does your Objective-C singleton look like?

Add Settings to an iOS project

2012-04-25T14:54:00.003+07:00

Just find a very nice article about the subject:
Adding a settings bundle to an iPhone App

Please pay attention on the paragraph "Even defaults need defaults…" - that's what I needed in my app. Recently I found out that the default values I set for the settings do not work - a boolean parameter is always NO and does not matter that I set it to YES. This boolean parameter gets its default value only when the user opens the application settings for the first time. This article proposes a solution.

The source documentation in the iOS Developer Library:
Preferences and Settings Programming Guide

iOS Developer Library proposes an example: FunHouse. Here is a method from this sample:

+ (void)setupDefaults

{

NSDictionary *userDefaultsValuesDict;

userDefaultsValuesDict=[NSDictionary dictionaryWithObject:

[NSNumber numberWithBool:NO] forKey:@"useSoftwareRenderer"];

// set them in the standard user defaults

[[NSUserDefaults standardUserDefaults]

registerDefaults:userDefaultsValuesDict];

}

Looks promising.
(Do not forget to uninstall your app from the phone and then install again in order to test changes in this code.)

In my app, I just expect that all boolean values from the app preferences are NO by default. My code looks so:

- (void)loadDebugSettings

{

self.cleanBackupOn = NO;

self.devServer = NO;

self.logCommunicationOn = NO;

NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];

if ( defaults )

{

self.cleanBackupOn = [defaults boolForKey:@"AutoCleanBackupData"];

self.devServer = [defaults boolForKey:@"DevServerOn"];

self.logCommunicationOn = ![defaults boolForKey:@"LogCommunicationOf"];

}

Now, if I need one of these values to be YES, I use registerDefaults:

Find all words in a sentence

2012-04-25T14:49:00.003+07:00

This is one of the first samples in Mac OS X Developer Library. I found it in Cocoa Fundamental Guide

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])

{

@autoreleasepool {

NSArray *param = [[NSProcessInfo processInfo] arguments];

NSCountedSet *cset = [[NSCountedSet alloc] initWithArray:param];

NSArray *sorted_args = [[cset allObjects]

sortedArrayUsingSelector:@selector(compare:)];

NSEnumerator *enm = [sorted_args objectEnumerator];

id word;

while (word = [enm nextObject]) {

printf("%s\n", [word UTF8String]);

}

[cset release];

}

return 0;

}

here is the Terminal Window:

I payed attention on this sample, because it shows a useful trick: how to sort and enumerate data, for example an NSDictionary object.

Apple Developer

Testing iOS 4 Apps on the iPhone – Developer Certificates and Provisioning Profiles (Xcode 4)

Joining the iOS Developer Program

Creating an iOS Development Certificate Signing Request

Submitting the iOS Development Certificate Signing Request

Installing an iOS Development Certificate

Assigning Devices

Creating an App ID

Creating an iOS Development Provisioning Profile

Enabling an iPhone Device for Development

Associating an App ID with an App

iOS and SDK Version Compatibility

Installing an App onto a Device

Deploying Your App to Your Own iPhone / iPad / iPod

Learn Objective-C: Day 4

Getting Started

Coding the Interface

Coding the Implementation

Testing the Class

Property and Synthesize

Wrapping Up

Next Time

Challenge

Installing Tomcat on Mac OS X

"EGO" Xcode Theme for Xcode 4 + EGOv2

Learn Objective-C: Day 3

In Review: Classes & Objects

Classes from Apple (and some history)

Pointers and Initializing

Inheritance

Summary

Homework

Next Time

Learn Objective-C: Day 2

Object Orientated Programming

Methods

Attributes

Interface and Implementation

Interface

Implementation

Next Time

Challenge

Learn Objective-C: Day 1

What is Objective-C?

What will I need?

Compiling your code

The Basics

Variables

Conditionals

Loops

Pointers

Wrapping Up

Challenge

Next Time

Creating A Cydia Repository/Source For iOS! [Covering Everything A-Z]

What is a Cydia Repository?

Further Reading

Cocoa: Binding. GUI application without outlets

Cocoa: show Alert

Cocoa: NSScanner

Template program to learn Cocoa graphics

Cocoa: Implicit Animation

Save and Load UIImage in Documents directory on iPhone

Create Bitmap Graphics Context on iPhone

Make a snapshot from an iPhone application

Cocoa. Date and Time

The Blocks

Sort String Array

Accelerometer. It's simple

Objective-C. Class Extensions.

Singleton in iOS Programming

Add Settings to an iOS project

Find all words in a sentence