This document represents our best efforts to share how we review apps submitted to the App Store, and we hope it is a helpful guide as you develop and submit your apps. It is a living document that will evolve as we are presented with new apps and situations, and we’ll update it periodically to reflect these changes.

The developers may put their best efforts to provide Apple with a great application, the final and best judge of whether it should/would be approved is Apple and only Apple. This is especially applicable to apps that provide Location-based Services because a user’s location data is private and sensitive. Plus Apple’s testers are extremely thorough; if the app is using network, they would test it on 3G, wifi, and also without network; if it uses location they will test the app behavior while location services turned on and off; and so on. But, if an app is rejected despite all efforts of the developer, Apple provides detailed reasons of rejection with crash reports, screenshots, steps to replicate bugs, etc, in short everything that a developer needs to know to remove the behavior that caused rejection. Quoted from News and Announcements > iOS on Apple’s developer portal:

View Details Of Any Issues During App Review
Mar 15, 2011
You can now view details about any issues found during the review of your app from the new Resolution Center in iTunes Connect.
If your app has been reviewed and needs further refining before it can be approved for the App Store, you will receive an email with a link to the iTunes Connect Resolution Center. The Resolution Center offers additional details, explanatory screenshots if applicable, and links to information on how to resolve any issues. You can also respond directly to the App Review Team from within the Resolution Center. All communications with the App Review Team will be visible to you and the Admin and Technical members of your team.

Also the number of times same app can be submitted for review is unlimited, at least its not stated anywhere by Apple, nor has any developer complained as yet that Apple refused submission because the app was rejected and resubmitted too many times.

Knowing that Apple has a completely thorough and evolving method of reviewing App Store submissions, developers can use it for their benefit. Rather than putting too much time, effort and resources on extensive testing, developers can just develop their apps, do a little testing, submit for review, and let Apple do the dirty work. At the end of the day, they are the ones with absolute autonomy of whether something goes on the app store or not. Plus they give back everything developers need to mould their app according to Apple’s standards. Also if someone has already set a release date for their app, it would be good idea to submit a month or even two ahead of that date and provide the exact date when the app should go live after getting accepted using Release Control in iTunes Connect.

Bottom line, Apple’s Review process is the best testing process that an iOS/Mac app can go through; at least its the only best that matters.

P.S. I do not mean that one should submit an app that crashes every seconds and is full of bugs; developers should definitely take some time to test their applications. What I mean is one can do all the testing in the world and still get the app rejected; so instead of going overboard with it, just make sure the app works smoothly in normal conditions and let Apple do more extensive testing.

No magic here, just a little observation; if you have ever made a call from Safari, you would have noticed that ending the call takes you back to Safari. Like me, you must have believed that Apple has added this custom behavior to Safari which is not accessible to us, bla bla bla…..actually thats not the case. This is UIWebView magic and if you use UIWebView to make calls instead of openURL:, you would get the same behavior. Lets see how to do that.

Using UIWebView to Place Calls

Simply, open your tel URL in a UIWebView. Like this

UIWebView *callWebview = [[UIWebView alloc] init];
NSURL *telURL = [NSURL URLWithString:@"tel:number to call"];
[callWebview loadRequest:[NSURLRequest requestWithURL:telURL]];

See, you dont even have to add the webview to your UI. Isn't this awesome?? Whats more awesome is, it displays an alert for confirmation before actually placing the call

Feel free to leave a comment and wander around on my blog to find out more interesting stuff. You can also follow me here or on twitter (@xs2bush) to stay updated. Happy Coding

Update: The second line of code was missing a semi colon, thanks Ken for pointing that out. Also the UIWebView object was accesses using wrong variable name. All is correct now! I apologize for any inconvenience that it has might caused anyone I have tested it on my iPhone and it works perfectly.

Call History Database – Path, and Schema

The iPhone call history is stored in “call_history.db” which is located at the following path:

/private/var/root/Library/CallHistory/call_history.db

There are other important databases on the iPhone, some of which are accessible and some are not. We can find that out using the following piece of code. This basically enumerates the system folder and subfolders and finds databases that are readable:

NSFileManager *fileManager = [NSFileManager defaultManager];
NSDirectoryEnumerator *dirnum = [[NSFileManager defaultManager] enumeratorAtPath: @"/private/"];
NSString *nextItem = [NSString string];
while( (nextItem = [dirnum nextObject])) {
    if ([[nextItem pathExtension] isEqualToString: @"db"] ||
        [[nextItem pathExtension] isEqualToString: @"sqlitedb"]) {
        if ([fileManager isReadableFileAtPath:nextItem]) {
            NSLog(@"%@", nextItem);
        }
    }
}

I got the following results:

var/db/launchd.db
var/mobile/Library/AddressBook/AddressBook.sqlitedb
var/mobile/Library/AddressBook/AddressBookImages.sqlitedb
var/wireless/Library/CallHistory/call_history.db

Feel free to share yours

So now we have the database path and we can easily read the values stored in it, but to know what value is what we need to know the schema. Here is a snippet to find that out:

NSString *callHisoryDatabasePath = @"/private/var/wireless/Library/CallHistory/call_history.db";
BOOL callHistoryFileExist = FALSE;
callHistoryFileExist = [fileManager fileExistsAtPath:callHisoryDatabasePath];
[fileManager release];

