[picker setMessageBody:emailBody isHTML:YES];

There are some cases that this method that this method doesn’t take care of. In short, this method works great for sending “Tell a friend about this app” email. But if your app needs much more sophistication, especially, if it needs to email data created by the user, you can follow the approach I suggest. Using this method, you can also adapt your code for International support and send the same email in multiple languages without any “hard-coding”

Though the method promises some great features, it is ridiculously simple.

Step 1:

Create a HTML File with the contents of your email and add it to your project. You should NOT create any css or link it to any external CSS files. All your styles whether embedded withing the <STYLE> tag or kept as a separate CSS file will mostly be stripped by email clients. The reason could be because email clients don’t want your CSS to mess around with their client CSS. Read this article for more details. A sample is given below.

Step 2:

Insert placeholder markers within your HTML file. Your HTML file should look something like this.

<font size = '1' color= "#222222" style = "font-family: 'Lucida Grande', 'Lucida Sans Unicode', Helvetica, Arial;"><i>//TEXT_PLACEHOLDER//</i></font>
<font size = '2' color= "#000000" style = "font-family: 'Lucida Grande', 'Lucida Sans Unicode', Helvetica, Arial;"> Have a great day! <br/>//FRIENDNAME_PLACEHOLDER// <br/></font>

The bold markers are the placeholders. You can assume them to be variables in the email. We will be replacing them later.

Step 3:

Do exactly the same steps for sending an in app email explained in one of my previous tutorial, but rather than hardcoding the email body like this,

NSString *emailBody =
[NSString stringWithFormat:@"%@\n\n
Sent from MyGreatApp on iPhone. Download yours from AppStore now!
", content, pageLink, iTunesLink];
Read it from your HTML File you created in Step 2.

NSString *langString = [[userDefaults dictionaryRepresentation] objectForKey:@"NSLocaleCode"];
NSString *emailFileName = [NSString stringWithFormat:@"email_%@.html", langString];
NSString *emailFilePath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent: emailFileName];
NSString *body = [NSString stringWithContentsOfFile:emailFilePath encoding:NSUTF8StringEncoding error:nil];


Note that, I’m appending the locale code with the email filename. That means you should create your email file by name email_en_US.html and similarly for other language files.

Step 4:

Replace placeholder texts with your contents generated within the app.

body = [body stringByReplacingOccurrencesOfString:@"//TEXT_PLACEHOLDER//" withString:myText];
body = [body stringByReplacingOccurrencesOfString:@"//FRIENDNAME_PLACEHOLDER//" withString:myFriendName];


The values myText and myFriendName should be passed to this email function.

With this architecture in place, you can format your email, change language and do a lot more without much changes to your code. After all, writing cleaner code is more important in the long run.

–
Mugunth

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. iPhone Tutorial – In-App Email codeproject Sending an email from your iPhone application is...
2. iPhone Tutorial – Enabling reviewers to use your In-App purchases for free In-App purchases is a great way for developers to upsell...
3. iPhone Tutorial – UISearchDisplayController with NSPredicate Though UISearchDisplayController is seemingly easy (and yes it’s easy), apart...

“The version of iPhone OS on “ABC’s iPhone” does not match any of the versions of iPhone OS supported for development with this installation of the iPhone SDK”

So does that mean, you should re-install the SDK? Just like me, you will probably have confusions like,

Will installing it corrupt or overwrite your 3.2 beta?

Should I re-install 3.2 beta again?

I too had these. Fortunately, I decided to hack things myself and got the 3.1.3 working without downloading the entire SDK. This is how I did. Type the following command into your terminal.


ln -s /Developer/Platforms/iPhoneOS.platform/DeviceSupport/3.1.2\ \(7D11\) /Developer/Platforms/iPhoneOS.platform/DeviceSupport/3.1.3


Now quit and restart XCode. Voila! you have effectively “fooled” XCode! and you have saved countless hours which you can effectively use on programming another cool app!

Note that this hack will work *any* minor OS updates. However, if you are using a feature specific to the new version you will probably find yourself in trouble. In other words, don’t try to apply the same technique when 3.2 or 4.0 launches.

–
Mugunth

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. Is Windows Moribund? Any firefox user should be knowing about XMarks (formerly FoxMarks)....

Recently, I was using Microsoft’s Excel to edit a dozen large  CSV files. As a matter of fact, in Excel,  whenever you save “anything” you do as a CSV,  you will practically lose out features that aren’t supported natively by the underlying file format. For Example, CSV doesn’t support coloured cells. So when you colour a cell, and try to “save” it as a CSV, Excel pops up this dialog.

Saving as CSV loses of "certain" features

When you click “Yes”, all that Excel does is to “export” whatever content your file has into what the underlying format can support. So since, excel supports coloured cells but CSV doesn’t it ignores your colouring and proceeds saving it to CSV. Excel even goes one step far and doesn’t clear the “dirty flag” because, Excel hasn’t saved *every* change you made into the CSV.

