A fireside chat with Apple’s Jonathan Ive Designer of the iMac, iPod, PowerBook, and more makes a public appearance.

What you can learn from a Palm developer Some iPhone development tips from the Palm side of things.

Prowl A Growl client for the iPhone. Push notifications from your Mac or PC to your iPhone.

iPhone Simulator Exchange Create 1-click installers of your iPhone Simulator apps for distributed testing and sharing.

Apple launches HTTP Live Streaming standard in iPhone 3.0 Interesting details and history behind Apple’s HTTP Live Streaming standard.

Testing Application Names on Home Screen A handy tip for trying out what your application’s name will look like on the iPhone to avoid truncation issues.

How Many iPhone Games Are There? Turns out there are a LOT of games on the App Store.

Average Price of a Top 10 iPhone Game Some more financial info on some of the top iPhone games.

News Search App Allows iPhone-Wielding Citizens to Monitor Government Officials Search technology previously available only to the U.S. government and major corporations has been ported to the iPhone.

Carlos Icaza and Walter Luh are the co-founders of Ansca Mobile and creators of Corona, a new & much talked-about Lua based kit for building native iPhone applications.

This interview includes details about creating Corona; a comparison of the programming model, memory management, performance and optimization using Corona/Lua vs Cocoa Touch/Objective-C; and Adobe’s upcoming iPhone Flash products.

You can listen using the Flash player below, download the MP3, or subscribe to the iPhone Developer Podcast using the instructions at the bottom of this post.

For easy scanning of the interview, here is what was covered and when:

• 1:00 Leaving Adobe and the path to creating Corona
• 4:00 Why Lua? Good for mobile: Code base small and good performance. Accessible for people comfortable doing web-scripting. Capable of handling serious engineering e.g., Photoshop Lightroom, World of Warcraft
• 7:00 Where does Lua stop and Corona begin?
• 8:45 Display layer atop OpenGL
• 9:15 Event/user-interaction mode (as compared e.g., to Cocoa Touch)
• 11:00 Memory management, garbage collection, memory consumption
• 12:45 Memory optimization for in-memory images
• 13:15 Graphics “painters” model
• 14:00 On-screen grouping
• 15:00 Getting started with Corona
• 15:30 What comes with the SDK
• 16:30 Interpreted on the phone? Compiled to native code? Some intermediate format?
• 19:00 Performance
• 21:30 Intended for “Flash-like” apps, or more broadly?
• 22:30 From here to 1.0: mostly about making it easy to get the code onto the device, making Internet calls
• 26:00 Flash on the iPhone scheduled for October… [update: while Adobe is releasing Flash for a number of phones in October the iPhone doesn't appear to be one of them.]

Keep up to date with our iPhone developers’ podcast

Subscribe to our iPhone Development Podcast in one of two great ways:

1. Use the podcast’s feed with the feed app of your choice: http://podcast.mobileorchard.com/feed/podcast/
2. Subscribe using iTunes by clicking here.

We hope you enjoy the podcast, and if you have any suggestions of who we should interview (or want to be interviewed yourself), use our Contact Page or leave a comment below. Thanks for listening!

Trixel Postmortem Very informative postmortem of the iPhone game “Trixel.”

Birdfeed An alternative Twitter client for the iPhone. Includes features such as: local caching, refresh timestamps, and SMS-style direct messages.

Here’s How iPhone App Store Ratings Work More criticisms of the iPhone App Store.

Essential iPhone Memory Testing Great tips for debugging memory issues.

John Carmack and Tom Mustaine on Doom, iPhone Desires, and the Future of id Mobile Engaging interview with the technical and business end of id software.

Develop Native iPhone Apps Easily Corona is getting a lot of buzz. The basics are covered in this informative article. Our next podcast — due Sunday — is an interview with Corona’s creators.

Recommend Your Favorite iPhone Apps with AppsFire Great new recommendation site for iPhone apps.

Beginning iPhone 3 Development A popular iPhone development book gets an upgrade and the author is candid about what changed from the last version.

Apple Releases iPhone OS, SDK 3.1 Betas to Developers Not one to rest on their laurels, Apple released beta versions of iPhone OS 3.1 and iPhone SDK 3.1 this past Tuesday.

iPhone OS 3.1 Features More details on what’s new with iPhone OS 3.1.

Obj-C Framework for Parsing, Tokenizing, and Language Processing A handy framework you can use for parsing and other tasks for the iPhone.

SDKs and Deployment Targets Easily build a single binary of your application such that it degrades gracefully on earlier platform versions.

iPhone Game Programming - Game Structure Part 10 of a great video based tutorial series on iPhone game programming.

iPhone 3GS Smokes Competition in OpenGL Benchmarks OpenGL performance revealed for iPhone 3GS.

Student Startup Challenges Crowded iPhone App Store with Innovative Game It’s always a good idea to be original when developing a game for the iPhone in this crowded market. See how a group of young students went about trying to do something new.

iPhone 3.1 Enhancements More details on the new iPhone 3.1 update.

iPhone 4.0 Revealed 4.0 you say? Here’s a sneak peak at what’s coming next for the iPhone in the near future.

Welcome to part-3 of our New In iPhone 3.0 Tutorial/Programming Series. The previous two articles in this series covered in-app email and shake to undo/redo.

This time, we’ll cover the basics of reading-from and writing-to the pasteboard.

Pasteboard Overview

Multiple Pasteboards

There isn’t just one pasteboard on the iPhone:

There are two system pasteboards: a General system-wide pasteboard that’s used for copy-paste operations and a Find pasteboard that holds the last search string.

Additionally, applications can create their own pasteboards that can be used by other apps. For example, a point-of-sales app and a credit card terminal app could use a shared pasteboard to pass payment details back and forth.

Multiple Representations

An item added to the pasteboard has a type. More precisely, when an item is added to the pasteboard it has representations in one or more types. A web address, for example, could be stored as both a string and also a URL.

Storing multiple representations in the pasteboard allows for flexibility in how the item is used. An email client could use the text representation to plunk a readable NSString representation of the URL into the body of a message; a podcast app could consume the NSURL representation to fetch the podcast.

This approach isn’t unique to the iPhone. This design lets the same copy operation in Safari result in plain text in TextMate but formatted text in Pages.

Pasteboard Operations

Note: the examples in this tutorial will use the General pasteboard though, because all pasteboards ares subclasses of the UIPasteboard class, the programming model applies to any pasteboard.

Using The General Pasteboard

The generalPasteboard class method returns a pointer the general pasteboard — for these examples, I’ll have set the pasteboard variable thusly:

UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];

Convenience Properties

The most common pasteboard operations involve getting or setting strings, images, URLs and colors. Apple provides convenience getters/setters for these in the form of properties:

NSString *string = pasteboard.string;
UIImage *image = pasteboard.image;
NSURL *url = pasteboard.URL;
UIColor *color = pasteboard.color;

pasteboard.string = @"paste me somewhere";

Determining If A Type Of Representation Is Available

The getter methods return nil if there isn’t a representation of the item in that type. It’s handy to know ahead of time whether a representation in a particular type is available. Use the containsPasteboardTypes: method to check:

if ([pasteboard containsPasteboardTypes: [NSArray arrayWithObject:@"public.utf8-plain-text"]])
	NSLog(@"String representation present: %@", pasteboard.string);

For a list of all the types for an item, use pasteboardTypes.

Uniform Type Identifiers — UTIs — Signify Type

The previous example checked for the public.utf8-plain-text type to determine if a string was present. This is an example of a UTI, or Uniform Type Identifier. For info on UTIs, read Apple’s Uniform Type Identifiers Overview document.

Apple provides constants for common types in UTCoreTypes.h. To use the constants:

1. Add the MobileCoreServices framework to your project
2. #import <MobileCoreServices/MobileCoreServices.h>

The constants are of type CFStringRef. You’ll work with them as NSStrings. The CFStringRef type is a fancy way of representing strings for both C and Objective-C. To use them in Objective-C simply cast them:

NSString *urlUTIType = (NSString *)kUTTypeURL;

You’re free to make up your own for your own data types; Apple recommends you use reverse-DNS notation style (e.g., com.mobileorchard.mySnazzyType) to ensure uniqueness.

Setting And Retrieving Types That Lack Convenience Getters/Setters

The convenience getters/setters are just a syntactic nicety. Essentially, they function the same as using the valueForPasteboardType: and setValue:forPasteboardType methods:

NSString *string = [pasteboard valueForPasteboardType:@"public.utf8-plain-text"];
[pasteBoard setValue:@"paste me somewhere" forPasteboardType:@"public.utf8-plain-text"];

These methods are intended for strings, arrays, dictionaries, dates, numbers and URLs. The dataForPasteboardType and setData:forPasteboardType: methods are available for other types.

Storing An Item With Multiple Representations

Using the convenience setters/properties has a significant limitation: items are stored with a single type. If, using our example from above, we want to store a URL as both a NSString as well as a NSURL we need to construct a dictionary of types and their values and set the pasteboard’s items property:

static NSString *string = @"http://www.mobileorchard.com";
NSDictionary *item = [NSDictionary dictionaryWithObjectsAndKeys:
	string, @"public.utf8-plain-text", [NSURL URLWithString:string],
	(NSString *)kUTTypeURL,
	nil];
pasteboard.items = [NSArray arrayWithObject:item];

Now, both pasteboard.string and pasteboard.url will return items.

Pasteboards Support Multiple Items

Note that, in the last example, we’re setting the items — plural — property. To keep this tutorial simple, I treated the pasteboard as a single-item entity. Should you require it, you can get/set arrays of items from the pasteboard. It’s generally straightforward to do so, usually involving little more than creating/consuming arrays pluralizing the property/method names. Check the docs for details.

Mobile Orchard Beginning iPhone Programming Workshop. Bay Area, July 30-31. $999 early bird registration. Save $200 with “mo” discount code.

Apple enforces a number of restrictions on applications in the App Store. Among the most painful is the lack of feature-limited trials. Applications are either completely free, or the customer must pay up front, sight unseen. The proliferation of “Lite” applications is a direct result of this shortcoming. Publishers will often create two application versions: the first is fully functional but costs money, the second is “Lite” and comes with limited features but zero price tag. The goal is for prospective customers to try the free version first and then decide to buy the paid full version separately if they like it.

Because free applications have greater exposure this approach is widely advocated as a means to increase visibility and grow sales. When building a game or other stateless application the approach makes complete sense. However, utility applications often maintain information entered by the device owner. Application authors are faced with a dilemma because the iPhone’s security sandbox prevents one application from reading another application’s files. Thus, when customers upgrade from the Lite application they are penalized by having to re-enter all data!

When we developed our data vault product, Strip, we felt this situation was unacceptable. We wanted to offer Strip Lite, free for people to try, limited to 10 entries. Upgrading customers should be able to import their data from the Lite version. No pain.

The Approach

Strip stores user data in an encrypted SQLite Database. Since we really wanted a way to copy the data file from Strip Lite to Strip we developed a fairly clever solution: use a registered URL handler as a means of communication between application versions. This is how it works:

1. A customer downloads Strip Lite for free and enters some unique private data. All information is written to a database in the application’s document directory.
2. When the 10 record limit is hit Strip Lite asks them to upgrade. An upgrade button launches to explain the process and allow the user to download the paid version of the product.
3. Once Strip is purchased and installed, our customer will launch Strip Lite and click an “Export to Strip” button. Strip Lite reads the application database into an NSData object, Base64 encodes it and then Launches a “strip://” URL with the encoded file contents as a URL parameter.
4. The full version of Strip is registered as a handler for “strip://” URLs. The OS launches Strip and passed the URL to the handleOpenURL method of the application delegate. It parses and decodes the data and writes the database to the desired location in the new applications Document folder.
5. Our customer now has access to all the data the originally entered into Strip Lite!

Project Setup

This tutorial assumes that your project is already configured with two targets, one for your full version, and one for the Lite.