if(callHistoryFileExist) {
    if ([fileManager isReadableFileAtPath:callHisoryDatabasePath]) {
        sqlite3 *database;
        if(sqlite3_open([callHisoryDatabasePath UTF8String], &database) == SQLITE_OK) {

            //Getting table names and schema
            sqlite3_stmt *compiledStatement;
            NSString *sqlStatement = [NSString stringWithString:
                                    @"SELECT * FROM sqlite_master WHERE type='table';"];
            int errorCode = sqlite3_prepare_v2(database, [sqlStatement UTF8String], -1,
                                                 &compiledStatement, NULL);

            if( errorCode == SQLITE_OK) {
                int count = 1;
                while(sqlite3_step(compiledStatement) == SQLITE_ROW) {
                    // Read the data from the result row
                    int numberOfColumns = sqlite3_column_count(compiledStatement);
                    NSString *data;
                    NSString *columnName;
                    for (int i = 0; i < numberOfColumns; i++) {
                        columnName = [[NSString alloc] initWithUTF8String:
                                     (char *)sqlite3_column_name(compiledStatement, i)];
                        data = [[NSString alloc] initWithUTF8String:
                                 (char *)sqlite3_column_text(compiledStatement, i)];

                        NSLog(@"%@ : %@", columnName, data);

                        [columnName release];
                        [data release];
                    }
                    count++;
                }
            }
            else {
                NSLog(@"Failed to retrieve table");
                NSLog(@"Error Code: %d", errorCode);
            }
            sqlite3_finalize(compiledStatement);
        }
    }
}

You will get something like this:

type : table
 name : _SqliteDatabaseProperties
 tbl_name : _SqliteDatabaseProperties
 rootpage : 2
 sql : CREATE TABLE _SqliteDatabaseProperties (key TEXT, value TEXT, UNIQUE(key))

 type : table
 name : call
 tbl_name : call
 rootpage : 4
 sql : CREATE TABLE call (ROWID INTEGER PRIMARY KEY AUTOINCREMENT, address TEXT, date INTEGER, duration INTEGER, flags INTEGER, id INTEGER, name TEXT, country_code TEXT)

 type : table
 name : sqlite_sequence
 tbl_name : sqlite_sequence
 rootpage : 5
 sql : CREATE TABLE sqlite_sequence(name,seq)

 type : table
 name : data
 tbl_name : data
 rootpage : 6
 sql : CREATE TABLE data (ROWID INTEGER PRIMARY KEY AUTOINCREMENT, pdp_ip INTEGER, bytes_rcvd REAL, bytes_sent REAL, bytes_last_rcvd REAL, bytes_last_sent REAL, bytes_lifetime_rcvd REAL, bytes_lifetime_sent REAL)

More info on other iphone databases can be found on this link:

http://damon.durandfamily.org/archives/000487.html

Accessing the Call History

Now that we know the call history db path and schema, we can see that we are interested in the “call” table. Thanks to the above link, we know what exactly is stored in this table:

ROWID (INTEGER PRIMARY KEY AUTOINCREMENT) :   Auto-incrementing field/counter
address (TEXT) :   International-formatted foreign address 
date (INTEGER) :  OSX-epoch based datetime, convertable via date -r
duration (INTEGER) :  Length of call in seconds rounded to next minute, 0 = missed call
flags (INTEGER) :  Flags controlling the type of record; 5 – Outgoing call | 4 – Incoming call
id (INTEGER) :  AddressBook ID for outgoing calls selected from AddressBook, otherwise -1

Now we should write some code to access that. The following code accesses the “call” table and stores the retrieved values in an array of dictionaries. You could write your own class and use an array of objects of that class:

NSString *callHisoryDatabasePath = @"/private/var/wireless/Library/CallHistory/call_history.db";
BOOL callHistoryFileExist = FALSE;
callHistoryFileExist = [fileManager fileExistsAtPath:callHisoryDatabasePath];
[fileManager release];
NSMutableArray *callHistory = [[NSMutableArray alloc] init];

if(callHistoryFileExist) {
    if ([fileManager isReadableFileAtPath:callHisoryDatabasePath]) {
        sqlite3 *database;
        if(sqlite3_open([callHisoryDatabasePath UTF8String], &database) == SQLITE_OK) {
            sqlite3_stmt *compiledStatement;
            NSString *sqlStatement = [NSString stringWithString:@"SELECT * FROM call;"];

            int errorCode = sqlite3_prepare_v2(database, [sqlStatement UTF8String], -1,
                                                &compiledStatement, NULL);
            if( errorCode == SQLITE_OK) {
                int count = 1;

                while(sqlite3_step(compiledStatement) == SQLITE_ROW) {
                    // Read the data from the result row
                    NSMutableDictionary *callHistoryItem = [[NSMutableDictionary alloc] init];
                    int numberOfColumns = sqlite3_column_count(compiledStatement);
                    NSString *data;
                    NSString *columnName;

                    for (int i = 0; i < numberOfColumns; i++) {
                        columnName = [[NSString alloc] initWithUTF8String:
                                    (char *)sqlite3_column_name(compiledStatement, i)];
                        data = [[NSString alloc] initWithUTF8String:
                                (char *)sqlite3_column_text(compiledStatement, i)];

                        [callHistoryItem setObject:data forKey:columnName];

                        [columnName release];
                        [data release];
                    }
                    [callHistory addObject:callHistoryItem];
                    [callHistoryItem release];
                    count++;
                }
            }
            else {
                NSLog(@"Failed to retrieve table");
                NSLog(@"Error Code: %d", errorCode);
            }
            sqlite3_finalize(compiledStatement);
        }
    }
}