Sounds good so far. But what’s really wrong here? The real problem is, Excel gives you a sense of feel that “everything” have been saved and you are safe. Things become bad when you quit Excel. Because the dirty flag isn’t cleared and the file haven’t been saved completely, Excel prompts you to “save” the file again. Specious, not wanting to take chances, some users like me, save the file again. Again the same thing happens and the end user is still just dumbfounded and asks, But, why the heck should I save it again?

Microsoft UI designers have failed to understand the end users. In this case, it’s because Excel fails to speak the users’ lingo. According to the user, when he “saves” a file, he saves a copy and he is contended that he can always re-open when something bad happens. But excel just “exports” the file into CSV format and tells the user that it “saved” the file (when it in fact didn’t). As a result what happens is data loss. No not just cell colours, in cases, when the users doesn’t know that CSV doesn’t support multiple sheets, excel doesn’t export (or save) the second sheets data and the user just loses the entire content from the second sheet. Disaster! In one of the cases where I work, a co-worker of mine, has got used to these prompts which Excel shows after you “save” your file as CSV

Prompts user to save the "saved" file again

and he just closes Excel assuming that these prompts are nothing but “bugs” in Excel. (Yeah see, he is a half techie and a little knowledge is dangerous.) Things went fine when he didn’t lose data, but just lost some formatting here and there. But the real disaster happened when his second sheet containing over 1000 lines and 3 hour work was lost.

Now, lets’ see how Numbers, the equivalent software from Apple handles this.

Apple doesn’t even include CSV or other “lossy” formats in the save as sheet. That doesn’t mean, Numbers can’t “save” your data as CSV. But rather Apple calls it as “Export”. Files you export as CSV aren’t yet saved. So, when the user quit Numbers, and get a prompt to save the document, he will not confused.

Because Microsoft does it this way (wrong way), other software makers like Adobe too make the same mistake. Photoshop “saves” a file as PNG and still give you a sense of feel that you have saved the file. Another such example is audacity and paint.net and even those “save as PDF” plugins. They actually don’t “save” your data, but rather export it. Apple gets it right, but the whole world gets it wrong, Unfortunate!.

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. Elements of Usability Design: OK/Cancel vs Cancel/OK – Is it just a matter of taste? codeproject OK, many of the programmers would have been...

Follow Cost is a interesting and powerful statistic that helps you check the “cost” you would incur by “following” a person on twitter. This is a very useful statistic that I think every twitter client should adopt.  Tweetie for iPhone was the first to implement follow cost and I use this feature of tweetie to check whether a follower is “worth the pain” (as follow cost puts it).

In short, Follow Cost gives you an approximate count of the number of updates a person tweets in a day. As a thumb rule, I don’t follow anyone with a follow cost of over 40. A celebrity with a high follow cost is @guykawasaki. (80+ at the time of this writing) His tweets are interesting, but is it worth the pain? Depends. To me, definitely not.

The API

Follow Cost has a relatively simple API. But unfortunately, even after 3 months of Tweetie 2 launch, no other twitter client has implemented. You just have to make a GET request to followcost.com server with the twitter username as follows.=


http://followcost.com/<username>.json

The resulting output is a json formatted string which can be parsed using any JSON Framework.

Objective C Code

To make life easier, I wrote a helper class MKFollowCost. To use the class, first download the JSON framework and follow their installation instructions. If you are writing a twitter client, chances are that, you would probably have done this. Download the code from below and drag the two files, MKFollowCost.h and MKFollowCost.m into your project.

You can instantiate a followcost object by

MKFollowCost *followCost = [[MKFollowCost alloc] initWithTwitterName:@”mugunthkumar”];

All of the variables like, milliscobles, tweets per day etc, can be accessed from this object. The object is designed to be embedded without your Twitter Profile object.

Downloads

FollowCost Objective C Wrapper: FollowCost v1.0

Rights

You can use it in your own Twitter client, royalty free. Attributing me is upto you. However, if you modify the source code, please make it open source.

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. Consuming a RESTful Service (bit.ly) in an iPhone Application bit-ly-rest-api-objective-c Introduction Of late, many programmers who develop for...
2. iPhone Tutorial – In-App Purchases Last week, Apple announced that in-app purchases will be available...
3. bit.ly wrapper for Objective-C/iPhone Continuing from my part 1, in this section, we will...

After raising the issue to Apple, I even got a official reply that it’s not possible currently to allow reviewers to use your in-app purchases for free.

However, developers’ creativity knows no bounds. In this post, I’ll present a method to allow reviewers to use your in-app purchases for free without having multiple versions of the same app on the app store. The source code for the same is also available royalty-free (as always) for using it in your own apps. Before diving in, it’s advised that you read through my previous tutorial on how to do in-app purchases

Focus

As I previously wrote, you can sell consumables, non-consumables and subscriptions using the in-app purchases model. This article is focussed primarily on consumables and non-consumables. However, you can extend it to subscriptions as well by adding a bit more server side PHP programming. This post however focusses on adding this feature to consumable and non-consumable items only.

A Quick Recap

By now, you must be knowing the flow of a in-app purchase request. If you don’t, read through my in-app purchases tutorial. As a recap,

1) You list the items available for sale from your store to the user.