Start by creating a new InfoLite.plist file for your Lite version. We use 2 separate .plist files to ensure that the Full version is the only registered URL handler (we don’t want the Lite version responding to upgrade events itself!). It is easiest to just make a copy of the existing Info.plist file named InfoLite.plist.

Next, Open up the Build preferences for the Lite target. Change the Info.plist File property to read InfoLite.plist. This will ensure that the Lite target includes the proper file.

Now open the Info.plist (used by the Full Version) and register a custom URL handler. This is a straightforward process of adding elements as shown in the following screenshot.

Please note that the URL identifier and URL scheme must be unique for your application — see this stepwise overview of the process for reference.

Finally, the application must include code to perform Base64 encoding itself. This functionality is, unfortunately, not directly accessible in the framework SDK. There are a few options in Cocoa, including using OpenSSL’s libcrypto, but the easiest method is to use the encoding libraries from Google Toolbox for Mac which is conveniently distributed under the Open Source Apache License. Download GTMDefines.h, GTMBase64.h and GTMBase64.m, then add them to your project. The GTM code compiles perfectly on the iPhone and even includes web safe variants that are immediately suitable for use in URLs without percent encoding.

The Code

With the project setup complete the Paid version will respond to the custom URL launch! This will facilitate an export from the Lite version to be received by the Full version.

The Lite Version

The Lite application should be extended to add a button to trigger the export on an about, settings, or upgrade page.

The controller action code will read the data file, encode it and then format a URL with the protocol prefix / URL scheme configured in the previous step.

#import "GTMBase64.h"
...
NSData *fileData = [NSData dataWithContentsOfFile:@"/path/to/LiteApplication/Documents/file"];
NSString *encodedString = [GTMBase64 stringByWebSafeEncodingData:fileData padded:YES];
NSString *urlString = [NSString stringWithFormat:@"myapp://localhost/importDatabase?%@", encodedString];
NSURL *openURL = [NSURL URLWithString:urlString];
[[UIApplication sharedApplication] openURL:openURL];

The Full Version

The final step is to make your application handle the Open URL event and reverse the encoding process.

Add a handleOpenURL method to the AppDelegate implementation as follows. This will receive the URL, sanity check it, and then parse the query string directly. The resulting binary data is written to the file in the full application’s data directory.

#import "GTMBase64.h"
...
- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url {
    if([@"/importDatabase" isEqual:[url path]]) {
        NSString *query = [url query];
        NSString *importUrlData = [GTMBase64 webSafeDecodeString:query];

        // NOTE: In practice you will want to prompt the user to confirm before you overwrite their files!
        [importUrlData writeToFile:@"/path/to/FullApplication/Documents/file" atomically:YES];
        return YES;
    }
    return NO;
}

End Game

We have transferred files of up to 100k this way, and the size of a URL string is theoretically only limited by available memory. That said, this approach is most suitable for applications with small to medium size data transfer requirements. Best of all though, it can be easily used for SQLite databases, XML files, text files, or even extended to handled compressed archives.

Strip has seen steady growth since it’s release as people upgrade from Strip Lite to the full version. Based on download reports and direct comments from customers we believe that much of this is directly attributable to the simple upgrade path. Until (and if at all) Apple begins to allow in-app purchases from within free applications this is a simple and painless way to migrate data between Lite and Paid application versions.

Demographics and Behavioral Characteristics of iPhone and iPod Users Interesting data from AdMob and comScore.

New iPhone Users with Activation Headaches Get iTunes Credit Apple apologizes for the 3G S activation woes.

Pinch Media Watcher Pinch Media releases a native iPhone SDK application for viewing your application’s stats.

The Fable of Free More testimonies from the iPhone developer trenches regarding free apps.

iPhone 3.0 Features Which iPhone 3.0 software features does your iPhone support? Take a look at this handy guide from Apple.

Bait and Switch with In-App Purchases Something to consider from a user’s perspective when implementing in-app purchases with your iPhone app.