If you want to show date as a real date not number of seconds since epoch use this if-statement:

if (![columnName isEqualToString:@"date"]) {
    [callHistoryItem setObject:data forKey:columnName];
}
else {

    NSDate *callDate = [NSDate dateWithTimeIntervalSince1970:[data intValue]];
    NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
    [dateFormatter setDateStyle:NSDateFormatterFullStyle];
    [dateFormatter setTimeStyle:NSDateFormatterFullStyle];
    [dateFormatter setTimeZone:[NSTimeZone systemTimeZone]];

[callHistoryItem setObject:[dateFormatter stringFromDate:callDate] forKey:columnName];

}

Other conditions can be added to check the ‘flag’ and determining whether the call is incoming or outgoing.

Dont be afraid of using this in an application for the app store. There is already an app on iTunes that accesses call history.

Note: I found values other than 4 and 5 for flags, like 20,21. I dont know what they mean yet. Ill update as soon as I do. Meanwhile, you guys share what different values you get with us and also if you find out what they mean.

Happy Coding

Pulse has a unique UI that is as useful as it is pretty:

Each row contain feed from a single source and is horizontally scrollable. The visual representation is enough to get the gist of overall news and read only the stories that seem interesting or important. While this is a unique and efficient news reading application for the users, its also appealing to the developers (at least it was to me.)

So, here is a tutorial for creating the same interface (scree on the left):

 Things We Need

1. A UITableView whose cells have other UITableViews as subviews. You might find this tutorial helpful.

2. A bunch of images.

3. A taste for uniqueness. Most Important!

Lets Start

What we’re going to do is rotate our tableview that is the subview by -90 degrees. Then we are going to add images to each of its cells and rotate those images by 90 degrees.

Adjusting Sizes in IB

To start with, lets adjust the sizes a little bit. Open TableViewCell.xib (our UITableViewCell subclass from the above mentioned tutorial) and change the sizes as following:

1. Make the cell’s ‘View’ 320×220 for iPhone or 768×220 for iPad.

2. Make the UITableView 220×768. (Yes, the width and height is opposite to that of the cell because we’re going to rotate it.)

Adding and Initializing Required Properties

In our UITableViewController subclass, we need an array of arrays. Each of its object (i.e. an array) is going to contain a collection of objects that we want to be displayed in our horizontal tableview, in this case NSString objects having names of images. Lets declare those in our header file:

#import <UIKit/UIKit.h>

@class TableViewCell;

@interface TableViewController : UIViewController <UITableViewDataSource, UITableViewDelegate> {
      UITableView *tableView;
      TableViewCell *tableViewCell;
}

@property (nonatomic, retain) IBOutlet UITableView *tableView;
@property (nonatomic, retain) IBOutlet TableViewCell *tableViewCell;
@property (nonatomic, retain) NSArray *titlesArray;
@property (nonatomic, retain) NSArray *peopleArray;
@property (nonatomic, retain) NSArray *thingsArray;
@property (nonatomic, retain) NSArray *fruitsArray;
@property (nonatomic, retain) NSArray *arrays;

@end

and initialize in the implementation file:

- (void)viewDidLoad {
      [super viewDidLoad];

      titlesArray = [[NSArray alloc] initWithObjects:@"People", @"Things", @"Fruits", nil];
      peopleArray = [[NSArray alloc] initWithObjects:@"Gardener.png", @"Plumber.png",
                    @"BusinessWoman.png", @"BusinessMan.png", @"Chef.png", @"Doctor.png", nil];
      thingsArray = [[NSArray alloc] initWithObjects:@"StopWatch.png", @"TrashCan.png",
                    @"Key.png", @"Telephone.png", @"ChalkBoard.png", @"Bucket.png", nil];
      fruitsArray = [[NSArray alloc] initWithObjects:@"Pineapple.png", @"Orange.png",
                    @"Apple.png", nil];

      arrays = [[NSArray alloc] initWithObjects:peopleArray, thingsArray, fruitsArray, nil];
}

In our UITableViewCell subclass, we need an array to hold the content that is going to be displayed in its tableview. Lets declare that in its header:

#import <UIKit/UIKit.h>

@interface TableViewCell : UITableViewCell <UITableViewDataSource, UITableViewDelegate> {
      UITableView *horizontalTableView;
      NSArray *contentArray;
}

@property (nonatomic, retain) IBOutlet UITableView *horizontalTableView;
@property (nonatomic, retain) NSArray *contentArray;

@end

It will later be initialized in tableView:cellForRowAtIndexPath in the UITableViewController subclass.

Altering UITableViewDelegate and DataSource

We implemented UITableViewDelegate and DataSource for both our UITableViewController subclass and UITableViewCell subclass earlier. Now, we just need to change them a little bit.

In UITableViewController subclass, the datasource method tableView:cellForRowAtIndexPath: will be (Please also have a look at the second update):

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
      static NSString *CellIdentifier = @"Cell";
      TableViewCell *cell = (TableViewCell*)[self.tableView
                         dequeueReusableCellWithIdentifier:CellIdentifier];

      if (cell == nil) {
           [[NSBundle mainBundle] loadNibNamed:@"TableViewCell" owner:self options:nil];

           CGAffineTransform rotateTable = CGAffineTransformMakeRotation(-M_PI_2);
           tableViewCell.horizontalTableView.transform = rotateTable;
           tableViewCell.horizontalTableView.frame = CGRectMake(0, 0,
                         tableViewCell.horizontalTableView.frame.size.width,
                         tableViewCell.horizontalTableView.frame.size.height);

           tableViewCell.contentArray = [arrays objectAtIndex:indexPath.section];
           tableViewCell.horizontalTableView.allowsSelection = NO;

           cell = tableViewCell;
           self.tableViewCell = nil;
      }

      return cell;
}