2) When the user chooses a feature, you prepare a SKPayment object and add it to the queue.

3) Listen to notifications and record the purchases within your apps’ NSUserDefaults.

Or it’s even more simple if you had used my MKStoreKit.

The Idea

The idea here is to maintain a list of device IDs on the developer server and check whether the current device is exempted to use the feature without purchasing. If the device is allowed, rather than initiating a purchase, temporarily set the variables as if the transactions were made.

The complete source code, MKStoreKit V2.0 is attached at the end of the post.

You should be glad to know that, you don’t have to make changes to your calling code to add this feature.
In MKStoreKit, there is a function called buyFeature which initiates a in-app purchase request. In version 2.0, this function is modified to make a check first to your server (server code is also attached to this post) passing the UDID of the current device. If your server responds with a YES, it activates the feature temporarily without “actually purchasing”. This will enable your reviewers to review your app without buying your in-app purchase.

- (BOOL) canCurrentDeviceUseFeature: (NSString*) featureID;

This is the function that is called. Currently it checks the server mentioned in the variable ownServer (presently set to nil). To enable this function, you have to do the server side changes as explained in the next step.

Server Side Changes

Setup a database with two tables setup in your server. One table for storing a list of available products and another for storing new review requests as they come in.

The products table has the following fields
productid productName productDesc

The requests table has the following fields
udid productid email message status lastUpdated

You can use the SQL file attached to create these tables. Add a user to your MySql database and fill in the user id and password into the two php files.

Copy the server files from the ServerCode folder to some location like

http://api.mycompany.com/inapp/

change the “ownServer” variable in MKStoreManager.m to

http://api.mycompany.com/inapp/featureCheck.php

The featureCheck.php file checks the requests table for the UDID and the featureID. If the status of that row is 1, it returns YES. If your server returns YES for a particular UDID, the app activates the purchase for the current session without initiating a StoreKit purchase. Note that, this featureCheck happens everytime the app is started. Hence, if you deactivate a UDID on your server after the reviewer has finished reviewing, he will not be able to continue using it for free (Which means, you have actually given the reviewer a sneak-peek to your feature. Even if he likes it, he has to buy it)

How to send your review request?

There are atleast three ways of doing this.
One way is to ask your reviewers to send the UDID to you by email. You can ask them to use the Ad Hoc Helper by Erica Sadun You can then manually add it into the database using the AddDevice.html (present in the Server Code folder)
Second way is, You can “pretty up” the AddDevice.html and host it somewhere in your server. Send a link to this to your reviewers for filling their UDID/Product ID.
Third, as in my case, I’ve created a separate iPhone App for doing this. The only reason for doing so is, filling the UDID is very very cumbersome and error prone. If anyone knows a way to read the UDID of a device from a webapp, do let me know. (The big5 code didn’t work for me)

Going forward

I understand that all this server side setup is quite cumbersome. The server code isn’t even polished like the MKStoreKit. If Apple approves this method (which I will know in another 20 days), In MKStoreKit 3.0, I’ll probably throw of the whole server side code and replace it with a much elegant method by using a Google Spreadsheet. I haven’t yet digged around with the spreadsheets API. This way, you can implement the same feature without even owning a server .

I might as well add in features to migrate your existing customers who use your pro version to the version with in-app purchases. Stay tuned!

Source Code (Much awaited)

MKStoreKit V2.0
If you cannot successfully use this, you can hire me to do it for you. I usually freelance through oDesk.com

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. iPhone Tutorial – In-App Purchases Last week, Apple announced that in-app purchases will be available...
2. iPhone Tutorial: Follow Cost API and a open source wrapper What is Follow Cost? Follow Cost is a interesting and...
3. iPhone Tutorial – UISearchDisplayController with NSPredicate Though UISearchDisplayController is seemingly easy (and yes it’s easy), apart...

Step 1: Create the project

If you haven’t created a project yet, create a Navigation Based Project and open the RootViewController.xib.

Step 2: Modify the XIB

Drag UISearchDisplayController to your RootViewController.xib. (It automatically does the connections for you) Drag the SearchBar that gets added onto your TableView. You need the UISearchBar to be displayed on the controller. So drag the searchbar and place it on the top of the table view. Add ScopeBars if you need any. We will discuss later how to handle the scope bar changes and how to filter text based on the selected scope.

Step 3: The Design of UISearchDisplayController

In a traditional tableviewcontroller, you normally have one master list of data which you use for all the tableview data source methods. In case of UISearchDisplayController, you have to maintain two lists. One master list and one a filtered list. The tableview data source delegates will be called by the framework when it needs to populate your tableview or the search results. So in all the methods you have to differentiate whether the data source call is for populating the filtered list or for populating the main list.

This is done by a simple two line code.

if (tableView == self.tableView) {
// normal table view population
}
if(tableView == self.searchDisplayController.searchResultsTableView){
// search view population
}

This code should be written in cellForRowAtIndexPath, didSelectRowAtIndexPath and numberOfRowsInSection.
For the complete code listing, see Apple’s sample code.

Step 3: Implement the search delegates

