#import <UIKit/UIKit.h>;
#import <AssetsLibrary/AssetsLibrary.h>;

@interface MyImagePickerViewController : UIViewController {
 
	IBOutlet UITableView *tableview;
	IBOutlet UIActivityIndicatorView *activity;
 
	NSMutableArray *assets;
}
 
@property (nonatomic, retain) IBOutlet UITableView *tableview;
@property (nonatomic, retain) IBOutlet UIActivityIndicatorView *activity;
 
@end

We are going be using the assets array here to hold the assets that we are going to pull using the AssetsLibrary Framework.

Now open up MyImagePickerViewController.xib and drag in a UITableView and a UIActivityIndicatorView. With these in place connect them to the IBOutlets you created for this class. Also make sure to connect the UITableViewDataSource and UITableViewDelegate to the MyImagePickerViewController as well. With that done we can start to use the AssetsLibrary Framework.

Using the Asset Library

Now we are going to use our AssetsLibrary framework. This will be done within the viewDidLoad method of your MyImagePickerViewController.m. Put the following code in there.

1 - (void)viewDidLoad {
2
3    [super viewDidLoad];
4    [activity startAnimating];
5
6    void (^assetEnumerator)(struct ALAsset *, NSUInteger, BOOL *) = ^(ALAsset *result, NSUInteger index, BOOL *stop) {
7	if(result != NULL) {
8		NSLog(@"See Asset: %@", result);
9		[assets addObject:result];
10
11	}
12    };
13
14    void (^assetGroupEnumerator)(struct ALAssetsGroup *, BOOL *) =  ^(ALAssetsGroup *group, BOOL *stop) {
15	if(group != nil) {
16		[group enumerateAssetsUsingBlock:assetEnumerator];
17	}
18
19
20	[self.tableView reloadData];
21	[self.activity stopAnimating];
22	[self.activity setHidden:YES];
23    };
24
25    assets = [[NSMutableArray alloc] init];
26    library = [[ALAssetsLibrary alloc] init];
27    [library enumerateGroupsWithTypes:ALAssetsGroupAlbum
28					   usingBlock:assetGroupEnumerator
29					 failureBlock: ^(NSError *error) {
30						 NSLog(@"Failure");
31					 }];
32 }

We are going to be going though this code line by line. On line 4, we start animating our activity indicator. I will explain why we have to do that a little bit later. Lines 6 – 23 are the lines that will  declare the two blocks that we will use to fill our tableview with pictures. We are going to declare two blocks to use as parameters to methods within a ALAssetLibrary object and a ALAssetGroup object. The first method call we will make will be on our ALAssetLibrary object. So for the moment lets skip passed the block declarations and look at line 25. On line 25 we instantiate our NSMutableArray to hold the ALAssets that we will pull out from the AssetsLibrary. On line 26 we will create our ALAssetsLibrary object. We will call a single method on this object to loop through all of the assets in a library. The method is:

– enumerateGroupsWithTypes:usingBlock:failureBlock:

This method takes in 3 parameters. An ALAssetGroup type, a block to be performed on each group and a block to be performed on failure. Lets talk about block syntax. A block is a native Objective C object. It is a subclass of NSObject. With that said it is also an Objective C method. An objective C method is composed of three things. A return type, a parameter list and a piece of code to be executed. We are going to pass the assetsGroupEnumerator block object that declare on line 14 into this method. Lets take a look at how the block is declared.

You begin by specifying a return type for the block. Void in this case. Next you enclose a name for the block which is proceeded by a carrot ^ character. This is the special character Apple has decided on to denote blocks. You begin block names with blocks as well as the actual declaration of what a block is. This name is wrapped in parenthesis. This is followed by the parameter list that the block will accept. In this case it is a ALAssetsGroup object and a Boolean indicating whether to stop. Now I did not come up with these parameters by myself. Since I will be passing this block into an ASAssetLibrary the documentation will tell us what will be passed into the block. ALAssetsLibrary objects documentation can be seen here. With that all said, lets take a look at the code that will actually compose this block. Starting on line 15 we will make sure that we are seeing a valid group. If the ALAssetsGroup object that we are passed is valid then we will call another enumeration on the group which will enumerate through assets. This enumeration method also requires a block. We declared this block above. This block is called assetEnumerator. Once again we retrieved the parameters list from the documentation of the object asking for, in this case an ALAssetsGroup.

