For example, if you want to slowly fade-in (increase) the volume of the audio player over a few seconds, you could write a loop to bump the volume a small increment each time through the loop, and pause briefly before heading back to the top of the loop. If you didn’t include a short pause within the loop, the application may run the loop so quickly that you could not audibly detect the fade-in.

sleepForTimeInterval

One approach is to use the class method sleepForTimeInterval method:

+ (void)sleepForTimeInterval:(NSTimeInterval)ti

The variable NSTimeInterval is of type double and represents the number of seconds to sleep

// Block for .5 seconds
[NSThread sleepForTimeInterval:.5];

sleepUntilDate

Another approach is to use an NSDate object to specify a specific time in the future to resume the thread:

+ (void)sleepUntilDate:(NSDate *)aDate

With this method you pass in an NSDate object that specifies how long to block the thread.

// Block for 2.5 seconds from "now"
 NSThread sleepUntilDate: [NSDate dateWithTimeIntervalSinceNow:0.5]];

The video below shows a rotating a button (on the left) as well as image. Notice the direction of rotation is clockwise on the button and counter-clockwise on the image. Also, notice that the rate of the spin is different for each object.

Spin/Rotate Code

This method accepts a layer object (CALayer), the duration of the spin (in seconds) and the direction:

- (void)spinLayer:(CALayer *)inLayer duration:(CFTimeInterval)inDuration
     direction:(int)direction
{
  CABasicAnimation* rotationAnimation;
 
  // Rotate about the z axis
  rotationAnimation = 
    [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"];
 
  // Rotate 360 degress, in direction specified
  rotationAnimation.toValue = [NSNumber numberWithFloat: M_PI * 2.0 * direction];
 
  // Perform the rotation over this many seconds
  rotationAnimation.duration = inDuration;
 
  // Set the pacing of the animation
  rotationAnimation.timingFunction = 
    [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
 
  // Add animation to the layer and make it so
  [inLayer addAnimation:rotationAnimation forKey:@"rotationAnimation"];
}

Calling the spinLayer Method

The code below shows how to call the method, specifying the duration and the direction. Make note that the layer associated with the image/button is passed in to the method:

#define SPIN_CLOCK_WISE 1
#define SPIN_COUNTERCLOCK_WISE -1
 
UIImageView  *testImage;
...
[self spinLayer:testImage.layer duration:1 direction:SPIN_CLOCK_WISE];
 
UIButton *infoButton;
...
[self spinLayer:infoButton.layer duration:3 direction:SPIN_COUNTERCLOCK_WISE];

Spin Effect – Timing Functions

Notice in the original example I specified kCAMediaTimingFunctionEaseInEaseOut as the timing function name, which defines the pacing of the animation, in this case, the animation begins slowly, accelerates and then slows again.

You can experiment with the following timing functions for various effects:

kCAMediaTimingFunctionLinear
kCAMediaTimingFunctionEaseIn
kCAMediaTimingFunctionEaseOut
kCAMediaTimingFunctionEaseInEaseOut
kCAMediaTimingFunctionDefault

I attended a recent Apple Tech Talk and one of the more interesting discussions was on how to create code to dynamically resize images, using an approach that is thread safe. An experienced developer at the event was willing to share an excellent code example that I’ll walk through in this post. The code is a fair amount more complex than the first version I wrote, however, with the complexity comes flexibility.

Building the User Interface

The project to demonstrate thread-safe image resizing is quite simple, essentially a table and a slider, with the later controlling the size of the images in the table. The image below should give you and idea of how things work:

It all starts by building a UITableView and setting the imageView property to one of the images in the application bundle. The code to build (or reload) the table looks as follows:

1
2
3
4
5
6
7
8
9
10
11

-(UITableViewCell *) tableView:(UITableView *)tableView 
   cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
  UITableViewCell *cell = 
	(UITableViewCell*) [tableView dequeueReusableCellWithIdentifier:kMyCellID];
  ...
 
  cell.imageView.image = [self requestImageForIndex:row];
 
  return cell;
}

The relevant line of code is 8, notice the call to requestImageForIndex, the code for this method is shown below. There is a fair amount going on here, first an ImageStateObject is created, this keeps track of the path of the image, a flag indicating if the image has been loaded and a flag indicating if a (resize) operation is in progress. There is also code for managing a queue of operations -to keep focuses on the task at hand, skip down to LINE 20, where we call UImageFromPathScaledToSize passing in the image state object and the preferred size.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

-(UIImage*) requestImageForIndex:(NSUInteger)index
{
  ImageStateObject *iso	= [self imageObjectForIndex:index];
  CGSize  theSz = [self preferredImageSize];
 
  if( mUseOperations )
  {
    if( iso.hasImage == NO && iso.queuedOp == NO )	// if we dont have an image and there is no operation pending
    {	
      // Queue up an operation to do the work!
      MyLoadScaleOperation *op = [[MyLoadScaleOperation alloc] initWithPath:iso.path index:index targetSize:theSz];
      op.resultsDelegate = self;		// set the delegate
      [mQueue addOperation:op];
      [op release];
 
      iso.queuedOp = YES;
    }		
    return mPlaceHolderImage;		// just return our placeholder
  }	
  return UImageFromPathScaledToSize( iso.path, theSz );
}

Note that when calling the method on line 20, notice the path to the image is passed in as the first parameter.

ImageStateobject

For completeness, here is the definition of the image state object:

@interface ImageStateObject : NSObject
{
  NSString *path;
  BOOL  hasImage;
  BOOL  queuedOp;
}

The code for working with the queued operations (queuedOp) we will look into in a future post.

UImageFromPathScaledToSize

Given a path to an image and a specified size, create a UIImage object and get the scale value based on the current image size and the size to scale to, and finish by creating a new UIImage object from the original image, scaled as requested.

UIImage *UImageFromPathScaledToSize(NSString* path, CGSize toSize)
{
  UIImage *scaledImg = nil;
  UIImage *img = [[UIImage alloc] initWithContentsOfFile:path];	// get the image
 
  if( img )
  {
    float scale = GetScaleForProportionalResize( img.size, toSize, false, false );
 
    CGImageRef cgImage	= CreateCGImageFromUIImageScaled( img, scale );
 
    [img release];
 
    if( cgImage )
    {
      scaledImg = [UIImage imageWithCGImage:cgImage];	// autoreleased
      CGImageRelease( cgImage );
    }
  }
  return scaledImg;	// autoreleased
}

Get Scale Percentage and Create New Image Reference

Below is the code to determine the scale value as a percentage. For example, if the incoming image size (theSize) is 266 x 401 and the destination size (intoSize) is 225 x 225, the returned scale value is .561 (225/401). That is, we want to scale the image to 56% of its current size.

float GetScaleForProportionalResize( CGSize theSize, CGSize intoSize, bool onlyScaleDown, bool maximize )
{
  float sx = theSize.width;
  float sy = theSize.height;
  float dx = intoSize.width;
  float dy = intoSize.height;
  float scale = 1;
 
  if( sx != 0 && sy != 0 )
  {
    dx = dx / sx;
    dy	 = dy / sy;
 
    // if maximize is true, take LARGER of the scales, else smaller
    if( maximize )
      scale = (dx > dy)	? dx : dy;
    else			
      scale = (dx < dy)	? dx : dy;
 
    if( scale > 1 && onlyScaleDown )	// reset scale
      scale = 1;
  }
  else
  {
    scale = 0;
  }
  return scale;
}

The last step is to create a CGImageRef which will hold bitmap information for the new, scaled image. This reference will then be used to create our final scaled UIImage object.

CGContextRef CreateCGBitmapContextForWidthAndHeight( unsigned int width, unsigned int height, 
    CGColorSpaceRef optionalColorSpace, CGBitmapInfo optionalInfo )
{
  CGColorSpaceRef colorSpace = (optionalColorSpace == NULL) ? GetDeviceRGBColorSpace() : optionalColorSpace;
  CGBitmapInfo alphaInfo	= ( (int32_t)optionalInfo < 0 ) ? kDefaultCGBitmapInfo : optionalInfo;
  return CGBitmapContextCreate( NULL, width, height, 8, 0, colorSpace, alphaInfo );
}
 
CGImageRef CreateCGImageFromUIImageScaled( UIImage* image, float scaleFactor )
{
  CGImageRef newImage = NULL;
  CGContextRef bmContext = NULL;
  BOOL  mustTransform = YES;
  CGAffineTransform  transform = CGAffineTransformIdentity;
  UIImageOrientation orientation = image.imageOrientation;
 
  CGImageRef srcCGImage = CGImageRetain( image.CGImage );
 
  size_t width = CGImageGetWidth(srcCGImage) * scaleFactor;
  size_t height = CGImageGetHeight(srcCGImage) * scaleFactor;
 
  // These Orientations are rotated 0 or 180 degrees, so they retain the width/height of the image
  if ( (orientation == UIImageOrientationUp) || (orientation == UIImageOrientationDown) || (orientation == UIImageOrientationUpMirrored) || (orientation == UIImageOrientationDownMirrored)  )
  {	
    bmContext	= CreateCGBitmapContextForWidthAndHeight( width, height, NULL, kDefaultCGBitmapInfo );
  }
  else	// The other Orientations are rotated ±90 degrees, so they swap width & height.
  {	
    bmContext	= CreateCGBitmapContextForWidthAndHeight( height, width, NULL, kDefaultCGBitmapInfo );
  }
 
  CGContextSetBlendMode( bmContext, kCGBlendModeCopy );	// we just want to copy the data
 
  switch(orientation)
  {
    case UIImageOrientationDown:		// 0th row is at the bottom, and 0th column is on the right - Rotate 180 degrees
    transform = CGAffineTransformMake(-1.0, 0.0, 0.0, -1.0, width, height);
    break;
 
    case UIImageOrientationLeft:		// 0th row is on the left, and 0th column is the bottom - Rotate -90 degrees
    transform = CGAffineTransformMake(0.0, 1.0, -1.0, 0.0, height, 0.0);
    break;
 
    case UIImageOrientationRight:		// 0th row is on the right, and 0th column is the top - Rotate 90 degrees
    transform = CGAffineTransformMake(0.0, -1.0, 1.0, 0.0, 0.0, width);
    break;
 
    case UIImageOrientationUpMirrored:	// 0th row is at the top, and 0th column is on the right - Flip Horizontal
    transform = CGAffineTransformMake(-1.0, 0.0, 0.0, 1.0, width, 0.0);
    break;
 
    case UIImageOrientationDownMirrored:	// 0th row is at the bottom, and 0th column is on the left - Flip Vertical
    transform = CGAffineTransformMake(1.0, 0.0, 0, -1.0, 0.0, height);
    break;
 
    case UIImageOrientationLeftMirrored:	// 0th row is on the left, and 0th column is the top - Rotate -90 degrees and Flip Vertical
    transform = CGAffineTransformMake(0.0, -1.0, -1.0, 0.0, height, width);
    break;
 
    case UIImageOrientationRightMirrored:	// 0th row is on the right, and 0th column is the bottom - Rotate 90 degrees and Flip Vertical
    transform = CGAffineTransformMake(0.0, 1.0, 1.0, 0.0, 0.0, 0.0);
    break;
 
    default:
    mustTransform = NO;
    break;
  }
 
  if ( mustTransform )	
    CGContextConcatCTM( bmContext, transform );
 
  CGContextDrawImage( bmContext, CGRectMake(0.0, 0.0, width, height), srcCGImage );
  CGImageRelease( srcCGImage );
  newImage = CGBitmapContextCreateImage( bmContext );
  CFRelease( bmContext );
 
  return newImage;
}

Project Source Code

You can download the entire project source code here. You’ll find the image processing code shown above is in the source file ImageHelpers.m.

There are many other worthwhile code snippets to look at in this project, including code to create and display gradients (for the table background) as well as working with NSOperation and NSOperationQueue to place resize requests into a queue for processing.

Creating More Readable Link

If you want to create a link that is easier to read, you can follow the format shown below, replacing your application name where indicated:

http://itunes.com/apps/application_name_here

For example, the equivalent link to the Cartoons To Go app new becomes: http://itunes.com/apps/cartoonstogo

Notice that I removed all the spaces in the application name. Here is the complete list of naming requirements:

- Remove all whitespace
- Remove the following characters and symbols: !¡”#$%’()*+,\-./:;<=>¿?@[\]^_`{|}~©™®
- Replace ampersands with the word “and”
- Accented characters such as ü should be replaced with base character (for example “u”)
- Use only lower-case letters

The above rules apply to both linking to your application as well as the company name. For example to access the company name 3 Sixty Software, LLC in the App Store, the readable link is: http://itunes.com/apps/3sixtysoftwarellc.

I’ve been working with Mill Creek to come up with creative ways to leverage their content in digital formats beyond DVD with the iPhone as the first mobile platform.

Scream Scenes was released in the fall of 2009 and featured audio and video clips from 16 of the most frighteningly fantastic classic horror films which can be found in Mill Creek Entertainment’s Horror Classics 50 Movie MegaPack.

If you tap on the any of the 16 movie icons, a short audio clip of a “classic scream” will play. If you touch and hold one of the icons, the video segment from the movie showing the “classic scream” will play.

Sam Kinison

Our second collaborative project was the Sam Kinison Scream Board, which follows the same idea of Scream Scenes, audio and video content from a collection of Sam Kinison DVDs. If you are not familiar with Sam Kinison, let’s just say his sense of humor can be a little shocking. If you are okay with Sam’s no holds barred approach (the app has a 17+ rating) his standup comedy makes for some great laughs.

The Sam Kinison app is free, if you are up for some outrageous fun, give it a try.

The conditional looks as follow:

condition-test ? first-expression : second-expression

If the condition-test is nonzero, the first-expression is evaluated, otherwise the second-expression is evaluated.

// Traditional approach
if (x > 0)
  str = @"positive";
else
  str = @"negative";
 
// Conditional operator
str = x > 0 ? @"positive" : @"negative";

Nesting Conditional Operators

Extending the example above, we can update the code for the case where x is neither positive or negative (x is zero), using nested conditionals:

// Traditional approach
if (x > 0)
  str = @"positive";
else if (x < 0)
  str = @"negative";
else
  str = @"zero";
 
// Conditional operator
str = x > 0 ? @"positive" : x < 0 ? @"negative" : @"zero";

As shown above, based on the association of parameters, no parenthesis are necessary, however, I find this much easier to read:

str = x > 0 ? @"positive" : (x < 0 ? @"negative" : @"zero");

Good Use Case

I find the conditional operator useful when creating messages in which part of the message may be plural or singular depending on the value of a variable.

It’s not much more work to make messages appear as expected, for example, how often have you seen a message from an application that looks similar to this “1 file(s) downloaded” where ideally the message would read “1 file downloaded” – not a big deal, however, it’s a trivial amount of code to get this right:

int x = 1;
NSString *str = 
  [NSString stringWithFormat:@"%d file%s downloaded", x, (x > 1 ? "s" : "")];

Sometimes it’s the little things that will setup you apart in a crowd of developers.

Other than the built-in movie player, another option is to use a UIWebview, however, there are a few drawbacks including no support for notifications on when a movie has been preloaded, which is handy for displaying a “please wait” loading message.

This post is introduces another approach to playing a movie in portrait mode without delving into private API’s, and I think you’ll agree, it’s quite clever.

Portrait Video Mode on the iPhone

I spend a fair amount of time working with video related applications and content, so when I saw a portrait video playing seamlessly inside Dog Tricks – Best of 101 Dog Tricks I was very interested to figure out how to do the same.

I wrote Michael Schneider of Hive Brain Software, developer of the above app and asked if he would share his secret. Michael was kind enough to pass along some great notes explaining how we got this to work. This post walks through a complete working example I wrote based on the information Michael shared with me.

The End Result

Let’s start by looking at a short video of the application I’ll build in this post running in the simulator:

Notice how the video is shown within the application with the tabbar controls still visible on the screen.

The 30,000 Foot View

The basic idea to make this work is simple, rotate the orientation of the original video, turn off the movie player controls and fire up the movie player as normal.

What you end up with is the movie player running landscape mode with your video content viewable in portrait mode. The reason for hiding the controls is that they would appear sideways. As an example, notice in the screenshot below that the video is viewable in portrait mode, however, the controls are still oriented for a landscape movie player:

Although a simple trick, it’s the little things that will make this approach appear seamless within your application. As an example of a nice effect, I’ll show how to overlay an image on top of the movieplayer so it appears as though the movie is playing directly inside your app.

There are three steps to make this all work:

- Change the orientation of the movie
- Turn off the movie player controls
- Overlay an image of your application UI on top of the movie player

Let’s see how to pull all the pieces together…

Video Orientation

The first step is to use a capable video editing tool to rotate your video to portait mode. I used Quicktime Pro (on Snow Leopard), the steps that I used follow:

- From the Window menu choose Show Movie Properties
- Click on the row for the video track
- Click the Visual Settings tab
- In the Flip/Rotate section, rotate the video counter-clockwise
(or clockwise depending on the orientation you set for your iPhone app).

Code for App Delegate

The app delegate code for this code example is nothing more than a Window object and a Tabbar controller. The interface and implementation files are below:

#import <UIKit/UIKit.h>
 
@class TabbarController;
 
@interface Test_appAppDelegate : NSObject <UIApplicationDelegate>
{
  UIWindow *window;
  TabbarController *tabbar;
}
 
@property (nonatomic, retain) UIWindow *window;
@property (nonatomic, retain) TabbarController *tabbar;
 
@end

The implementation file:

...
- (void)applicationDidFinishLaunching:(UIApplication *)application 
{   
  // Create and initialize the window
  window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
 
  // Create the tabbar
  tabbar = [[TabbarController alloc] init];
  [window addSubview:tabbar.view]; 
 
  [window makeKeyAndVisible];
 
}
...

Code for Tabbar Controller

The tabbar controller is code is nothing out of the ordinary, the interface file is shown below:

#import <UIKit/UIKit.h>
 
@interface TabbarController : UITabBarController  <UITabBarControllerDelegate>
{
}
 
@end

As you can see in the code below I’ve defined three tabs, each with a unique title:

@implementation TabbarController
 
- (id) init
{
  self = [super init];
  if (self) 
  {
    self.delegate = self;
 
    UIViewController *localViewController;   
 
    // New tabbar controller and array to contain the view controllers
    NSMutableArray *localViewControllersArray = [[NSMutableArray alloc] initWithCapacity:3];
 
    // Tab 1
    localViewController = [[Tabbar1ViewController alloc] initWithTitle:@"Tab 1"];    
    [localViewControllersArray addObject:localViewController];
    [localViewController release];
 
    // Tab 2
    localViewController = [[Tabbar2ViewController alloc] initWithTitle:@"Tab 2"];    
    [localViewControllersArray addObject:localViewController];
    [localViewController release];
 
    // Tab 3
    localViewController = [[Tabbar3ViewController alloc] initWithTitle:@"Tab 3"];    
    [localViewControllersArray addObject:localViewController];
    [localViewController release]; // Retained by above array
 
    self.viewControllers = localViewControllersArray;
    [localViewControllersArray release];
  }
 
  return self;
}
 
@end

Code for Tab 1

The only tabbar that has any working code for this example is the left-most tab, which plays the movie in portrait mode. The interface definition for this tab is shown below:

#import <UIKit/UIKit.h>
#import <MediaPlayer/MediaPlayer.h>
 
@interface Tabbar1ViewController : UIViewController
{
  MPMoviePlayerController  *moviePlayer;
  NSURL  *movieURL;
}
 
@end

Inside the implementation file, the first block of relevant code is the initialization, which sets up the view, the background color and the title for the tab:

- (id)initWithTitle:(NSString *)theTitle 
{
  if (self = [super init])
  {
    self.view = [[[UIView alloc] initWithFrame:[[UIScreen mainScreen] applicationFrame]] autorelease];    
    self.view.backgroundColor = [UIColor blackColor];
    self.title = theTitle;
  }  
  return self;  
}

The next section of code to write is when the tab is about to appear, here we create the path to the movie, setup the movie player, register to receive a notification when the movie has finished playing, start the movie, and finally, overlay an image on top of the player (more on that below):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

-(void)viewWillAppear:(BOOL)animated
{
  // Path to the movie
  NSString *path = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mov"];      
  movieURL = [NSURL fileURLWithPath:path];
 
  // Setup the player
  moviePlayer = [[MPMoviePlayerController alloc] initWithContentURL:movieURL];
 
  // Hide the controls
  [moviePlayer setMovieControlMode:MPMovieControlModeHidden];  
 
  // Register to receive a notification when the movie has finished playing
  [[NSNotificationCenter defaultCenter] addObserver:self 
                      selector:@selector(moviePlayBackDidFinish:) 
                      name:MPMoviePlayerPlaybackDidFinishNotification 
                      object:nil];
 
  // Start the movie  
  [moviePlayer play];
 
  // Overlay an image with center that is transparent for movie to show through  
  MovieOverlayViewController *overlay = [[[MovieOverlayViewController alloc] init] autorelease];
  NSArray *windows = [[UIApplication sharedApplication] windows];
  UIWindow *moviePlayerWindow = [windows objectAtIndex:1];
  [moviePlayerWindow addSubview:overlay.view];  
}

The interesting code starts on line 21, this is where I define a new view controller, MovieOverlayViewController, which will overlay an image on top of the running movie player. This overlay will present the illusion that the movie is running directly inside the app.

Movie Image Overlay

To give the app the appearance of running natively in portrait mode, we’ll overlay an image that shows the tabbars along the bottom and a text banner across the top. I’ll also write code to detect when the user taps on the image and do the necessary checks to see if the user tapped in an area that would translate to one of the tabs, more on that momentarily.

The finished look on the device is below:

Notice in the figure below that actual image we will overlay is nothing more than a transparent image with some text across the top and a series of tabbar images across the bottom.

The movie overlay view controller for this app is quite trivial, it contains nothing more than a UIImageView:

@interface MovieOverlayViewController : UIViewController 
{
  UIImageView *overlay;
}

Inside the implementation file, we begin with the initialization and code for creating the UIImageView that will be overlayed on the movie player:

- (id)init
{
  if (self = [super init])
    self.view = [[[UIView alloc] initWithFrame:[[UIScreen mainScreen] applicationFrame]] autorelease];    
  return self;  
}
 
-(void) viewWillAppear:(BOOL)animated
{
  overlay = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"overlay.png"]] autorelease];
  [self.view addSubview:overlay]; 
}