When the user invokes a search,the UISearchDisplayDelegate functions you implement will be called. The two main functions that you have to implement are,

- (BOOL)searchDisplayController:(UISearchDisplayController *)controller 
shouldReloadTableForSearchScope:(NSInteger)searchOption
 
- (BOOL)searchDisplayController:(UISearchDisplayController *)controller 
shouldReloadTableForSearchString:(NSString *)searchString

Copy the implementation from Apple’s source.In the header file, your class should implement UISearchBarDelegate and UISearchDisplayDelegate.

As the name suggests, the first function will be called when the user changes the scope button and the second function is called when he starts typing a search query. The first function is not necessary if you haven’t added any scope button in step 2.

Step 4: Filtering your data using NSPredicate

This step is the reason why I wrote this seemingly simple post. I didn’t like the Apple’s way of filtering. It doesn’t match “contains” text. I modified the filterContentForSearchText method, so as to use NSPredicate. You still need the Apple’s implementation of shouldReloadTableForSearchString and shouldReloadTableForSearchScope.
The filterContentForSearchText implementation CANNOT be copy-pasted into your application. It’s a code fragment that doesn’t compile without some changes. Points to note in the function is the use of predicate.

NSPredicate *predicate = 
[NSPredicate predicateWithFormat:@"(SELF contains[cd] %@)", searchText];

The [cd] in the predicate format means case and diatric insensitive. the verb I have used is “contains”, you can change it to beginsWith, endsWith, like and many others. The NSPredicate is a very powerful feature that can be exploited here. I don’t understand why Apple just didn’t use it For more info, look at Apple’s NSPredicate documentation here

Below is the complete code listing after making the NSPredicate changes.

- (void)filterContentForSearchText:(NSString*)searchText scope:(NSString*)scope
{
    [self.filteredData removeAllObjects]; // First clear the filtered array.
    for (Product *product in tableData)
    {
        NSPredicate *predicate = [NSPredicate predicateWithFormat:
           @"(SELF contains[cd] %@)", searchText];
       [product.productID compare:searchText options:NSCaseInsensitiveSearch];
        BOOL resultID = [predicate evaluateWithObject:product.productID];
        BOOL resultName = [predicate evaluateWithObject:product.productName];
       if([scope isEqualToString:@"Product ID"] && resultID)
        {
            [self.filteredData addObject:product];
        }
        if([scope isEqualToString:@"Product Name"] && resultName)
        {
            [self.filteredData addObject:product];
        }
        if([scope isEqualToString:@"Any"] && (resultID || resultName))
        {
            [self.filteredData addObject:product];
        }
    }
}

With NSPredicate, you can play around with the search filters. NSPredicate is as powerful and easier to use than Regular Expressions. Try your hand at it.

–
Mugunth

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. iPhone Tutorial – Enabling reviewers to use your In-App purchases for free In-App purchases is a great way for developers to upsell...
2. iPhone Tutorial – In-App Purchases Last week, Apple announced that in-app purchases will be available...
3. iPhone Tutorial: Follow Cost API and a open source wrapper What is Follow Cost? Follow Cost is a interesting and...

Update: Did it really free you from creating “lite” and “pro” versions? How did you manage to give away free copies of your in-app purchases for reviewers? Read my tutorial on how toenable in-app purchases for free

Apple allows three types of purchases within the app and Apple terms them as consumables, non-consumables and subscriptions.

Consumables are products that are “consumed” immediately. This means, if the purchase is made today, and the user wants to purchase it again tomorrow, he will be charged again when he attempts a purchase.

Non-Consumables are features that are purchased exactly once. Apple automatically takes care of “remembering” those purchases and allows the user to purchase them again for free, just like downloading apps you already purchased.

Subscriptions are the most complicated part, They behave like non-consumables during the subscribed period and like consumables after that. You as a developer have to ensure that anything that is subscribed by the user is available across all of his iTunes synced devices when they are purchased from one device. Hence, do not lock in-app purchases to UDIDs. This might even get your app rejected. The StoreKit, as on date, doesn’t have any built-in mechanism to do it automatically which is why subscriptions are a bit tougher to develop.

One important point to note is that, in-app purchases cannot be used to deliver product updates. Changes to the binary has to be separately submitted. However, if you are a game developer, game data, maps, levels and other “data files” are allowed for in-app purchase.

In this post, we will focus on how to prepare your app for enabling features for the “pro” version from the “lite”. Or technically, we will focus on how to bring in, consumables and non-consumables into your app. We will leave the subscriptions part to another blog post as it’s quite complicated and involves some server side programming as well.

Preparing your iTunes Connect

To start with, in-app purchases, you need to do some ground work on your iTunes Connect account. A three step process that Apple thinks every developer should know. (Unfortunately I couldn’t find any official documentation for this)

Step 1:

First is to create an App ID and enable in-app purchases for that. This App ID shouldn’t have any wild card characters or else, the in-app purchases option will be grayed. I would always recommend to use a different App ID for every application you create.

Step 2:

Create provisioning profiles (Development and Distribution) using this App ID. Again it’s a good practice to create different provisioning profiles for every app. There are many tutorials on how to create this here and Apple’s own documentation here (This link will prompt you to login).