AT&T: iPhone Coverage Getting Better, Faster Soon As we all know, AT&T coverage can be spotty. AT&T hopes to remedy this “soon”.

AdSense for Mobile Applications (Beta) Integrate AdSense into your mobile application with Google’s new beta.

Survey of iPhone Developers Great compilation of data from a recent iPhone developer survey.

iPhone 3GS JavaScript Performance JavaScript speed test results on the new iPhone 3G S, and they don’t look too shabby.

Gmail Mobile Adds Touch Gestures Google implements in-browser gestures for its updated mobile application.

Flash Competitor for iPhone Ex-Adobe vets launch Corona, a Flash alternative that may run on the iPhone in the near future.

iPhone Dev Camp I will be most likely attending this event July 31st - August 2nd in Sunnyvale, CA at the Yahoo headquarters. Won’t you join me?

Mobile Orchard Beginning iPhone Programming Workshop. Bay Area, July 30-31. $999 early bird registration. Save $200 with “mo” discount code.

A couple of days ago, I received a note from James DonFrancesco about an unexpected behavior change introduced in iPhone 3.0:

In 2.X, apps could launch a tel:// url to dial the phone without user input. In 3.0, Apple introduced a verification box to obtain user permission when an tries to make an outbound call.

This change breaks James’ baby monitor app — which makes calls parents when their kids wake — and diminishes the user experience of the whole genre of specialty dialer apps.

James, reasonably, wanted to gather a posse of similarly effected people to to collectively lobby Apple for a change; perhaps convince them to borrow from the Core Location user experience and let users grant apps permission to dial without validation.

James’ situation is a specific example of a larger pattern to address: there isn’t an acceptable way for iPhone developers to constructively provide feedback with gravity.

Sure, Apple takes bug reports. However, the system is effectively opaque. Is the submitter alone with his/her issue, or does it effect a silent majority of developers? Furthermore, while bugs are objectively resolvable, they’re a subset of the much larger category of subjective feedback, e.g., policy/behavior changes.

There is evidence that Apple responds to constructive feedback: They dropped the NDA, they’ve reversed app rejections (e.g., Eucalyptus), and there are reports that they actively try to avoid bad blood.

So, to provide the iPhone developer community with a mechanism to collectively submit constructive feedback with gravity to Apple, I’m pleased to announce:

The Unofficial iPhone SDK Feedback Project

The fine folks at UserVoice have provided us with a system for collecting feedback:

Anyone may submit feedback; the community then votes on the issues, producing a stack-ranking of the most important items on the minds of iPhone developers.

Developers can also enlist their app’s users to vote for more gravity.

The system functions as an economy: you have a limited number of votes, forcing you to make spending choices, concentrating feedback. With enough participation, the system will function as an efficient market, accurately indicating what’s on our collective minds.

Of course, without your participation this is for naught. Contrary to conventional wisdom, you can beat city hall — I personally, literally beat city hall in a fight this month. Apple can be moved too.

For further motivation: I’ll be running a new, regular feature here on Mobile Orchard highlighting new/hot/interesting feedback activity. So go make your voices heard!

Welcome back! In the first part of this series, I showed how to implement Shake To Undo/Redo and NSUndoManager in an iPhone app.

This time, we’ll add in-app email to a simple iPhone application using the new-in-3.0 MessageUI framework.

Technically neither mail from an app nor MessageUI are new. MessageUI was a private framework prior to 3.0, and apps could send mail using mailto:// URLs, though in a limited way.

In any case, with 3.0 and MessageUI, sending messages is straightforward and full featured.

We’ll start with working code for a simple app with a UI containing a single button. We’ll add code that shows the compose-an-email message UI and pre-fills the subject and content when the button is pressed.

Source/GitHub

The code for this tutorial is available on GitHub. To download a copy for yourself, close the repository:

1. Open a terminal and change to the directory where you want the code
2. Clone the repo by typing git clone git://github.com/dcgrigsby/InAppEmail.git

I’ve made two separate commits to the repository — an initial commit without in-app email, and a second one with those capabilities added. If you’re following along step-by-step, you’ll want to revert to the earlier commit. From the source directory:

1. Type git checkout 0019071d855e6d3a9f263b8a02d9c7d93dc5dcd2

Orientation

InAppEmail is about as simple an application as it’s possible to construct. The single “Send Email” button — which is disabled, for now — triggers the buttonPressed message when pressed.

Adding The MessageUI Framework

As part of the MessageUI Framework, Apple provides a ready-made compose-a-message UI called MFMailComposeViewController for our use. In order to use it, we need to add the MessageUI Framework to our project:

1. In the Groups & Files panel of the project, expand the InAppEmail project branch
2. Control-click or right-click the Frameworks folder
3. Choose Add > Existing Frameworks…
4. Expand the Frameworks folder
5. Choose MessageUI.framework and click Add
6. Click Add once more

Next, import the framework in the header:

1. Add #import <MessageUI/MessageUI.h> to InAppEmailViewController.h

Showing The MFMailComposeViewController UI

MFMailComposeViewController is just like any other view controller; we can use presentModalViewController from our InAppEmailViewController class to slide it onto the screen modally.

Replace the puttonPressed method in InAppEmailController.m with this:

- (IBAction)buttonPressed {
	MFMailComposeViewController *controller = [[MFMailComposeViewController alloc] init];
	[controller setSubject:@"In app email..."];
	[controller setMessageBody:@"...a tutorial from mobileorchard.com" isHTML:NO];
	[self presentModalViewController:controller animated:YES];
	[controller release];
}

Running the app in its current form would be disappointing. The “Send Email” message button is disabled. It’s a simple matter to enable it but, but we should do so only if the iPhone or iPod touch the app is running on has been configured to send mail. To do so, add code for aviewDidLoad method to InAppEmailViewController.m:

- (void)viewDidLoad {
	if ([MFMailComposeViewController canSendMail])
		button.enabled = YES;
}

Dismissing the MFMailComposeViewController UI

We’re most of the way there. Run the app at this juncture and it mostly works: clicking the button brings up the compose UI pre-filled with our sample message. Add an email address in the “To” field and away you go — mostly:

We’re missing one piece: we need to know when to dismiss the mail composer UI. The MFMailComposeViewControllerDelegate protocol provides a callback mechanism to accomplish this.

To receive the callback, we’ll need:

1. Adopt the protocol in our InAppEmailViewController
2. Set ourselves up as the delegate to receive the callbacks
3. Implement the callback method

To adopt the protocol update InAppEmailViewController.h. Changes are bold:

#import <UIKit/UIKit.h>

@interface InAppEmailViewController : UIViewController <MFMailComposeViewControllerDelegate> {
	IBOutlet UIButton *button;
}

- (IBAction)buttonPressed;

@end

To set ourselves up as the delegate to receive the callbacks update buttonPressed in InAppEmailViewController.m. Changes are bold:

- (IBAction)buttonPressed {
	MFMailComposeViewController *controller = [[MFMailComposeViewController alloc] init];
	controller.mailComposeDelegate = self;
	[controller setSubject:@"In app email..."];
	[controller setMessageBody:@"...a tutorial from mobileorchard.com" isHTML:NO];
	[self presentModalViewController:controller animated:YES];
	[controller release];
}

Finally, we implement the callback method. Add this code for a mailComposeController:didFinishWithResult:error: method to InAppEmailViewController.m:

- (void)mailComposeController:(MFMailComposeViewController*)controller didFinishWithResult:(MFMailComposeResult)result error:(NSError*)error {
	[self becomeFirstResponder];
	[self dismissModalViewControllerAnimated:YES];
}

Conclusion

That covers the basics. This tutorial doesn’t demonstrate setting recipients, adding attachments, or composing HTML email — all of which are straightforward once you’ve got the basics down.

Finally, one limitation that’s worth noting: you can’t force a user to send mail; they can always click the cancel button.

iPhone 3.0 has arrived, and with it push notification and in-app purchase.

In this interview, Scott Kveton, Michael Richardson and Steven Osborn of Urban Airship talk about the ins and outs of these new capabilities, the challenges of maintaining server infrastructure as an iPhone developer, and their services that seek to alleviate those pain points.