The other relevant code for this view controller is managing touches on the image. To provide the most realistic user experience, once the image is overlayed and the movie is playing, you will need to detect touches on the image where the tabs live. The code below will determine if a touched point is within the rectangle of each of the tabs, printing a message to the console on which tab was touched.

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event 
{	  
  // Detect touch anywhere
  UITouch *touch = [touches anyObject];
 
  // Where is the point touched
  CGPoint point = [touch locationInView:self.view]; 
  NSLog(@"pointx: %f pointy:%f", point.x, point.y);
 
  // Was a tab touched, if so, which one...
  if (CGRectContainsPoint(CGRectMake(1, 440, 106, 40), point))
    NSLog(@"tab 1 touched");
  else if (CGRectContainsPoint(CGRectMake(107, 440, 106, 40), point))
    NSLog(@"tab 2 touched");
  else if (CGRectContainsPoint(CGRectMake(214, 440, 106, 40), point))
    NSLog(@"tab 3 touched");
}

You could add code to the above example and when tab 2 or 3 is tapped, stop the movie, remove the overlay and switch to the view controller associated with the appropriate tab.

Xcode Portrait Mode Video Source Code

You can download the entire Xcode project here: Xcode Portrait Video.

Credits

Thanks again to Michael Schneider of Hive Brain Software for sharing his insight on this trick. You can check out more of Michael’s work on a series of self improvement applications at Relaxing Apps.