Note: horizontalTableView is the subview of TableViewCell. In the preparatory tutorial it was named tableViewInsideCell.

Since we are separating the content through sections rather than rows, there are going to be more than one sections each having one row:

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
      // Return the number of sections.
      return [arrays count];

} 
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
      return 1;
}

- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section {
      return [titlesArray objectAtIndex:section];
}

Also change the height of each row to 220:

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
      return 220;
}

In UITableViewCell subclass, tableView:cellForRowAtIndexPath: will be:

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
      static NSString *CellIdentifier = @"Cell";
      UITableViewCell *cell = [self.horizontalTableView
                           dequeueReusableCellWithIdentifier:CellIdentifier];

      if (cell == nil) {
           cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle
                              reuseIdentifier:CellIdentifier] autorelease];
      }

      //Since we are reusing the cells, old image view needs to be removed form the cell
      for (UIImageView *view in cell.subviews) {
            [view removeFromSuperview];
      }

      UIImageView *imageView = [[UIImageView alloc] initWithFrame:CGRectMake(10, 10, 200, 200)];
      imageView.image = [UIImage imageNamed:[contentArray objectAtIndex:indexPath.row]];

      //Use UIContentModeScaleAspectFit or other depending upon the size of your images,
                    mine were small but not proportional so...    
      imageView.contentMode = UIViewContentModeCenter;
      CGAffineTransform rotateImage = CGAffineTransformMakeRotation(M_PI_2);
      imageView.transform = rotateImage;

      [cell addSubview:imageView];
      [imageView release];

      return cell;
}

Adjust the row height here also:

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
      return 220;
}

and done!

Here is what the result would look like:

Again, its raw, certainly not as pretty as Pulse, but it can be (rather should be) refined before using in an actual application. If it helped, you’re welcome

Any improvements or suggestions are most welcome in the comments sections. Do subscribe for more unique stuff.

Update

Borut pointed out that our custom cells with UITableView inside them are not being reused. If we study the code carefully, we will find out that we are not assigning any reuseIdentifier because we are not using the default -initWithStyle:reuseIdentifier method for creating cells. The reuseIdentifier property of UITableViewCell is readonly , we cannot set it. A workaround is to create a getter method in our UITableViewCell subclass for the reuseIdentifier and use the same string being used to dequeue the reusable cells. In our case, this should do:

- (NSString *) reuseIdentifier {
    return @"Cell";
}

Note that in this tutorial we are using @”Cell” for dequeuing cells in both UITableViewCell subclass and UITableViewController subclass. This needs to return the one we are using in the UITableViewCOntroller subclass because we want to reuse this cell there.

Update 2

Borut wanted to update the content dynamically and was having problems with the current version. Like I said earlier, this is a very limited implementation and can be improved. We improved it a little more. If you want to dynamically add remove content, change the ‘arrays’ ivar type to NSMutableArray and update the array. Now we need to tell our two tableviews to reload, not one, but two tableviews. First call reload on the parent tableView after editing the array, example:

[arrays removeLastObject];
[self.tableView reloadData];

Next we change our cellForRowAtIndexPath of parent tableView to add a method call to reload the child tableView:

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *CellIdentifier = @"Cell";
    TableViewCell *cell = (TableViewCell*)[self.tableView
                          dequeueReusableCellWithIdentifier:CellIdentifier];
	if (cell == nil) {
        [[NSBundle mainBundle] loadNibNamed:@"TableViewCell" owner:self options:nil];
        cell = tableViewCell;
		self.tableViewCell = nil;

    //changed the location of the closing bracket
    }   

    CGAffineTransform rotateTable = CGAffineTransformMakeRotation(-M_PI_2);
    cell.horizontalTableView.transform = rotateTable;
    cell.horizontalTableView.frame = CGRectMake(0, 0, cell.horizontalTableView.frame.size.width,
                                     cell.horizontalTableView.frame.size.height);

    cell.contentArray = [arrays objectAtIndex:indexPath.section];

    //addition
    [cell reloadContent];
    cell.horizontalTableView.allowsSelection = YES;

    return cell;
}

Now also add the reloadContent method to the UITableViewCell subclass:

- (void)reloadContent {
    [self.horizontalTableView reloadData];
}

Update 3

Thanks a lot for your appreciation. Since there were a lot of requests for code. I’ve uploaded it to dropbox. Here is the link:
http://dl.dropbox.com/u/17653793/Pulse.zip

Prep work – Getting things ready

First, we shall prepare all the stuff that we would be working with in order to load a UITableView inside a UITableViewCell. Goes without saying but I’d say it anyway, create/open an Xcode project that has a UITableViewController subclass or has a UIViewController subclass with a UITableView in it.

Real Work

Making a custom UITableViewCell

In order to make a custom UITableViewCell, first of all, create a subclass of UITableViewCell, we’ll name it ‘TableViewCell’. In Xcode 4, File > New > New File and in the dialog select UIViewController subclass and in the ‘Next’ dialog type UITableViewCell in the ‘subclass’ text field.