Step 3:

You need to create product references in your iTunes account. Each individual in-app purchase should be uniquely identifiable. Apple recommends using the reverse DNS notation, something like, com.mycompany.myiproduct.ifeature Before creating product ids, you need to associate it with a existing application in AppStore. If your app is not yet live, you can create a dummy, placeholder application, fill in the metadata (which you can anyway change it later) and check “upload binary later”.

To create a new in-app purchase, open your itunes connect and choose “Manage In-App purchases”. Choose the app for which you want to setup in-app purchases and click next. You should see a screen like this.

The reference name is the name that appears during the in-app purchase prompt. Any name like, Levels 10 – 50 will be fine. The Product ID should be unique. This is used for reporting as well as within your app for requesting a purchase (more on this later). You can select the type as consumable or non-consumable. When you say an in-app purchase is consumable, your users will be charged everytime they purchase it. This is perfect for a radio app that requires users to pay for listening to a song everytime. If it’s a product feature, set it as non-consumable. Non-consumable products are purchased exactly once. When the user attempts to purchase it again, it will be delivered to him for free.

Type in the other required detail in this page and click save.

Step 4:

The fourth and final step is to create test user accounts. After you program the app, you might want to test the app. You can use these accounts to login to the App Store. The purchases will be processed as if it were real but no financial transactions will take place.

This completes your iTunes connect configuration. Take a deep breath. We have just started. A lot more to go.

Writing the StoreKit Code

Now that you have setup the iTunes account, let’s start by writing the actual code to interact with the AppStore and allow users to make purchases. For coding help, nothing beats the Apple’s official StoreKit programming guide. However, the guide has one bug that crashes the program. We will see how to circumvent it properly here.

Step 1: Adding StoreKit.Framework

The first step here is to add the StoreKit.Framework to your project.

Step 2: Parental Controls

It’s important to check whether the iPhone/iPod doesn’t have parental control restrictions. When you try to initiate a purchase when parental controls are on, you might crash your app. The apple docs code seems to have an error here. The function, canMakePayments is a static method of class SKPaymentQueue and not a member function. The working code looks like this.

if ([SKPaymentQueue canMakePayments])
{
... // Display a store to the user.
}
else
{
... // Warn the user that purchases are disabled.
}

Step 3: Retrieving the product information and populating the UI

Now the you have designed a gorgeous looking view, you can show it to the user using, say presentmodalviewcontroller or any similar method. Do note that StoreKit doesn’t provide the UI to be displayed. It’s upto the developer to design the UI. The first step is to query your “In-App Purchases” and show the user, the available list of options. Retrieving the product information from AppStore is a couple of lines of code as illustrated here.

- (void) requestProductData
{
SKProductsRequest *request= [[SKProductsRequest alloc] 
initWithProductIdentifiers: [NSSet setWithObject: kMyFeatureIdentifier]];
request.delegate = self;
[request start];
}
- (void)productsRequest:(SKProductsRequest *)request didReceiveResponse:
        (SKProductsResponse *)response
{
NSArray *myProduct = response.products;
// populate UI
[request autorelease];
}

The kMyFeatureIdentifier you pass to initWithProductIdentifiers is the uniquely identifiable product id you created in your AppStore account. Remember the reverse DNS product id? You CANNOT specify a wild card character here. So, if you have multiple products, you have to initialize the request object with a list of product using

SKProductsRequest *request= [[SKProductsRequest alloc] 
initWithProductIdentifiers:
[NSSet setWithObjects: myGreatFeature1, myGreatFeature2, nil]];

You can pass as many features as possible to setWithObjects and be sure to end the last object with nil.
Setting the delegate to self and calling the start method will invoke the “didReceiveResponse” delegate. The delegate will give you an array of products and the request itself. Use the array to populate your store UI and release your request here. (This is the same request you created initially).

Step 4: Adding a Transaction Observer

This is a very important step. You can do this as soon as your app is open or when you start a “In-App” purchase session. Do note that, in-app purchase requests are continued even if the user quits the app in between. So imagine a case, when user buys an item, but before the transaction is processed, he gets a phone call that interrupts everything. Though the actual transaction is not interfered (as it happens on Apple servers), your application will never know what happened. To ensure that you get all transaction notifications, (completed/ pending/restored), you have to register a class that receives the callbacks from AppStore. This class should implement and it’s delegate methods.
This is the code for registering the your store observer.

MKStoreObserver *observer = [[MKStoreObserver alloc] init];
[[SKPaymentQueue defaultQueue] addTransactionObserver:observer];

(If you can’t follow anything here, just head below for the real source code, but it’s advised that you read through this, understand and then use the code in your app).

Step 4: Implementing the callback

Within your MKStoreObserver class, you have to implement the callback function paymentQueue:updatedTransactions:

This function will receive updates on the transactions as and when it’s made. Because your transactions take place even when the app is closed, you should be ready to receive these notifications as soon as you open the app. So the best place is to initialize it in applicationDidFinishLaunching or equivalent method.