For this block, which begins on line 6, the block is passed an ALAsset object, an index and a stopping condition boolean. Within the code of the block we will ensure that the returned ALAsset is valid and if it is we will add it to our array which will hold all of our assets. With this block declared we pass it into the call to our ALAssetsLibrary object on line 16.  Once every group has been enumerated and our array is filled with all of our ALAssets we will tell the tableview to reload its data and get rid of our UIActivityIndicatorView.

With all of this done all that remains if filling in the required UITableViewDataSource methods. The tableview will be filled with the assets we collected. ALAsset objects are cool in that they include a method called -thumbnail which returns a CGImageRef to a thumbnail we will use. I won’t explain the development of these methods any further since they are pretty straight forward.

// Customize the number of sections in the table view.
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return 1;
}
 
// Customize the number of rows in the table view.
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return [assets count];
}
 
// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
 
    static NSString *CellIdentifier = @"Cell";
 
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] autorelease];
    }
 
	ALAsset *asset = [assets objectAtIndex:indexPath.row];
	[cell.imageView setImage:[UIImage imageWithCGImage:[asset thumbnail]]];
	[cell.textLabel setText:[NSString stringWithFormat:@"Photo %d", indexPath.row+1]];
 
    return cell;
}

Introduction

Back in July of last year. Brandon put up a post showing you how to integrate twitter into your application. Today I am going to take the class he made last year and add a new class which will let you post to twit pic. First lets do a little overview of what tools we need for this.

Required Tools

Twit pic is an awesome service. They have created a whole public API, that anyone can use to host a picture and post a tweet with a link to it. You can see the TwitPic API, and all its functionality here.The API is pretty simple, with only 2 methods.

• uploadAndPost
• upload

We are going to only be implement access to the uploadAndPost method. In order to use the API we need to use an HTTP POST method. While Apple provides NSURLConnection to take care of operations like this, we are going to use a better third party framework called ASIHTTPRequest. You can find ASIHTTPRequest to download here. I will go over the steps to get it installed. Just download the files for right now. You will also need to download some utility files that Apple created for users called Reachability. You can find those files here.

Preparing a project to use ASIHTTPRequest

1. Before we add the method into out TwitterRequest class, we have to do a bit of preparation with a project we want to use this framework witb. First think to do is to add ASIHTTPRequest and the Reachability classes into your application.
2. Now we have to add some frameworks to out project by “Editing the active target”. Go to Project ->  Edit Active Target “TwitPic”
3. Add in the following targets: CFNetwork.framework, SystemConfiguration.framework and libz.1.2.3.dylib

Using ASIHTTPRequest to contact TwitPic

Now if we compile we should see no errors, and we will be able to use ASIHTTPRequest in our new method in out TwitterRequest class. The method to communicate with TwitPic is actually going to be very short. We need to create the method to send the picture and fill in the methods to handle the response. Lets take a look at what these methods look like.

Method to send picture to TwitPic

Here we are going to pass in the photo for twit pic along with the delegate that is using out class. This pertains back to the design decision made when developing the original TwitterRequest class. Look back at the first post for expansion on this. Here we create an instance of an ASIFormDataRequest. request is an instance variable I declared in the TwitterRequest header. Pass in the proper values for the proper keys, following along with the TwitPic API. We are going to start and Asynchronous request here, so the UI does not freeze while the picture is being uploaded.