Step 1: Adjust Objects and Properties in Xib File

Open the xib file of your UITabelViewCell subclass and incase you cannot change the size of the view, delete that view, add a new UIView, and adjust the height to the value you need. I made it 200 so that I can have eight 25 pi long cells inside this cell (25×8=200).

Next thing, change the class of the ‘View’ object. Select the ‘View’ object, open ‘Identity Inspector’, and type your subclass’s name i.e. ‘TableViewCell’.

After that change the ‘File’s Owner’ to the UITableViewController subclass (or the class that has the table view whose cell this is)

Next create the IBOutlet for the UITableView inside this cell in the header file for UITableViewCell’s subclass, let’s name it tableViewInsideCell. In XIB, connect the IBOutlet and set the delegate and dataSource of the tableViewInsideCell to the ‘View’ object (whose class we just changed to ‘TableViewCell’) not the File’s Owner. This is an important step, so be careful. We will only make one connection to the File’s Owner and that is going to be with the ‘View’ object of this xib.

(See how the dataSource, delegate and ref outlet connections are made with the ‘TableViewCell’ rather than the File’s Owner.)

Step 2: Implement the UITableView Delegate and DataSource in UITableViewCell subclass

In the header, add the protocol that this class is implementing, i.e. UITableView delegate and data source. So, TableViewCell.h would look like:

#import <UIKit/UIKit.h>

@interface TableViewCell : UITableViewCell <UITableViewDelegate, UITableViewDataSource> {
      NSDictionary *data;
}

@property (nonatomic, retain) IBOutlet UITableView *tableViewInsideCell;
@property (nonatomic, retain) NSDictionary *data;

@end

Note that there is an NSDictionary object in .h file. This will be used to transfer data from the UITableViewController subclass to the UITableViewCell subclass. Use this dictionary in a switch or an appropriate conditional statement to set appropriate data values for each cell inside the tableView:cellForRowAtIndexPath delegate method.

TableViewCell.m would have the UITableView delegate and dataSource methods. Here is what it would look like:

#import "TableViewCell.h"

@implementation TableViewCell

@synthesize tableViewInsideCell;
@synthesize data;

- (void)dealloc {
      [data release];
      [tableViewInsideCell release];
      [super dealloc];
}

- (id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier {
      self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];
      if (self) {
          // Custom initialization
      }
      return self;
}

#pragma mark - Table view data source
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
      // Return the number of sections.
      return 1;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
      // Return the number of rows in the section.
      return 8;
}

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
      static NSString *CellIdentifier = @"Cell";
      UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
      if (cell == nil) {
          cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1
                            reuseIdentifier:CellIdentifier] autorelease];
      }

      // Configure the cell...

     switch (indexPath.row) {
        case 0:
            cell.textLabel.text = @"Latitude";
            cell.detailTextLabel.text = [data objectForKey:@"Latitude"];
            break;

        case 1:
            cell.textLabel.text = @"Longitude";
            cell.detailTextLabel.text = [data objectForKey:@"Longitude"];
            break;

        case 2:
            cell.textLabel.text = @"Speed";
            cell.detailTextLabel.text = [data objectForKey:@"Speed"];
            break;

        case 3:
            cell.textLabel.text = @"Altitude";
            cell.detailTextLabel.text = [data objectForKey:@"Altitude"];
            break;

        case 4:
            cell.textLabel.text = @"Date";
            cell.detailTextLabel.text = [data objectForKey:@"Date"];
            break;

        case 5:
            cell.textLabel.text = @"Time";
            cell.detailTextLabel.text = [data objectForKey:@"Time"];
            break;

        case 6:
            cell.textLabel.text = @"Course";
            cell.detailTextLabel.text = [data objectForKey:@"Course"];
            break;

        case 7:
            cell.textLabel.text = @"Accuracy";
            cell.detailTextLabel.text = [data objectForKey:@"Accuracy"];
            break;

        default:
            break;
      }

      return cell;
}

#pragma mark - Table view delegate
-(CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{
    return 25;
}
@end

Adding the custom UITableViewCell to the Tableview

In order to add this custom cell to our tableview, the first step is to make an outlet for ‘TableViewCell’ (your UITableViewCell’s subclass) inside your UITableViewController subclass. This is what the ‘TableViewController.h’ would look like:

#import <UIKit/UIKit.h>

@class TableViewCell;

@interface TableViewController : UITableViewController {
    NSArray *dataArray;
}

@property (nonatomic, retain) IBOutlet TableViewCell *tableViewCellWithTableView;

@end

Open TableViewCell.xib and make the ‘View’ object’s (whose class we changed to ‘TableViewCell’) connection with the File’s Owner. We are doing this because we changed the File’s Owner class to our UITableViewController subclass. So our cell’s outlet in the tableview controller header will be connected to the custom cell that we created

Making the connections is confusing but its following a simple rule; connections are made with the class that has the outlet declared in it. Here is the list of all connections made in TableViewCell.xib:

1. Custom cell’s View <-> File’s Owner | class: TableViewController (because we need the cell object in TableViewController class to assign in tableView:cellForRowAtIndexPath)

2. Tableview inside the cell <-> custom cell’s View | class: TableViewCell (because the tableView is inside the cell)

3. UITableViewDelegate & UITableViewDataSource <-> custom cell’s View | class: TableViewCell (because the tableview that is inside the cell has its delegate and data source implemented in our custom cell’s class. These two connections are very important, if these are made with the File’s Owner by mistake then remember the File’s Owner which is tableview controller is implementing its own delegate and data source for the top most tableview, so you wouldn’t get an error but also not any output)

Anyway, coming back. After making the connection in the xib, add the custom TableViewCell to the table view like so:

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    static NSString *CellIdentifier = @"CellWithTableView";
    TableViewCell *cell = (TableViewCell*)[tableView dequeueReusableCellWithIdentifier:CellIdentifier];

    if (cell == nil) {
        [[NSBundle mainBundle] loadNibNamed:@"TableViewCell" owner:self options:nil];
        tableViewCellWithTableView.data = [dataArray objectAtIndex:indexPath.row];
        tableViewCellWithTableView.tableViewInsideCell.allowsSelection = NO;
        cell = tableViewCellWithTableView;
        [cell setNeedsDisplay];
    }

    return cell;
}