Now in the updatedTransactions functions, handle the three types of transactions, purchased, failed and restored.

- (void)paymentQueue:updatedTransactions(SKPaymentQueue *)queue 
updatedTransactions:(NSArray *)transactions
{
for (SKPaymentTransaction *transaction in transactions)
{
switch (transaction.transactionState)
{
case SKPaymentTransactionStatePurchased:
// take action to purchase the feature
[self provideContent: transaction.payment.productIdentifier];
break;
case SKPaymentTransactionStateFailed:
if (transaction.error.code != SKErrorPaymentCancelled)
{
// Optionally, display an error here.
}
// take action to display some error message
break;
case SKPaymentTransactionStateRestored:
// take action to restore the app as if it was purchased
[self provideContent: transaction.originalTransaction.payment.productIdentifier];
default:
break;
}
// Remove the transaction from the payment queue.
[[SKPaymentQueue defaultQueue] finishTransaction: transaction];
}
}

Purchase and failed are seemingly straightforward. You will receive a restored transaction message when your app was quit before the transaction was completed. You should always do the “same” thing when your purchase is new or restored. If you want to charge your users for every download, then probably, set the in-app purchase to be a “consumable” item. But be sure to use that only for purchases that are really “consumable”. Like a live radio show or a podcast and not for unlocking additional levels. Users expect that a level they have unlocked will stay forever.

Three things to note here
1) You should remove the transaction from the payment queue after the transaction is complete. Otherwise, the transaction will be re-attempted, which is not what the users expect (and your app will most likely get rejected).

2) You should provide the content (or unlock the feature) before completing the transaction. When you receive the message SKPaymentTransactionStatePurchased, it means that the users’ credit card has been charged. It’s high time that you provide the feature.

3) You should not display an error when the transaction fails because the user rejected it. Display any error message only when,

if (transaction.error.code != SKErrorPaymentCancelled)</code>

Apple recommends you not to display an error, because that is not an error. The user has purposely cancelled the transaction (probably because the price was too high?). You can audit it and go on. But for heaven sake, don’t display an error like, “Unable to process transaction because user cancelled operation!”. It will be soooo Windozy…

Step 5: The actual purchase

Now that your architecture is ready, you can go ahead and initiate the purchase by calling the function below when the user clicks your “Buy” button on the UI.

SKPayment *payment = [SKPayment paymentWithProductIdentifier:myGreatFeature1];
[[SKPaymentQueue defaultQueue] addPayment:payment];

Optionally, you can add something like payment quantity for “consumable” items.

payment.quantity = n; // number of "items" that user wishes to purchase.

Finally, after providing the feature, you should “remember” that the user has purchased the app. Apple’s recommended way is to use NSUserDefaults, the same way you store your settings.

Testing your app

Alright. Now let’s test the app. Note that, the app cannot be testing from iPhone simulator. The StoreKit communicates with AppStore.app to complete transactions which is not present in the Simulator. So connect your iPhone and run the app.
Remember step 3 you did in iTunes connect? You created some test accounts? Well, they are used for testing your app. Before using that, sign out of AppStore by opening Settings.app -> Store -> Sign Out.
Start the app. (You should NOT sign into the AppStore with the test user account. It will anyway ask you to provide your credit card which we are not interested in)

Open the Store UI and initiate the purchase. You will get a prompt like, “Do you want to buy 1 “ABC feature” for 2.99$? Tap Buy. You will be prompted to login. Provide your test account login. The AppStore provides a secure connection to the iTunes account and notifies you whether the purchase was successful through the callback paymentQueue:updatedTransactions. When you use the test account, the scenarios will be exactly same expect that no one will be charged. These test accounts run inside a sandbox.

In case your app got quit by a phone call, the transactions continue and you will get a restoreTransactions the next time your app is opened. This is why you should start listening to transactions as soon as you open the app (not just when the user opens the store UI)

That’s it. I wouldn’t say its easy. But for developers who have some intermediate knowledge in iPhone development and Objective C, it shouldn’t be a big deal. Remember that when your app is free, you get 10 times more downloads (as reported by admob statistics). When people actually use your app, there is a high chance that they buy your in-app features. That’s upselling becomes easy. Given that this is a very strong business model for the already saturated AppStore, you should start incorporating this model into your code soon.

Source code

The source code, MKStoreKit, contains four files. MKStoreManager.h/m and MKStoreObserver.h/m. The StoreManager is a singleton class that takes care of *everything* Include StoreKit framework into your product and drag these four files into the project. You then have to initialize it by calling [MKStoreManager sharedStorageManager] in your applicationDidFinishLaunching. From then on, it does the magic. The MKStoreKit automatically activates/deactivates features based on your userDefaults. When a feature is purchased, it automatically records it into NSUserDefaults. For checking whether the user has purchased the feature, you can call a function like,

if([MKStoreManager featureAPurchased])
{
//unlock it
}

To purchase a feature, just call

[[MKStoreManager sharedManager] buyFeatureA];

It’s that simple with my storekit. The source code will be uploaded when this post is read by at least 1000 people. Please spread the word.

