Luckily, the iPhone OS 3.0 added this functionality. Quite excitingly, similar functionality for in-app SMS messages is coming soon (in iPhone OS 4.0), but we won’t talk about that here.

1. Referencing the MessageUI Framework

First up, we have to ensure that we are linking with the MessageUI Framework, which is the library that will provide the functionality we’re after. If you’ve not already got the MessageUI Framework referenced in your project, you’ll want to right click on ‘Frameworks‘ in your projects ‘Groups & Files’ and select Add -> Existing Frameworks. Select MessageUI.framework and insert it into your project.

2. Call up the MFMailComposeViewController view like any other UIView

Next up you need to create and push to the main navigation controller a fresh MFMailComposeViewController. This will control the in-app email view that will allow the user to complete the remaining details for the email they wish to send and then either beam that email off to the lucky recipients across the internet, or to cancel the operation.

The example below shows how set a whole host of options on the mail compose view. You don’t have to set all of these – things like the Subject and the Recipients are optional, but you will more than likely want to set one or two of these depending on the view that is enabling the user to start a new email.

The code for this will often go in an IBAction method and is as follows

-(IBAction)sendEmail:(id)sender {
  // Create a new Mail Composer View Controller
  MFMailComposeViewController *mailViewController = [[MFMailComposeViewController alloc] init];
  mailViewController.mailComposeDelegate = self;

  // Optional Configuration Parameters to make life easier for the user
  [mailViewController setSubject:@"Subject"];
  [mailViewController setMessageBody:@"Message Body" isHTML:NO];
  [mailViewController setToRecipients:[NSArray arrayWithObject:@"a@b.com"]];
  [mailViewController setCcRecipients:[NSArray arrayWithObject:@"a@b.com"]];
  [mailViewController setBccRecipients:[NSArray arrayWithObject:@"a@b.com"]];

  // Present the VIew Controller and clean up after ourselves
  [self presentModalViewController:mailViewController animated:YES];
  [mailViewController release];
}

Now, we’ve got an application that shows a compose email view ready for the user to send an email direct from your app. However, there’s one main problem with the app as it stands – once you’ve launched the mail compose view, it’ll never go away! In order for you to respond when the user has (or hasn’t) sent an email, and to optionally respond with your own messages depending on whether it worked or not, you’ll have to implement the MFMailComposeViewControllerDelegate protocol.

3. Implementing the MFMailComposeViewControllerDelegate Protocol

The third and final step in getting your in app Mail Composer working correctly is to respond to the appropriate delegate protocol. I often find that implementing delegate protocol methods can sometimes be a laborious task – but you’re in luck this time, as there is only one method that you have to worry about;