Note that the cell needs to be loaded from the xib rather than by using the initWithStyle:reuseIdentifier method. Also note that the NSDictionary object called ‘data’ that was declared in the custom cell header is being assigned the appropriate element from the dataArray. The dataArray was initialized to have NSDictionary objects, like so:

    NSDictionary *one = [[[NSDictionary alloc] initWithObjectsAndKeys:@"13.861970", @"Latitude",
                          @"100.504250", @"Longitude",
                          @"50 kph", @"Speed",
                          @"1000 meters", @"Altitude",
                          @"12/04/2010", @"Date",
                          @"05:45 PM", @"Time",
                          @"North west", @"Course",
                          @"+/- 10 meters", @"Accuracy", nil] autorelease];

    NSDictionary *two = [[[NSDictionary alloc] initWithObjectsAndKeys:@"13.862470", @"Latitude",
                          @"100.501389", @"Longitude",
                          @"60 kph", @"Speed",
                          @"1050 meters", @"Altitude",
                          @"12/04/2010", @"Date",
                          @"06:15 PM", @"Time",
                          @"North", @"Course",
                          @"+/- 10 meters", @"Accuracy", nil] autorelease];

    NSDictionary *three = [[[NSDictionary alloc] initWithObjectsAndKeys:@"13.861970", @"Latitude",
                            @"100.504250", @"Longitude",
                            @"70 kph", @"Speed",
                            @"1000 meters", @"Altitude",
                            @"12/04/2010", @"Date",
                            @"06:35 PM", @"Time",
                            @"South", @"Course",
                            @"+/- 10 meters", @"Accuracy", nil] autorelease];

    NSDictionary *four = [[[NSDictionary alloc] initWithObjectsAndKeys:@"13.861970", @"Latitude",
                           @"100.504250", @"Longitude",
                           @"50 kph", @"Speed",
                           @"1050 meters", @"Altitude",
                           @"12/04/2010", @"Date",
                           @"06:55 PM", @"Time",
                           @"South West", @"Course",
                           @"+/- 10 meters", @"Accuracy", nil] autorelease];

    dataArray = [[NSArray alloc] initWithObjects:one, two, three, four, nil];

That is all, just remember to set the cell height to the height of your custom cell.

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{
    return 200;
}

With the above dummy data, my table looked like this:

This is the most raw form and can be customized in many ways to look nicer. I hope someone out there finds it useful…

Trying this and actually succeeding in it made me realize that iOS SDK is flexible and any UIView subclass element to any other UIView subclass. So don’t be afraid to implement new ideas no matter how wild they might appear. For those eager to try wild stuff, have a look at ‘Pulse’, its a news reader app that won Apple’s Design Award 2011. This app has horizontally scrollable images and its developers explained that they have used UITableViews to create that. I might try that myself and post a tutorial
Update: Pulse-style scrolling tutorial has been published. Enjoy!

Update

Borut pointed out that our custom cells with UITableView inside them are not being reused. If we study the code carefully, we will find out that we are not assigning any reuseIdentifier because we are not using the default -initWithStyle:reuseIdentifier method for creating cells. The reuseIdentifier property of UITableViewCell is readonly , we cannot set it. A workaround is to create a getter method in our UITableViewCell subclass for the reuseIdentifier and use the same string being used to dequeue the reusable cells. In our case, this should do:

- (NSString *) reuseIdentifier {
    return @"Cell";
}

Note that in this tutorial we are using @”Cell” for dequeuing cells in both UITableViewCell subclass and UITableViewController subclass. This needs to return the one we are using in the UITableViewCOntroller subclass because we want to reuse this cell there.

Update 2

Thanks a lot for your appreciation. Since there were a lot of requests for code. I’ve uploaded it to dropbox. Here is the link:
http://dl.dropbox.com/u/17653793/TableViewInsideCell.zip

Being a developer myself, I was wondering did they actually put a separate ‘condition’ to alert users that they are about to delete Angry Birds???

If they did, way to go Angry Birds!!!

This tutorial has two parts:

1. Creating the photo gallery.

2. Converting this photo gallery to a video Gallery.

So, lets begin…

1. Creating Photo Gallery

Step 1: Create an Xcode Project

If you do not already have a project in which you want to create the gallery, now would be the time to create one. If you are starting from scratch, create a ‘Window-based’ project in Xcode. Lets name it “PhotoVideoGallery”, which is the name that will be used from now on in the tutorial.

Step 2: Download and build the three20 framework.

First of all, download the latest version of three20 from github. Now that we have three20, we need to add it to our project.