-(void)statuses_update:(NSString *)status withPhoto:(NSData*)photoData delegate:(id)requestDelegate requestSelector:(SEL)requestSelector {
     isPost = YES;
     // Set the delegate and selector
     self.delegate = requestDelegate;
     self.callback = requestSelector;
     // The URL of the Twitter Request we intend to send
     NSURL *url = [NSURL URLWithString:@"http://twitpic.com/api/uploadAndPost"];
     // Now, set up the post data:
     request = [[[ASIFormDataRequest alloc] initWithURL:url] autorelease];
     [request setDelegate:self];
     [request setData:photoData forKey:@"media"];
     [request setPostValue:username forKey:@"username"];
     [request setPostValue:password forKey:@"password"];
     [request setPostValue:status forKey:@"message"];
     // Initiate the WebService request
     [request startAsynchronous];
}

Methods to handle response

We need to handle two types of response from TwitPic. Either the request will finish, or the request will error. If the request finishes the following will be called. We check that the delegate set for the TwitterRequest class is present and that is responds to the selector that was passed in. If it does, the TwitterRequest class will respond back to the class using it.

- (void)requestFinished:(ASIHTTPRequest *)request {
NSLog(@"%@", [request responseString]);
// do something with the data
     if(delegate && callback) {
          if([delegate respondsToSelector:self.callback]) {
               [delegate performSelector:self.callback withObject:receivedData];
          } else {
               NSLog(@"No response from delegate");
          }
     }
// release the connection, and the data object
     [request release];
}

This is the class that should be used to handle errors. This for example could display a UIAlertView saying that an error occurred.

- (void)requestFailed:(ASIHTTPRequest *)request {
     NSError *error = [request error];
}

You can download the Header and Main for the updated TwitterRequest class here.

I’m pretty jazzed about a couple of design classes slated for this upcoming year. First up is a weekend workshop at the Marc Adams School of Woodworking this June 26^th and 27^th. If you are feeling the itch to begin creating your own designs, this might be a great way to try the water. Rest assured you will learn some of the basics on proportions, forms, the classic orders, but this class is really about learning to see and visualize. I’m working hard to put together a program that is inspiring and at the same time down to earth and practical at your workbench. Something else you should know before signing up. I like to have fun and try not to take myself too seriously. Come prepared not only to learn about design but also share a few laughs. Speaking of which, I dug this out from the last class I taught at MASW along with Dr Tom Young a few years ago. It’s sort of a collection of woodworking proverbs or Murphy’s laws of woodworking. Many of these I have learned the hard way:

1. Off square parts will assemble for maximum ill effect.
2. Your workshop is never big enough.
3. The workshop of your dreams won’t be big enough.
4. Mobile bases aren’t mobile in seven inches of sawdust.
5. Plastic wood isn’t.
6. A Safety guard hasn’t been invented that can prevent stupid.
7. Sawdust coating the laundry basket usually precedes a storm.
8. Finding one of your good chisels in the kitchen junk drawer is another sign of an impending storm.
9. The ideal number of clamps is two more than you will ever own.
10. The ideal sized clamp is two inches longer than the one you are making do with.
11. It’s time to sweep the shop floor when:
    1. You start losing tools bigger than a router.
    2. The kids start digging tunnels and building forts.
    3. You start bumping your head on the ceiling.
12. Amateur woodworkers don’t have clocks in their workshops; professionals don’t have enough time in theirs.
13. Hammering a bent nail into a board will not make it go away.
14. A tool tray at the back of your workbench was the original inspiration for the discovery of “Black holes” in the universe.
15. The original cost of a router is insignificant compared to what you will spend on router bits.
16. The amount of years spent woodworking is directly proportional to the amount of extra lights and outlets installed in the workshop.
17. Flying objects are never a good sign in the workshop.
18. Smoke is never a good sign in the workshop.
19. A popping sound when removing clamps is never a good sign in the workshop.
20. Re-attached fingers never work as well as original equipment.
21. Lumber always costs more than you planned.
22. You never have enough tools until you have at least three of everything.
23. “Natural material – no two are alike” means this wood is full of knots.
24. Your biggest goof will take place nearest the end of a project.
25. Experienced woodworkers still make mistakes; they are also more adept at hiding them.
26. All blueprints contain errors; it’s your job to find them the hard way.
27. There are six different ways to solve any woodworking problem, and at least thirty six ways to flub it up.
28. Calling it a day after really screwing something up will not make it better in the morning.
29. A dull drill bit will not magically become sharp by throwing it back in a cigar box.
30. If you never scrap anything, you probably don’t make anything either.
31. No one appreciates a door that closes smoothly, but even a moron will crab about one that sticks.