And Michael would like to pass on many thanks Scott Michaels at Atimi in Vancouver BC for sharing information on this approach at the 360iDev conference in San Jose.

I am looking for 10-15 people who own an iPhone or iPod touch to give the application a try. I’ll create a build specifically for your device or provide a promo code to download the latest version.

What I ask for in return is a thorough run through of the app, testing the streaming speed and performance, as well as exercising the overall UI.

Please send me an email if you are interested to help out jwmuchow at gmail dot com

Even though you can’t use iTunes to upload new apps, change current app descriptions, prices, etc, you can access your reports with the following link: https://itts.apple.com

NSRange Definition

NSRange is a structure defined as follows:

typedef struct _NSRange 
{
  NSUInteger location;
  NSUInteger length;
} NSRange;

location is the starting index in the range (zero based) and length is the number of entries in the range. NSUInteger is simply an unsigned value that supports both 32 and 64 bit systems. Here is how NSUInteger is defined:

#if __LP64__ || TARGET_OS_EMBEDDED || TARGET_OS_IPHONE || TARGET_OS_WIN32 || NS_BUILD_32_LIKE_64
typedef unsigned long NSUInteger;
#else
typedef unsigned int NSUInteger;
#endif

NSRange and Strings

The example below shows one approach for creating a range and using the same to extract a substring – the output from below is IPA