This little tutorial by the creator of three20 is quite convenient for building it. Here are the main steps so you don’t have to navigate away:

1. Make a new folder on the desktop and copy both three20 and your project (a copy preferably) into it.

2. Open terminal and move to the desktop using this command

cd ~/Desktop

3. Three20 includes a python script that adds it to Xcode iOS projects. We can run the script by running this command in the terminal:

python three20/src/scripts/ttmodule.py -p PhotoVideoGallery/PhotoVideoGallery.xcodeproj Three20

4. What? there’s no step 4 Simple as that!!!

Note: If you do not want to copy/move your project, you can build three20 into it using this terminal command replacing your specific paths and project’s name:

python path/to/three20/src/scripts/ttmodule.py -p path/to/myProjectName.xcodeproj Three20

You might get an alert when you open your project that your project has been altered from an outside entity. In that case, you need to click on the “Read from Disk” button.

Step 3: Start making the gallery, finally

First a word on how this works. We need a thumbnail gallery, which needs a source that provides it the photos to display. This source needs photos so it can give them to the gallery. So we have to make three new classes, one for the photo, one for the photo source and one for the gallery.

The Photo Class

Create a subclass called “Photo” of NSObject and make it conform to the protocol <TTPhoto>. Now according to this protocol, our photo must have the following attributes and methods:

* The photo source that the photo belongs to.
 @property (nonatomic, assign) id photoSource;

 * The size of the photo.
 @property (nonatomic) CGSize size;

 * The index of the photo within its photo source.
 @property (nonatomic) NSInteger index;

 * The caption of the photo.
 @property (nonatomic, copy) NSString* caption;

 * Gets the URL of one of the differently sized versions of the photo.
 - (NSString*)URLForVersion:(TTPhotoVersion)version;

we are going to use an -init method to set these attributes. So our Photo.h looks like this

@interface Photo : NSObject  {
      NSString *_caption;
      NSString *_urlLarge;
      NSString *_urlSmall;
      NSString *_urlThumb;
      id  _photoSource;
      CGSize _size;
      NSInteger _index;
}
@property (nonatomic, copy) NSString *caption;
@property (nonatomic, copy) NSString *urlLarge;
@property (nonatomic, copy) NSString *urlSmall;
@property (nonatomic, copy) NSString *urlThumb;
@property (nonatomic, assign) id  photoSource;
@property (nonatomic) CGSize size;
@property (nonatomic) NSInteger index;
- (id)initWithCaption:(NSString *)caption urlLarge:(NSString *)urlLarge
urlSmall:(NSString *)urlSmall urlThumb:(NSString *)urlThumb size:(CGSize)size;
@end

and Photo.m looks like this:

#import "Photo.h"

@implementation Photo
@synthesize caption = _caption;
@synthesize urlLarge = _urlLarge;
@synthesize urlSmall = _urlSmall;
@synthesize urlThumb = _urlThumb;
@synthesize photoSource = _photoSource;
@synthesize size = _size;
@synthesize index = _index;

- (id)initWithCaption:(NSString *)caption urlLarge:(NSString *)urlLarge
                    urlSmall:(NSString *)urlSmall urlThumb:(NSString *)urlThumb size:(CGSize)size {

    if ((self = [super init])) {
       self.caption = caption;
       self.urlLarge = urlLarge;
       self.urlSmall = urlSmall;
       self.urlThumb = urlThumb;
       self.size = size;
       self.index = NSIntegerMax;
       self.photoSource = nil;
    }
    return self;
    }

- (void) dealloc {
     self.caption = nil;
     self.urlLarge = nil;
     self.urlSmall = nil;
     self.urlThumb = nil;
     [super dealloc];
 }

#pragma mark TTPhoto

- (NSString*)URLForVersion:(TTPhotoVersion)version {
     switch (version) {
       case TTPhotoVersionLarge:
         return _urlLarge;
       case TTPhotoVersionMedium:
         return _urlLarge;
       case TTPhotoVersionSmall:
         return _urlSmall;
       case TTPhotoVersionThumbnail:
         return _urlThumb;
       default:
         return nil;
     }
}

@end

The Photo Source Class

Create a subclass called “PhotoSource” of TTURLRequestModel (so that we can also download photos from a server using the same class) and make it conform to the protocol <TTPhotoSource>. Now according to this protocol, our photo must have the following attributes and methods:

* The title of this collection of photos.
 @property (nonatomic, copy) NSString* title;

* The total number of photos in the source, independent of the number that have been loaded.
 @property (nonatomic, readonly) NSInteger numberOfPhotos;

* The maximum index of photos that have already been loaded.
 @property (nonatomic, readonly) NSInteger maxPhotoIndex;

- (id)photoAtIndex:(NSInteger)index;

So our PhotoSource.h looks like:

@interface PhotoSource : TTURLRequestModel  {
   NSString *_title;
   NSArray *_photos;
}

@property (nonatomic, copy) NSString *title;
@property (nonatomic, retain) NSArray *photos;
+ (PhotoSet*)samplePhotoSet;

@end

and our PhotoSource.m should look like:

#import "PhotoSource.h"
#import "Photo.h"

@implementation PhotoSource
@synthesize title = _title;
@synthesize photos = _photos;