I’ve been compiling this list for some time. If you have any to add, I’d love to hear them.

George R. Walker

Introduction

So for any developer than has joined the iPhone Development program and attempted to throw their app on their phone, the process of provisioning is a familiar and likely painful process. Like many developer you may have several projects going on possibly for several organizations. You can think of provisioning as the paper work your app needs to fill out in order to “board” your phone. The process involves ____ steps:

1. Get an iPhone Developer Account
2. Create a certificate request
3. Download your approved certificate
4. Register your device
5. Create an App Id for some app (eg. com.exampleComapny.exampleProduct
6. Create a provisioning profile that says an app with a certain App ID can run on a device with a certain ID

While there may be a headache or two in the first several steps, Apple does provide a fairly robust overview of how to accomplish those things. We are going to focus on a developer who has gone through these steps and has a provisioning profile available on their machine. Now you may have multiple provisioning profiles on a single machine, but doing that just involves more work. I use this quick trick to modify projects to my provioioning profile so that I can help  test etc.

Instructions

Step 1

Assuming you already have a project created, open up the terminal and navigate into the directory for the project. In my case I have a project called “MyTesterProject”.

Step 2

Now if we do an ls command we can see that there is a .xcodeproj in this directory. We are going to navigate into that. Although in Finder this may look like a file, it is actually a bundle or folder that has things contained in it. Using the change directory command (cd) we can navigate into the project.

Step 3

Listing out the directory here we can see that there are several files. The one we are going to focus on is project.pbxproj. This is the file that contains all the configuration settings for this project. What I do here through the terminal is use the command mate to open text mate, however you may use vi or pico or whatever other text editor you like to open the file.

Step 4

Now you are going to search for whatever developer this project is currently linked to. For this example lets pretend that this project is configured for a provisioning profile for “Collin Ruffenach” but we want to change it. Search through this document and find the developers name.

Step 5

You will find the name in a section of text that looks similar to this. You need to replace whatever name is there with your name. The other important field begins with “PROVISIONING_ PROFILE”.

The number that you are to replace the provisioning profile number with will be found in xCode. If you go into xCode and into the Window menu, you will see an option for organizer. In organizer you can see all your provisioning profiles. Pick the one you have made for your self and get the Profile Identifier, this is what you will put for the PROVISIONING_PROFILE:

Step 6

The last thing to do is go into the info.plist file for the project and make sure to change the Bundle Identifier to match the one for the provisioning profile you have. I know at first this seems like a kind of invasive way to do things, but it has really sped up my development and testing time. Hope this tip works for you guys. Thanks for reading and Happy Coding!

This will be a simple tutorial showing you how to access the iPhone’s photo library as well as the camera. Since the 3.0 update, the methods for picking photos have been deprecated. So this will be a 3.0 and above tutorial.

We will be creating an applicaiton that will allow you to pick a photo from the library or camera and display it on the screen. Here is a screenshot of what the app will look like:

Let’s go ahead and get started…

1. Create A New View Based Application

I called mine photoApp (I will be using this name as reference)

2. Create The IBOutlets and IBAction

Open photoAppViewController.h and add the following code

#import 
 
@interface PhotoAppViewController : UIViewController | UIImagePickerControllerDelegate, UINavigationControllerDelegate | {
	UIImageView * imageView;
	UIButton * choosePhotoBtn;
	UIButton * takePhotoBtn;
}
 
@property (nonatomic, retain) IBOutlet UIImageView * imageView;
@property (nonatomic, retain) IBOutlet UIButton * choosePhotoBtn;
@property (nonatomic, retain) IBOutlet UIButton * takePhotoBtn;
 
-(IBAction) getPhoto:(id) sender;
 
@end

Important: Replace the | in the interface declaration with < and >.  I just used the vertical pipe bc wordpress was replacing it with html encoding.

Notice that we implement the UIImagePickerControlDelegate and the UINavigationControllerDelegate. These are both needed to properly interface with the image picker. The rest of this stuff should be pretty strait forward if you have been reading our tutorials. We set up some outlets to the buttons we are using (this will be to determine which button was pressed). There is also and IBAction that will get called when the user presses either of the buttons. This method (getPhoto) will show the ImagePicker.

3. Create The Interface

Open up photoAppViewController.xib in Interface builder and follow these steps:

1. Drag a UIImageView on to the main view
2. Set the Mode of the UIImageView to Aspect Fit in the Attribute inspector
3. Drag a UIButton on to the view and title it Choose Photo
4. Drag another UIButton on to the view and title it Take Photo

The interface should look something like this:

4. Connect The IBoutlets and IBAction

1. Connect choosePhotoBtn to the UIButton titled Choose Photo
2. Connect takePhotoBtn to the UIButton titled Take Photo
3. Connect the imageView to the UIImageView
4. Connect the Touch Up Inside callback on each of the buttons to the getPhoto method

When you click on File’s Owner the connection inspector should look like this:

Close Interface Builder

5. Implement The getPhoto Method

Open PhotoAppViewController.m and add the following code:

@synthesize imageView,choosePhotoBtn, takePhotoBtn;
 
-(IBAction) getPhoto:(id) sender {
	UIImagePickerController * picker = [[UIImagePickerController alloc] init];
	picker.delegate = self;
 
	if((UIButton *) sender == choosePhotoBtn) {
		picker.sourceType = UIImagePickerControllerSourceTypeSavedPhotosAlbum;
	} else {
		picker.sourceType = UIImagePickerControllerSourceTypeCamera;
	}
 
	[self presentModalViewController:picker animated:YES];
}

Make sure you synthesize your view properties.  Here is what is going on in this method.

We first create a new UIImagePickerController object.  This is a view controller and can be displayed any way you would normally display a view controller (pop on to a navigation view stack, load in a tab view, present as modalviewcontroller).  Next, we set the delegate of the picker to our viewController.  This just means the picker will call a method inside of this class when the user picks a photo.

Next, we determine which button was pressed.  Since both buttons were connected to this method, we can see which one called it by using ==.  Now, here is where Apple has done a great job.  The difference between displaying the camera and photo library comes from setting a single property in the picker.  Looking at the code, it should be pretty obvious which is which.

Finally, we call presentModalViewController with our picker.  This will animate the picker into view from the bottom of the screen to the top.  Depending on the button you press, you should see one of the views below:

6. Displaying The Selected Image

Once a photo is selected or taken, the ImagePicker will callback to a method in our class called didFinishPickingMediaWithInfo.  Add the following code to your PhotoAppViewController.m file.

- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info {
	[picker dismissModalViewControllerAnimated:YES];
	imageView.image = [info objectForKey:@"UIImagePickerControllerOriginalImage"];
}

The first line just hides the picker.  The next sets to image property of our image view to an image returned from the picker.  The picker actually returns an NSDictionary.  That is because the other key UIImagePickerControllerMediaType; will return whether this is a video or an image.

And there you have it.  A way to get photos from the iPhone’s image library or camera.  If you have any comments or questions, feel free to write them in the comments section of this post or write them to me on twitter.  You can download the source below. Happy iCoding!

iPhone Tutorial – PhotoApp.zip