NSString *homebrew = @"Imperial India Pale Ale (IPA)";
 
// Starting at position 25, get 3 characters
NSRange range = NSMakeRange (25, 3);
 
// This would also work:
// NSRange range = {25, 3};
 
NSLog (@"Beer shortname: %@", [homebrew substringWithRange:range]);

If you want to search for a substring, you could write something like the following:

NSString *homebrew = @"Imperial India Pale Ale (IPA)";
NSRange range = [homebrew rangeOfString:@"IPA"];
 
// Did we find the string "IPA" ?
if (range.length > 0)
  NSLog(@"Range is: %@", NSStringFromRange(range));

The output from above will display: Range is: {25, 3}. Notice the call to NSStringFromRange() which will display the return value (a range) as an NSString. There is also a function to create a range from a string: NSRangeFromString().

Let’s look at one more example, the code below will search for the string “ia” starting at the end of the string moving towards the beginning:

NSString *homebrew = @"Imperial India Pale Ale (IPA)";
 
// Search for the "ia" starting at the end of string
NSRange range = [homebrew rangeOfString:@"ia" options:NSBackwardsSearch];
 
// What did we find
if (range.length > 0)
  NSLog(@"Range is: %@", NSStringFromRange(range));

The result from above is: Range is: {12, 2} (the “ia” inside the word “India”).

NSRange Functions

Here is a list of functions that work with ranges:

NSEqualRanges()
NSIntersectionRange()
NSLocationInRange()
NSMakeRange()
NSMaxRange()
NSRangeFromString()
NSStringFromRange()
NSUnionRange()