You can listen using the Flash player below, download the MP3, or subscribe to the iPhone Developer Podcast using the instructions at the bottom of this post.

For easy scanning of the interview, here is what was covered and when:

• 1:30 - Urban Airship offering
• 2:30 - Push notification overview
• 3:30 - Urban Airship handling push notification for Tap-Tap revenge
• 4:00 - Implementing push notification without a service like Urban Airship
• 4:30 - Send JSON messages, persistent connection, device tokens/feedback service for unsubscribe
• 5:00 - What’s missing in the sample implementation in Apple’s forums that demonstrate push notification in a dozen lines of code?
• 5:45 - Feeback service for managing “inactive” devices
• 7:15 - Persistent connections
• 8:30 - Implementing push via Urban Airship
• 12:00 - Building a relationship with Apple
• 13:00 - In app purchase
• 13:30 - Connecting receipt info to a content download after in-app purchase
• 14:00 - 3-10% of users use the app over the long term; the in-app purchase creates an additional revenue stream from those folks
• 15:00 - Pricing model
• 17:00 - A free option?
• 18:30 - Options for in app purchase: embedded content/features, downloadable content/feature
• 19:30 - Advantages/disadvantages of embedding the content in the app
• 21:30 - Purchase request programming model
• 25:45 - Consumable and non-consumable items
• 27:00 - Apple review process for in-app purchases

Keep up to date with our iPhone developers’ podcast

Subscribe to our iPhone Development Podcast in one of two great ways:

1. Use the podcast’s feed with the feed app of your choice: http://podcast.mobileorchard.com/feed/podcast/
2. Subscribe using iTunes by clicking here.

We hope you enjoy the podcast, and if you have any suggestions of who we should interview (or want to be interviewed yourself), use our Contact page or leave a comment against this post. Thanks for listening!

About Our Theme Music

Like the riff that opens the show? Buy the full song on iTunes.

AppStore HQ A comprehensive mobile app store aggregator.

How the iPhone can overtake all gaming handhelds in five steps The iPhone sure is poised to grow, especially in the gaming space.

iPhone install base vs. console install base Interesting comparison between how many people have iPhones compared to gaming consoles.

The Awesome Potential of iPhone In-App Purchases Now that iPhone 3.0 is out, it’s an exciting time to see what developers do to take advantage of the new in-app purchasing feature.

iPhone Game Development (Rough Cuts Version) The first book that I’ve seen that exclusively covers game development for the iPhone.

10 cool things about the iPhone 3G S Living under a rock? With the new iPhone 3.0 operating system launching this week, and the new hardware launching today, take a look at some of the coolest features that are now available.

Apple iPhone Developers Mostly Don’t Make Much Money A sobering article on one developer’s experiences with making a living as an iPhone developer.

The Apple App Rating System Goes Live Some information on the new ratings system that the upgraded iTunes will now support, including more across the board support for adult titles.

Aurora Feint to Roll Out OpenFeint 2.0 Thinking of adding XBox Live like features to your game? Want your game connected with other games? Take a look at this new version of a social gaming platform for the iPhone.

The Incredible App Store Hype More sobering data regarding making a living as an iPhone developer.

What do Snow Leopard, iPhone 3G S, iPhone 3.0 mean for business? An enterprise view on the new upgrades from Apple.

Wolfram|Alpha now has an iPhone portal Now access this amazing new “knowledge” engine (it’s not a search engine) from your iPhone.

Secret Exit on the Rise of iPhone and Why Cellphone Games Don’t Work for Indies A candid interview with the creators of the award winning “Zen Bound” game for the iPhone.

Trust, hostility, and the human side of Apple The perspective of an Apple developer and their frustrations.

AT&T drops iPhone 3G S prices for early iPhone 3G adopters There’s a lot of controversy between previous iPhone owners and AT&T with regards to upgrading to iPhone 3G S. AT&T has announced, for a limited time, the opportunity to purchase one at the same price points as new customers.