As always, all my source code can be used without royalty into your app. Just make sure that you don’t remove the copyright notice from the source code if you make your app open source. You don’t have to attribute me in your app, although I would be glad if you do so

Downloads:
Version 2:MKStoreKit V2.0
Version 1:MKStoreKit.zip

Troubleshooting

Despite all this, In-App Purchases remain a biggest and the most PITA situation for any iPhone developer. If you can’t get it work, check whether your “didReceiveResponse” delegate returns the product id you passed as invalid. You can confirm this by adding a NSLog statement inside the delegate. Double check if your invalid product id returned here matches the product id you created in iTunes connect. If they are same, check if your product id on iTunes connect says “Cleared for Sale”. For this, you have to provide a screenshot and “Developer Approve” it.

Another case is, if this is your first app, then chances are that, your “Paid Applications Contract” isn’t yet in effect. If this is the case, you have to wait till Apple approves your bank details.

If these two doesn’t work, you might have to wait for 12-24 hrs, till Apple propagates your iTunes connect information to all it’s servers. See the last line in this documentation for more details.

If you have issues adding this to your application, you can hire me to do it for you. I charge a nominal fee of 30$ per hour and this work shouldn’t take more than a couple of hours.

Update 1: (22-Oct-2009): Code changes to fix a crash that occured in most cases.
Update 2: (7-Dec-2009): Added link to MKStoreKit v2.0.
–
Mugunth

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. iPhone Tutorial – Enabling reviewers to use your In-App purchases for free In-App purchases is a great way for developers to upsell...
2. iPhone Tutorial – UISearchDisplayController with NSPredicate Though UISearchDisplayController is seemingly easy (and yes it’s easy), apart...
3. iPhone Tutorial: Elegant way to send formatted In-App email By now, most of you know how to send emails...

Recently, Twitter’s switch from tinyurl to bit.ly as it’s default shortening service infuriated companies like tr.im as they announced that they will probably be shutting down their service, though they reverted their decision later. When such companies go out of business, what will happen to your URLs? Dead and gone for good? So why not host our own URL shortening services? How difficult is it to write our own URL shortening service? Turns out that a few couple of PHP files, and a MySQL database and a mod-rewrite enabled Apache server is all what you need for hosting your own URL shortening service. Writing those PHP code is not for the those who are not conversant with PHP (including me). For people like us, two smart guys, Lester Chan and Ozh Richard at yourls.org have written a custom URL shortener that you can use it for free on your blog. In this post, I will briefly explain how to host your own custom URL shortener using YOURLS. Later we will also look at how to host your own “TwitPic” service.

Steps for hosting a custom URL Shortener

Hosting your own custom URL shortener with YOURLS is a 3hr work. Yeah, believe me, these people have made most part of the work required. In fact, it took me more time to write this post than host YOURLS. I’ve explained it in four easy steps below.

Step 1

Purchase a short and sweet domain. I recently purchased a domain mk.sg and it costed me a paltry 30$ (45 SGD) from Vooju. You can explore possible domains using domainr, a nice tool that automatically checks for available domains from the letters you choose. Though this step is not mandatory, it’s good to have a short domain name given that domain names are this cheap.

Step 2

Download the latest copy of yourls from their website. Create a MySql database in your server and fill in the details of your MySQL database in the config file as explained in the config section Upload your files to the root of the server.
For example, I host my primary domain mugunthkumar.com and mk.sg in the same hosting account. mk.sg actually points to a folder inside my public_html folder. FTP these files into that folder and point your browser to http://YOUR-SHORT-DOMAIN.COM/admin. Click install. Done!

The configuration file provides options like whether it’s a private URL shortener or public, the usernames and passwords allowed for accessing the service and a whole lot. Believe me, it’s as feature-rich as bit.ly. You can track who clicked your links, from which location they clicked and a variety of other tracking features. However, it doesn’t allow users to “preview” the short links. Not a deal-breaker though.

If your installation is going to be private like mine, you can access the service from http://YOUR-SHORT-DOMAIN.COM/yourls-api.php You can rename yourls-api.php to something else as well. If you specify the installation as private in the config file, you have to provide a user name and password for accessing this API like below.

http://YOUR-SHORT-DOMAIN.COM/yourls-api.php?action=shorturl&username=test&password=test&format=simple&&url=%@

If you want your URL shortener to be used by everyone, set it appropriately in the config file and you can ignore the username and password parameter from this API.

Step 3

Install the YOURLS word press plugin that automatically links your posts, creates a short URL and tweets it. Any post or page you publish is now automatically tweeted by this plugin.

Step 4

Now, how good is a URL shortener if your favorite twitter client doesn’t support it? Fortunately with the release of Twitter 2, my favourite twitter client, you can use a custom URL shortener as described in developer.atebits.com. Open Tweetie 2, Go to Settings, URL Shorterning -> Custom, type the entry below.

http://YOUR-SHORT-DOMAIN.COM/yourls-api.php?action=shorturl&username=test&password=test&format=simple&&url=%@

Hopefully, other twitter clients will follow the crowd shortly. And I believe, if most twitter clients support custom URL shortening, the market share for bit.ly and others might go down.