-(void)mailComposeController:(MFMailComposeViewController*)controller didFinishWithResult:(MFMailComposeResult)result error:(NSError*)error
{
  if ( result == MFMailComposeResultFailed )
  {
    // Sending failed - display an error message to the user.
    NSString* message = [NSString stringWithFormat:@"Error sending email '%@'. Please try again, or cancel the operation.", [error localizedDescription]];
    UIAlertView* alertView = [[UIAlertView alloc] initWithTitle:@"Error Sending Email" message:message delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
    [alertView show];
  }
  else
  {
    // If we got here - everything should have gone as the user wanted - dismiss the modal view.
    [self dismissModalViewControllerAnimated:YES];
  }
}

There you have it – 3 easy steps to implementing the MFMailComposeViewController in your iPhone application.

Use them sparingly; Having too many global variables floating around makes it very hard to keep track of what’s going on. I never use more than one global object for each logical section of my code – even if that object contains a handful of other objects from that section.

But you do sometimes need them; I once wrote a small game where I decided not to use my own globals at all. Truth be told, I ended up with a bit of a mess – a large number of similar constructors with a numbers of parameters to link my objects together. Sure, the units were technically separate and didn’t rely on each other – but the reality was, that when you get deep enough into your code – some classes are only ever going to be used in this project (view controllers etc).

Use them when it’s applicable; Generally, global variables are applicable in situations when you’ve got an object / class of which you are only ever going to need one of them and they don’t logically sit as a child of one single part of the application. For instance, the ‘application’ object in some languages – where the object represents the running application.

So, Singleton Eh?

The Singleton model is often used to instantiate just one instance of a class which doesn’t allow a second instance of that same class to be loaded anywhere in the application. Some implementations will throw an exception if you try to create a second instance of the class, some will create the singleton for you when you first try to access it, and some will even let you create other instances if you want, but will always manage a ’single shared instance’ for you. Many of the core Apple classes follow this pattern, such as [UIApplication sharedApplication].

Anyway, Apple do a very good job (naturally) of providing a good example of the Singleton model. The following code is rather similar to the Apple example, but it also includes what you should have in the header file. It is also a stable part of any library of code snippets, so it has to be here really!

SingletonClass.h

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

@interface SingletonClass : NSObject {

}

+ (id)sharedInstance;
@end

SingletonClass.m

#import "SingletonClass.h"

@implementation SingletonClass

static SingletonClass *sharedInstance = nil;

// Get the shared instance and create it if necessary.
+ (SingletonClass*)sharedInstance {
    if (sharedInstance == nil) {
        sharedInstance = [[super allocWithZone:NULL] init];
    }

    return sharedInstance;
}

// We don't want to allocate a new instance, so return the current one.
+ (id)allocWithZone:(NSZone*)zone {
    return [[self sharedInstance] retain];
}

// Equally, we don't want to generate multiple copies of the singleton.
- (id)copyWithZone:(NSZone *)zone {
    return self;
}

// Once again - do nothing, as we don't have a retain counter for this object.
- (id)retain {
    return self;
}

// Replace the retain counter so we can never release this object.
- (NSUInteger)retainCount {
    return NSUIntegerMax;
}

// This function is empty, as we don't want to let the user release this object.
- (void)release {

}

//Do nothing, other than return the shared instance - as this is expected from autorelease.
- (id)autorelease {
    return self;
}

@end

There you go – copy and paste this into your new project, rename the interface and implementations and you’re done – a ready to use Singleton in your project.

Launching Safari from within an iPhone App

The openURL method of UIApplication is a very useful and valuable method. It provides a quick and simple way to leave the current application and load up the web browser, the email application or even the phone application. It also provides a way for you to set the ‘default’ data, such as the start page in safari, or the email recipient for mail.

Using the function to launch Safari with a specific URL is simple, it requires barely any code. The following example shows how one would use openUrl to launch Safari having clicked a button.

-(IBAction)linkButtonClick:(id)sender {
NSString* launchUrl = @"http://www.johnwordsworth.com/";
[[UIApplication sharedApplication] openURL:[NSURL URLWithString: launchUrl]];
}

Launching Mail, the Phone or SMS

Launching the mail client, phone or the SMS client is equally as simple. The openURL method examines the first few characters of your URL and then uses this information to determine what information you have provided. It then does it’s best to enact what you have requested.

The following functions give you a quick and easy way to launch the relevant apps quickly and easily.

// Launch the email client with mailto://[recipient]
-(BOOL)launchMailWithRecipient:(NSString *)recipient {
NSString* launchUrl = [NSString stringWithFormat:@"mailto://%@", recipient];
return [[UIApplication sharedApplication] openURL:[NSURL URLWithString: launchUrl]];
}

// Launch the phone with tel://[number]
-(BOOL)launchPhoneWithNumber:(NSString *)number {
NSString* launchUrl = [NSString stringWithFormat:@"tel://%@", number];
return [[UIApplication sharedApplication] openURL:[NSURL URLWithString: launchUrl]];
}

// Launch the SMS client with sms:[number]
-(BOOL)launchSMSWithNumber:(NSString *)number {
NSString* launchUrl = [NSString stringWithFormat:@"sms:%@", number];
return [[UIApplication sharedApplication] openURL:[NSURL URLWithString: launchUrl]];
}

But the iPod doesn’t have a phone!?

That’s right – there’s something we’ve not yet touched upon, and that’s the fact that openURL returns a boolean value. This value lets you know whether or not the operation completed successfully. Obviously, if it did – then you’d better clean up your App pretty quick as it’s not going to be in the foreground for much longer! However, more usefully, it allows you to handle the case when the supported operation is not permitted.

For instance, if you’re hoping to loading up the phone app on an iPod Touch, then it’s not going to work. In this case, you might want to popup a UIAlertView to let the user know that it’s not going to work. If you’re really working hard towards a friendly user interface, then you can use the canOpenUrl method to check this out without actually leaving the application. For instance, if canOpenUrl returns false, then you could disable the links or buttons that would otherwise launch the phone or SMS application.

How would you do that?

-(BOOL)doesDeviceHaveAPhone {
NSString* launchUrl = @"tel://0";
return [[UIApplication sharedApplication] canOpenUrl:[NSURL URLWithString: launchUrl]];
}

I’ll leave you to think about the other cunning things that you can do, such as launching with an http url that links directly to a google map / youtube video or custom Google search string. Anyhow, when combined with other elements of a productivity app, this can be quite useful! Enjoy.

So, instead of bitching about it, I thought I would ’simply’ fix it. Now, I leafed through a couple of other people’s skins, browed through the empty ‘how to make a skin’ wiki page and thought; “It’s not going to be easy, but I’ll give it a try.”. Now, if you’ve ever had any experience re-skinning an application before, you’ll know that it’s never as easy as you think it should be. Vendetta Online is, unfortunately, no exception.

I thought it would have been nice if the skins consisted of an XML file that would allow you to set the text colors and provide solid borders without the need for producing graphics, but I can also see how this is low on the priority scales for the developers. Anyway, with over 100 files to produce my head is already turning around ideas of how to produce a piece of software to make the whole process easier, but for now, here are some screenshots of the skin that I have been working on.

(Click images to enlarge)

As you can see, there are a few bits that need some extra work. Most importantly, the HUD elements are still plagued by an aliasing problem that was the main reason that I wanted to write this skin. However, this time, it’s not the radar, but the central HUD elements. Anyway – I’ll find a good compromise, get it all packaged up, and hopefully release it out to the community at some point soon.

Another important difference, is that Vendetta Online is produced by only 4 people. In my opinion, this has had 2 massive effects on the game. First of all, unfortunately, it means that the game is lacking a little in scope. It’s not easy to find truly unique missions as the focus seems to have been on the core ‘learning the game’ and ‘generic always there missions’ to date. This means that the awesome history and thought that’s gone into the world doesn’t get to shine through. Also, the graphics aren’t quite up to EVE’s standards. Don’t get me wrong, they’re great for a team of 4, and produce a wonderful experience, but it’s unfortunate that they have to sit next to EVE in a comparison.

The second effect on the otherhand, is absolutely amazing. Being led by only a team of 4, and having a tight-nit community has led to some innovation in the MMORPG genre. The game has a Player Contribution Corp; a group of players who have access to a set of tools and guides for contributing missions, plugins and skins to the game. Some of the community made plug-ins really fill those gaps that the development team simply haven’t had time to plug yet.

Being able to contribute to a live MMORPG is really appealing to me. As someone who is just starting his career in the gaming industry, I love the idea of being able to join a friendly and ambitious community, put a handful of hours into a mission, skin or plug-in and see it in action in a real live game. It was this that spurned me on to write this post. I’ve started work on a new skin for the engine that I hope will help the engine shine a little more on my monitor, and wanted to share some thoughts about my experience.

The bottom line is this; If you’re looking for an MMORPG with a small yet friendly player-base that will allow you to contribute ideas and suggestions to the development of the game, then Vendetta Online is definitely something you should try out. I’m not going to lie – the first 30-60 minutes might be a little different to your regular MMORPG experience – it won’t be quite as shiny, but you will pretty quickly get to witness the community first hand. Hell, they’ve got an 8 hour trial (that’s 8 hours in game, you can spread it over a few weeks if you wish) – so why not give it a shot?

Download the Vendetta Online Client Here

This fantastic evening marks the begining of my revisited blog. There is still much for me to do on the blog design before I could consider it done (adding dates into the template in a friendly fashion to start with). Anyhow, this is all leading up to some posts about XNA programming from dicussions that I had a while ago over at xnachat.com. Anyhow, it’s late here and there’s much sleep to be had.

The Problem

Our game is relatively simple and we would like to define the stages that the player progresses through in a plain text file. While it’s a very simple task to read a text file in C#, I initially had problems assuming that loading a new StreamReader on the the Xbox like so StreamReader(“LevelIndex.txt”); would load up a text file in the same directory as my executable. Not the case – it turns out that, as the Xbox doesn’t really follow a directory structure like a PC, this doesn’t work.

The Solution

The solution is also relatively simple, but not east to find – as it’s one of those things that you either know how to do or not. There are 2 important things to note before jumping directly into a code listing.

1. StorageContainer.TitleLocation: In order to construct the file path that you will be feeding into a StreamReader, you must prefix your path with this property. To load up the file ‘LevelIndex.txt’, which resides in the root directory of your solution, you must construct the path as follows; String fullPath = StorageContainer.TitleLocation + “LevelIndex.txt”;

2. Build Action (None), Copy to Output Directory (Copy if Newer): As your text file is not going to be processed by the Content Processor, you need to tell Visual Studio what should be done with your text file. For my project, I dragged and dropped the text file into my Solution (but NOT in the Content directory). The text file sits alongside your .cs files (although, could reside in a folder). Then, you must change the properties of the text so that Build Action is set to ‘None’ and Copy to Output Directory is set to ‘Copy if Newer’. This ensures that Visual Studio doesn’t try to compile the file as code or include it in your Content repository. It will simply copy the text file to the TitleLocation of your game – just what you want so that you can read it from within your title.

Code Listing

The following code listing shows how we have implemented a simple text file reader for an Xbox XNA Project;

function String[] readStageTitles( String filePath ) {
  ArrayList stageTitles = new ArrayList();
  String[] returnData = null;

  // Both Windows and Xbox - Ensures we are looking in the game's folder.
  String StageIndexPath = StorageContainer.TitleLocation + "\\" + file;

  try
  {
    StreamReader streamReader = new StreamReader(StageIndexPath);
    String line;

    while ((line = streamReader.ReadLine()) != null)
    {
      String[] data = line.Split(';');

      if ( data.Length == 2 ) {
        stageTitles.Add(data[1]);
      }
    }

    streamReader.Close();
  }
  catch( Exception ex )
  {
    // Do things here incase it can't read the file
  }

  returnData = (String[])stageTitles.ToArray( typeof(String) );
  return returnData;
}

Hope this helps someone out there.

After a few searches on Google and many failed attempts, I found that the following command instantly fixed my problem;

netsh interface tcp set global autotuninglevel=disabled

I’m afraid I have no real idea what other impact this might have on your machine / server. I understand that this disables the built in network ‘tuning’ that Vista uses to try to improve your bandwidth usage so that all software on your machine is guaranteed a solid minimum Quality of Service (QoS). I suspect that it’ll have no noticable impact at all, it’ll just perform more like XP than Vista (which was fine).

If it does screw things up, you can reverse this action by;

netsh interface tcp set global autotuninglevel=normal

You’ll have to run this from a cmd.exe shell and will probably need to run cmd.exe with the ‘Run as Administrator…’ command. I have UAC disabled, so it runs fine anyway. You should just get a simple ‘Ok’ response from the software if it’s run ok.

I hope that this helps some people. It’s been running perfectly fine ever since.

This week, I’ve mostly been playing with the Print Screen options / Screen Capture options. Previously, I’ve only used a couple of the plethora of screen capture options that OSX offers, but I thought it time to get a definitive list of the (hard to remember) key combinations available, mostly for my own reference.

So, putting Windows to shame, you can actually save a screen capture as a JPEG file with a mouse click. This would be a great addition to windows and would definitely stop me from receiving emails that are 5Mb with 2 BMP screen caps in that I’ve been receiving a lot of recently. An overview of the commands are;

Saving a Screen Capture Direct to a JPEG File

⌘ ⇧ 3: Capture the entire screen to a jpeg file on the desktop.

⌘ ⇧ 4 (Followed by Drag): Capture the selected area of the screen to a jpeg file on the desktop.

⌘ ⇧ 4 (Then Spacebar, Then click on a window): Capture selected window (and sometimes a border) to a jpeg file on the desktop.

Saving a Screen Capture to the Clipboard

⌘ ⇧ 3 + Ctrl: Capture the entire screen to the clipboard.

⌘ ⇧ 4 + Ctrl (Followed by Drag): Capture the selected area of the screen to the clipboard.

⌘ ⇧ 4 + Ctrl (Then Spacebar, Then click on a window): Capture selected window (and sometimes a border) to the clipboard.

While it’s fantastic having this much freedom over the print screen process, the last one especially reminds me of trying to learn a 10-hit combo in Soul Calibur. It even feels that way when you’re trying to press all of the buttons on the keyboard/mouse during the process!

I’m not sure how many of you are aware, but Microsoft’s .NET languages such as Visual Basic and C# don’t actually compile into windows specific executable code but they instead get compiled into an ‘intermediate’ code similar to Java. This is why you are required to download 80Mb of .NET Framework files to run them on XP.

So, what the clever guys on the Mono Project have done is rewrite the .NET Framework so that it runs on other operating systems. That means that you are able to run software that was compiled for Windows as .NET Managed Code in other operating systems as if it were a native application. Now the system is far from perfect, so you’re not able to just pick any application and guarantee it will work – but the project is improving all the time and making more and more programs compatible.

Again, something which is not stated, is how easy this is. Download the Mono application for your machine. And then type: ‘mono MyApplication.exe’ and wait for the application to run. Hassle free (when it works).

While this may not seem significant to many people, I found it amazing that I could run a bunch of .exe files on my mac directly from my Windows Partition with no problems what-so-ever. My only issue with this technology at the moment, is the inability to have ‘browser windows’ in the application run on OSX. They run on Linux apparently, but not on a Mac.

I really hope that .NET developers start making their applications Mono compatible, and I look forward to the browser window component being accessible on a Mac. I’ll definitely be trying my C# programs on Mono and I may even release some of them soon!