- (id) initWithTitle:(NSString *)title photos:(NSArray *)photos {
     if ((self = [super init]))
       self.title = title;
       self.photos = photos;
       for(int i = 0; i < _photos.count; ++i) {
         Photo *photo = [_photos objectAtIndex:i];
         photo.photoSource = self;
         photo.index = i;
       }
     }
     return self;
}

- (void) dealloc {
     self.title = nil;
     self.photos = nil;
     [super dealloc];
}

#pragma mark TTModel

- (BOOL)isLoading {
     return FALSE;
}

- (BOOL)isLoaded {
     return TRUE;
}

#pragma mark TTPhotoSource

- (NSInteger)numberOfPhotos {
     return _photos.count;
}

- (NSInteger)maxPhotoIndex {
     return _photos.count-1;
}

- (id)photoAtIndex:(NSInteger)photoIndex {
     if (photoIndex < _photos.count) {
         return [_photos objectAtIndex:photoIndex];
     } else {
         return nil;
     }
}

static PhotoSource *samplePhotoSet = nil;

+ (PhotoSet*) samplePhotoSet {
     @synchronized(self) {
       if (samplePhotoSet == nil) {
         Photo *firstPhoto = [[[Photo alloc] initWithCaption:@"Lake"
                                                     urlLarge:@"bundle://Lake.jpg"
                                                     urlSmall:nil
                                                     urlThumb:@"bundle://Lake_Thumb.png"
                                                     size:CGSizeMake(1024, 768)] autorelease];

         Photo *secondPhoto = [[[Photo alloc] initWithCaption:@"Shed"
                                                     urlLarge:@"bundle://Shed.jpg"
                                                     urlSmall:nil
                                                     urlThumb:@"bundle://Shed_Thumb.png"
                                                     size:CGSizeMake(768, 1024)] autorelease];

         Photo *thirdPhoto = [[[Photo alloc] initWithCaption:@"Tree"
                                                     urlLarge:@"bundle://Tree.jpg"
                                                     urlSmall:nil
                                                     urlThumb:@"bundle://Tree_Thumb.png"
                                                     size:CGSizeMake(683, 1024)] autorelease];

         NSArray *photos = [NSArray arrayWithObjects:firstPhoto, secondPhoto, thirdPhoto, nil];
         samplePhotoSet = [[self alloc] initWithTitle:@"Pictures" photos:photos];
       }
     }
     return samplePhotoSet;
 }
@end

Note: Replace the image names, paths, and sizes for this to work.

To display a thumbnail gallery we need to subclass ‘TTThumbsViewController‘ class of three20. So,

1. Follow the old creating new file routine, File > New > New File. Select the ‘UIViewController subclass’ when it asks the template for your new file. In the next step, type “TTThumbsViewController” in the ‘subclass’ text field. Give your class a name, we’ll name it “ThumbsViewController”

2. Now, ThumbsViewController needs a photoSource so add it as an attribute to our class. ThumbsViewController.h looks like:

#import 
@class PhotoSource;

@interface ThumbsViewController : TTThumbsViewController {
      PhotoSource *_myPhotoSource;
}
@property (nonatomic, retain) PhotoSource *myPhotoSource;
@end

and in the implementation we set the photo source to ours and ThumbsViewController.m looks like:

#import "ThumbsViewController.h"
#import "PhotoSource.h"

@implementation ThumbsViewController
@synthesize myPhotoSource;

- (void) viewDidLoad {
     self.myPhotoSource = [PhotoSource samplePhotoSet];
 }

- (void) dealloc {
     self.myPhotoSource = nil;
     [super dealloc];
 }

@end

All is done, except we should display ThumbsViewController somewhere in order to be able to view our gallery. So, we add this to our app delegate :

UINavigationController *navigationController = [[UINavigationController alloc]
                             initWithRootViewController:[[ThumbsViewController alloc] init]];
[self.window navigationController];
[navigationController release];

Here is what it should look like and when a thumbnail is tapped, the photos are opened in a scroller, just like int the ‘Photos’ app:

2. Converting it to a Video Gallery

Now, we shall convert this photo gallery we just made into a video gallery. So what we have to do is, in TTThumbsViewController, find the method that is called when a thumbnail is tapped and override it in our ThumbsViewController (our TTThumbsViewController subclass). The function that we’re looking for is thumbsTableViewCell: didSelectPhoto:. So Add this code to your ThumbsViewController:

- (void)thumbsTableViewCell:(TTThumbsTableViewCell*)cell didSelectPhoto:(id)photo {
        NSString *videoName = [photo caption];
        NSString *videoPath = [[NSBundle mainBundle] pathForResource:videoName ofType:@"m4v"];
        VideoPlayerViewController *videoController = [[VideoPlayerViewController alloc]
                               initWithPath:videoPath];
        [self presentModalViewController:videoController animated:YES];
        [videoController readyPlayer];
}

Note that photo’s caption that we had previously set in initWithCaption: urlLarge: urlSmall urlThumb size: inside the PhotoSource class is being used as the name of the video in this case. The ivar caption is displayed in the photo scroller. Since we are not loading the photo scroller in this case, we can use it to store the names of our videos so that we can later use them to get required video from the app bundle. Also note that VideoPlayerViewController is another UIViewController subclass that manages the MPMoviePlayer. The player can also be initialized and loaded here directly.

Legend: Bolded items are keywords specific to Three20 framework so they can be distinguished from our subclasses

Code Courtesy for Photo and PhotoSource code: Ray Wenderlich
Code Courtesy for ThumbnailViewController code: https://github.com/crigor/three20_examples