With this, you can get your own custom URL shortening service up and running within, say, 3 hrs.
Next, we will look at how to host our own “TwitPic” service.

Steps for hosting a custom “TwitPic”

Hosting your own “TwitPic” is even easier. Thanks to the Wordpress plugin Twitter2Press, that completely automates everything! Below are the detailed steps for hosting your own “TwitPic”.

Step 1

Create a subdomain or directory and install wordpress into it. Note that yourls and wordpress cannot co-exist in the same directory as both handle URLs differently. So install it into a subdomain and make that subdomain as short as possible. Mine is b.mk.sg.

Step 2

Install the Twitter2Press plugin and open the settings page. Choose YOURLS and specify the API username and password. This is the same username password that you provided in the config file while setting up YOURLS. Choose a page for the image gallery. This is the page that shows the images you tweeted (much like twitpic or yFrog’s home page). It can either be your home page or a dedicated page, say Image Gallery or something.

Step 3

Twitter2Press has an API that is supported by Tweetie 2 and hopefully other twitter clients will follow. For tweetie to work with your Image Service, you need to provide the API endpoint. If your Image Gallery Page is “gallery”, the endpoint is

http://YOUR-SHORT-DOMAIN.COM/gallery/index.php

All parameters are posted to this service by Tweetie 2. If you don’t have a dedicated Image Gallery Page, omit the gallery from the API endpoint.


That’s it. Now even if tr.im shuts down or twitpic eats all your files, you are safe. Your data lies in your server. Go, start yours now!

–

Mugunth

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. How to make your UITableView scroll fast? How to make your UITableView scroll fast? The iPhone’s GPU...

Source Code

Download the source code here
MKBitlyHelper 1.0.zip

Documentation

With just three lines of code, you can shorten your URL using this wrapper.

Initialize the helper class with your loginname and apikey.

bitlyHelper = [[MKBitlyHelper alloc] initWithLoginName:@"yourlogin" andAPIKey:@"yourapi"];


In your application, you can either provide your application specific API or user provided API. Logging into the bit.ly api helps in tracking the click throughs and referrals. The classes doesn’t provide a login or APIKey by itself.

Now, shortening or expanding URLs is as easy as calling these functions.

NSString *shortURL = [bitlyHelper shortenURL:@"http://mugunthkumar.com"];
NSString *longURL = [bitlyHelper expandURL:shortURL];

Disclaimers and other yada yada…

Be forewarned that it may have errors. As Donald Knuth says,

Beware of bugs in the above code; I have only proved it correct, not tried it.

Feel free you use this code and re-distribute it. The source code must retain the copyrights and my attribution in any derivative works of the source code.

On your application, you might opt to attribute me in your app though it’s not mandatory. I would be happy if you do so

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. Consuming a RESTful Service (bit.ly) in an iPhone Application bit-ly-rest-api-objective-c Introduction Of late, many programmers who develop for...
2. iPhone Tutorial: Follow Cost API and a open source wrapper What is Follow Cost? Follow Cost is a interesting and...
3. Formatting Dates relative to Now – Objective C (iPhone) codeproject Introduction Many a times, in an iPhone application,...

The product is in its early release phase and I intend to  submit it to AppStore by this month end. Currently I’m looking for beta testers. I’m looking for around 10-20 beta testers. As and when needs arise, I might increase the limit. I would prefer people who will be interested in testing the app’s second and third versions as well.

As of version 1, the most important features include, sharing files via email and the ability to browse and view downloaded files on iPhone without an active Internet connection. These features are illustrated in the screencast below.

If you prefer a direct download of the screencast, click here
https://my.syncplicity.com/share/kn3xqer1hn/Syncplicity_Screencast.zip — Removed direct download. This screencast is too old.

If you are interested in beta testing, drop me a mail @ feedback@mugunthkumar.com with your UDIDs.

You can send me your UDID using Erica Sadun’s UDID Generator. (iTunes Link)

For more information go to the Syncplicity forum here. (You need a Syncplicity account for accessing the forums)
https://my.syncplicity.com/Forums/default.aspx?g=posts&t=2793

For updates on this product, You can follow us on twitter @mksync.

Update: 21st September 2009: Closed for private beta. Follow us for product release updates.
Update: 19th October 2009: Product submitted to Apple. Follow us for product release updates.
Update: 7th November 2009: Product approved by Apple. No rejections whatsoever! Visit the product page for MKSync here.
Thanks,
Mugunth

For those who don’t know, what is Syncplicity, please read it’s wikipedia entry. It’s a cloud based, online backup and sync service, that works seamlessly behind the scenes to synchronize your data across computers simultaneously backing up to the cloud. Long gone are the days when you carried a USB drive around to keep your data in Sync. Apart from just syncing PCs, it can sync your google docs documents with your PC, keep your facebook albums in sync with your photos and much more…

©2010 blog.mugunthkumar.com. All Rights Reserved.

Related posts:

1. SingTel BBoM iPhone App (SG BBOM) SG BBoM iPhone App is designed specifically for use with...