




















































(For more resources on this topic, see here.)
Mobile devices offer a handful of features to the user. Creating an application that interacts with those features to provide a complete experience to users can surely be considered as an advantage.
In this article, we will discuss some of the most common features of iOS and how to integrate some or all of their functionality to our applications. We will see how to offer the user the ability to make telephone calls and send SMS and e-mails, either by using the native platform applications, or by integrating the native user interface in our projects. Also, we will discuss the following components:
Furthermore, we will learn how to read and save contact information, how to display contact details, and interact with the device calendar.
Note that some of the examples in this article will require a device. For example, the simulator does not contain the messaging application. To deploy to a device, you will need to enroll as an iOS Developer through Apple's Developer Portal and obtain a commercial license of MonoTouch.
In this recipe, we will learn how to invoke the native phone application to allow the user to place a call.
Create a new project in MonoDevelop, and name it PhoneCallApp.
The native phone application is not available on the simulator. It is only available on an iPhone device.
this.buttonCall.TouchUpInside += delegate {
NSUrl url = new NSUrl("tel:+123456789012");
if (UIApplication.SharedApplication.CanOpenUrl(url)){
UIApplication.SharedApplication.OpenUrl(url);
} else{
Console.WriteLine("Cannot open url: {0}", url.AbsoluteString);
}
} ;
Through the UIApplication.SharedApplication static property, we have access to the application's UIApplication object. We can use its OpenUrl method, which accepts an NSUrl variable to initiate a call:
UIApplication.SharedApplication.OpenUrl(url);
Since not all iOS devices support the native phone application, it would be useful to check for availability frst:
if (UIApplication.SharedApplication.CanOpenUrl(url))
When the OpenUrl method is called, the native phone application will be executed, and it will start calling the number immediately. Note that the tel: prefx is needed to initiate the call.
MonoTouch also supports the CoreTelephony framework, through the MonoTouch. CoreTelephony namespace. This is a simple framework that provides information on call state, connection, carrier info, and so on. Note that when a call starts, the native phone application enters into the foreground, causing the application to be suspended. The following is a simple usage of the CoreTelephony framework:
CTCallCenter callCenter = new CTCallCenter();
callCenter.CallEventHandler = delegate(CTCall call) {
Console.WriteLine(call.CallState);
} ;
Note that the handler is assigned with an equals sign (=) instead of the common plus-equals (+=) combination. This is because CallEventHandler is a property and not an event. When the application enters into the background, events are not distributed to it. Only the last occured event will be distributed when the application returns to the foreground.
The OpenUrl method can be used to open various native and non-native applications. For example, to open a web page in Safari, just create an NSUrl object with the following link:
NSUrl url = new NSUrl("http://www.packtpub.com");
In this article:
In this recipe, we will learn how to invoke the native mail and messaging applications within our own application.
Create a new project in MonoDevelop, and name it SendTextApp.
this.buttonSendText.TouchUpInside += delegate {
NSUrl textUrl = new NSUrl("sms:");
if (UIApplication.SharedApplication.CanOpenUrl(textUrl)){
UIApplication.SharedApplication.OpenUrl(textUrl);
} else{
Console.WriteLine("Cannot send text message!");
}
} ;
this.buttonSendEmail.TouchUpInside += delegate {
NSUrl emailUrl = new NSUrl("mailto:");
if (UIApplication.SharedApplication.CanOpenUrl(emailUrl)){
UIApplication.SharedApplication.OpenUrl(emailUrl);
} else{
Console.WriteLine("Cannot send e-mail message!");
}
} ;
Once again, using the OpenUrl method, we can send text or e-mail messages. In this example code, just using the sms: prefx will open the native text messaging application. Adding a cell phone number after the sms: prefx will open the native messaging application:
UIApplication.SharedApplication.OpenUrl(new
NSUrl("sms:+123456789012"));
Apart from the recipient number, there is no other data that can be set before the native text message application is displayed.
For opening the native e-mail application, the process is similar. Passing the mailto: prefx opens the edit mail controller.
UIApplication.SharedApplication.OpenUrl(new NSUrl("mailto:"));
The mailto: url
scheme supports various parameters for customizing an e-mail message. These parameters allows us to enter sender address, subject, and message:
UIApplication.SharedApplication.OpenUrl("mailto:recipient@example.
com?subject=Email%20with%20MonoTouch!&body=This%20is%20the%20
message%20body!");
Although iOS provides access to opening the native messaging applications, pre-defning message content in the case of e-mails, this is where the control from inside the application stops. There is no way of actually sending the message through code. It is the user that will decide whether to send the message or not.
The OpenUrl method provides an interface for opening the native messaging applications. Opening external applications has one drawback: the application that calls the OpenUrl method transitions to the background. Up to iOS version 3.*, this was the only way of providing messaging through an application. Since iOS version 4.0, Apple has provided the messaging controllers to the SDK. The following recipes discuss their usage.
In this article:
In this recipe, we will learn how to provide text messaging functionality within our application using the native messaging user interface.
Create a new project in MonoDevelop, and name it TextMessageApp.
using MonoTouch.MessageUI;
private MFMessageComposeViewController messageController;
public override void ViewDidLoad (){
base.ViewDidLoad ();
this.buttonSendMessage.TouchUpInside += delegate {
if (MFMessageComposeViewController.CanSendText){
this.messageController = new
MFMessageComposeViewController();
this.messageController.Recipients = new
string[] { "+123456789012" };
this.messageController.Body = "Text from MonoTouch";
this.messageController.MessageComposeDelegate =
new MessageComposerDelegate();
this.PresentModalViewController(
this.messageController, true);
} else{
Console.WriteLine("Cannot send text message!");
}
} ;
}
private class MessageComposerDelegate :
MFMessageComposeViewControllerDelegate{
public override void Finished (MFMessageComposeViewController
controller, MessageComposeResult result){
switch (result){
case MessageComposeResult.Sent:
Console.WriteLine("Message sent!");
break;
case MessageComposeResult.Cancelled:
Console.WriteLine("Message cancelled!");
break;
default:
Console.WriteLine("Message sending failed!");
break;
}
controller.DismissModalViewControllerAnimated(true);
}
}
The MonoTouch.MessageUI namespace contains the necessary UI elements that allow us to implement messaging in an iOS application. For text messaging (SMS), we need the MFMessageComposeViewController class.
Only the iPhone is capable of sending text messages out of the box. With iOS 5, both the iPod and the iPad can send text messages, but the user might not have enabled this feature on the device. For this reason, checking for availability is the best practice. The MFMessageComposeViewController class contains a static method, named CanSendText, which returns a boolean value indicating whether we can use this functionality. The important thing in this case is that we should check if sending text messages is available prior to initializing the controller. This is because when you try to initialize the controller on a device that does not support text messaging, or the simulator, you will get the following message on the screen:
To determine when the user has taken action in the message UI, we implement a Delegate object and override the Finished method:
private class MessageComposerDelegate :
MFMessageComposeViewControllerDelegate
Another option, provided by MonoTouch, is to subscribe to the Finished event of the MFMessageComposeViewController class.
Inside the Finished method, we can provide functionality according to the MessageComposeResult parameter. Its value can be one of the following three:
The last thing to do is to dismiss the message controller, which is done as follows:
controller.DismissModalViewControllerAnimated(true);
After initializing the controller, we can set the recipients and body message to the appropriate properties:
this.messageController.Recipients = new string[] { "+123456789012" };
this.messageController.Body = "Text from MonoTouch";
The Recipients property accepts a string array that allows for multiple recipient numbers. You may have noticed that the Delegate object for the message controller is set to its MessageComposeDelegate property, instead of the common Delegate. This is because the MFMessageComposeViewController class directly inherits from the UINavigationController class, so the Delegate property accepts values of the type UINavigationControllerDelegate.
The fact that the SDK provides the user interface to send text messages does not mean that it is customizable. Just like invoking the native messaging application, it is the user who will decide whether to send the message or discard it. In fact, after the controller is presented on the screen, any attempts to change the actual object or any of its properties will simply fail. Furthermore, the user can change or delete both the recipient and the message body. The real beneft though is that the messaging user interface is displayed within our application, instead of running separately.
The MFMessageComposeViewController can only be used for sending Short Message Service (SMS) messages and not Multimedia Messaging Service (MMS).