In case you hadn’t heard, you no longer require a developer account to build and test apps on your iOS devices. This is great for beginning developers. It means there is no cost to build and test an app on real hardware. You will still need a developer account to publish apps to the store or do larger scale beta testing with Test Flight.
Category: IOS
Swift – Open an Alert box
Opening an alert in iOS is very easy. Use the UIAlertController. This creates a special ViewController that can be displayed in one of two styles Alert, or ActionSheet.
let alert = UIAlertController(title: "Send Cypher", message: nil, preferredStyle: UIAlertControllerStyle.ActionSheet)
let message = UIAlertAction(title: "Message", style: UIAlertActionStyle.Default) { (action: UIAlertAction) -> Void in
// Do something when message is tapped
}
let email = UIAlertAction(title: "Email", style: UIAlertActionStyle.Default) { (action: UIAlertAction) -> Void in
// Do something when email is tapped
}
let cancel = UIAlertAction(title: "Cancel", style: UIAlertActionStyle.Cancel, handler: nil)
alert.addAction(message)
alert.addAction(email)
alert.addAction(cancel)
presentViewController(alert, animated: true, completion: nil)
Swift – Send Email
Sending email with Swift is easy with MFMailComposeViewController. Follow these steps:
Step 1: Import the MessageUI framework
import MessageUIStep 2: Add the Protocol to your ViewController
MFMailComposeViewControllerDelegateStep 3: Add the delegate method
func mailComposeController(controller: MFMailComposeViewController, didFinishWithResult result: MFMailComposeResult, error: NSError?) {
controller.dismissViewControllerAnimated(true, completion: nil)
}
Step 4: Make an instance of the MailComposeViewController, and present it.
func sendEmail() {
let mailVC = MFMailComposeViewController()
mailVC.mailComposeDelegate = self
mailVC.setToRecipients([])
mailVC.setSubject("Message Subject")
mailVC.setMessageBody("Message text...", isHTML: true)
presentViewController(mailVC, animated: true, completion: nil)
}
https://gist.github.com/ed9b0ad90ca0937aac62.git
Swift – Send SMS Messages
Sending SMS messages in Swift is very easy. You can add the capability to any app with a few lines of code.
Note: This will not work in the simulator, as the simulator doesn’t support SMS messages!
Step 1: Import MessageIU
Add the following to the top of your ViewController.
import MessageUI
Step 2: Add the Protocol
Add the MFMessageComposeViewControllerDelegate your ViewController definition.
Step 3: Conform to the protocol
Conform to the MFMessageComposeControllerDelegate by adding defining the:
messageComposeViewController:didFinishWithResult method. It might look something like:
func messageComposeViewController(controller: MFMessageComposeViewController, didFinishWithResult result: MessageComposeResult) {
switch result.rawValue {
case MessageComposeResultCancelled.rawValue :
print("message canceled")
case MessageComposeResultFailed.rawValue :
print("message failed")
case MessageComposeResultSent.rawValue :
print("message sent")
default:
break
}
controller.dismissViewControllerAnimated(true, completion: nil)
}
}You can omit the switch statement. The switch statement provides some feedback to you on the status of the message. Use this to notify your user when a message fails, or is canceled. Or omit if this is unimportant.
Step 3: Open the Message View controller
func sendMessage() {
let messageVC = MFMessageComposeViewController()
messageVC.body = "Message string"
messageVC.recipients = [] // Optionally add some tel numbers
messageVC.messageComposeDelegate = self
// Open the SMS View controller
presentViewController(messageVC, animated: true, completion: nil)
}
https://gist.github.com/1c863ab275e1c0e09936.git
Native vs HTML5 and Phonegap
This a question that comes up a lot for me. I think about it everyday. I’ve written about it here in the past. The question came up in class yesterday.
Here is a good discussion of the subject:
http://roadfiresoftware.com/2014/04/when-to-use-phonegap-versus-developing-a-native-ios-app/
Some quotes from this article:
Honestly, one big reason developers want to build an app with PhoneGap is so they don’t have to learn Swift or Objective-C. A lot of times, they’re afraid of learning a new language.
Here’s another
great for getting an app out the door quickly…but definitely lacking compared to native.”
(We’ll look at what it’s lacking in a bit…)
But according to Kevin Munc, “dev speed advantages are a myth.”
After learning the new environment, development time is not much improved using using HTML5 vs Native. Essentially you are doing all of the same things, only in another language. It’s learning the other environment that takes time.
Here is another article.
http://www.lifehacker.com.au/2013/03/ask-lh-should-i-use-phonegap-to-build-mobile-apps/
And here are some quotes:
The short answer: yes, using PhoneGap is fine, and will make it easy to build an app without needing to learn additional languages.
While you can deploy apps on multiple platforms, be aware that they won’t perform like native apps in every environment.
One more:
http://www.fastcompany.com/3030873/our-html5-web-app-flopped-so-we-went-native-and-havent-looked-back
http://www.fastcompany.com/3030873/our-html5-web-app-flopped-so-we-went-native-and-havent-looked-back
http://www.fastcompany.com/3030873/our-html5-web-app-flopped-so-we-went-native-and-havent-looked-back
Addendum: Develop twice
One of, if not the biggest, disadvantages of developing native is the fact that you will have to develop two apps, one for iOS, and another for Android. This sounds like a big hurdle if you’re impatient and time and money are the most important factors. But I think are is a hidden advantage to this approach.
Developing first on one platform, allows you to define, refine, and focus your UI and design on one platform before building for the other. Also, there are inherent differences between iOS and Android, building for both, creates an experience that doesn’t truly feel native on either. When quality is important I’m certain native is the choice.
Swift – Structs
If you haven’t heard Swift is a new language from Apple. Swift aims to be a modern language that streamlines your work.
Swift is strongly typed. This means that every value in Swift must be assigned a type.
Here I would like to talk about one feature in Swift called Structs. Struct is short for Structure or Construct. A Struct is similar to an Object in JavaScript.
In Swift a Struct is value. You can think of it as a complex value. If you were to think of a typical value, in a variable you might think:
var x = 230Here you have a single name, x, representing a single value the number (Int) 230. A Struct is the same, with the difference that a Struct is a structure containing more than a single value. You can think of the difference conceptually as the difference between: nail, and house. Nail is a single discrete element, while a house is single structure, it contains many sub elements.
var nail = 1
struct House {
var nails = 23000
var boards = 1200
}
You can see the variable nail holds a single value, while the house has two values: nails, and boards, and could contain any number of other values, like doors, switches outlets etc. Think of a Struct as a way to define an element that contains a group of related values. Imagine everything in your house as a struct:
struct House {
var nails = 1000
var boards = 200
var lightSwitches = 4
var doors = 3
var sink = 1
var toilet = 1
}
var myHouse = House()
println(myHouse.boards)Structs can also contain functions. In many ways a Struct is similar to a class. From our perspective they act in very much the same ways. Internally the software works them. Structs are assigned as values and Objects created from a Class are assigned as reference.
Copy vs Reference
When assigning a value (this would be how Structs are passed around) the computer creates a copy of the Struct. When you assign an Object you are assigning a reference to the original Object. In short:
Structs are always copied when they are assigned.
Class Objects are not copied when they assigned.
For example:
struct House {
var address = "123 Maple St."
}
var a = House()
var b = a
b.address = "321 Elm St."
println(a.address) // prints 123 Maple St.
println(b.address) // prints 321 Elm St.
Here you have two separate Houses. The first (a) would have the address 123, the second would have the address 321.
Here’s what would happen with a Class
class House {
var address = "123 Maple St"
}
var a = House()
var b = a
b.address = "321 Elm St."
println(a.address) // prints 321 Elm St.
println(b.address) // prints 321 Elm St.
You have two references to the same house, which moved from it’s original address to the 321 address.
Here is what Apple has to say about structs: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html
Swift – Character vs String
In Swift everything has a type. And these types can be fairly detailed. For example, Swift makes a clear distinction between a single Character, and a Collection of Characters.
Character
A Character in Swift can be any Character, this includes Emoji characters, and any other special character from any language set. You aren’t limited to UTF-8 characters.
Like many other programming languages Swift allows an escape sequence to represent special characters like these:
- \n Line Feed
- \r Carriage return
- \t Tab stop
- \\ Backslash
Characters also have a Name which describes the Character. For example a might be LATIN-SMALL LETTER A, while an Emoji might be FRONT-FACING BABY CHICK.
String
A String is a collection of Characters. The String has methods that allow us to access each Character in the String, and modify those Characters.
The String Class has so many options I couldn’t list them all here. All of the standard features you would expect exist. Though they might some different names. Things like:
- substringFromIndex
- substringToIndex
- stringByReplacingCharactersInRange
- stringByReplacingOccurrencesOfString
Parse.com
Parse.com is a service that wants to provides a backend for your social media apps. It’s my opinion that Parse is the easiest and fastest way for designers to get into creating social media apps and web sites.
How do we do it now?
The standard method to create a social media app or web site is to create a database and access the database using code written in MySQL. You also need code written in PHP to facilitate transactions with MySQL and manage content from the database. Together this is called the backend. All of these processes happen on a remote computer, your web host.
To have something people can look at you use HTML, CSS, and Javascript. This is called the frontend. You use HTML to structure your web pages, CSS to style them, and javascript to add functionality.
Let’s sum that up. To make a web site that has social media features you need (from front to back):
- HTML – Structures your data in the browser
- CSS – Styles the content in the browser
- Javascript – Adds functionality to the browser
- PHP – Handles backend services and transactions with the database
- MySQL – Stores and organizes data
Parse.com
Parse.com provides a service that removes the need for backend programming from the equation. With Parse all of the backend code is handled by the front end. Parse calls itself a: BaaS, which stands for Backend as a Service. The Parse service provides a ready made and hosted backend that can be used to build just about any type of social media app or web site.
Parse saves time by not requiring that you write backend code for creating and configure databases and tables. Parse provides ready made systems for managing user accounts and login. Creating a user login with Parse is as simple as creating the login or sign up form in HTML, CSS, and adding a few lines JavaScript.
For the record, I do not works for Parse and receive nothing from them. As an educator I see Parse as being the easiest way for students to make their social ideas into truly functional apps. For anyone else trying to make their social media ideas into real functioning work, Parse removes many of the roadblocks.
Who would benefit from Parse
Anyone wanting to get started making a social media network would benefit. Parse is well suited to small groups or individuals who want to get started making a social media site. If your skills are more frontend oriented, HTML, CSS, JS, then Parse will save you the trouble of learning PHP, MySQL.
Parse is targeted at startups and small teams looking to create new social media platforms quickly and easily. I see it as a perfect fit for students, as the focus of our students is on front end design and programming. Building an app with Parse moves all of the work of creating a social media app into the front end, and concentrates programming tasks into a smaller set of more familiar tools: HTML, CSS, and JS.
How does Parse work?
In short the Parse service works with Javascript. Essentially you create objects you wish to save in Javascript, and the Parse server takes care of the rest. To display data from the server you request objects from the Parse server through Javascript. Obviously there is a more to it than those two sentences, but not much more.
What kind of things can you make with Parse?
Any social media web site or App. Parse provides libraries code for Xcode, and Android. You can make mobile Application with much less effort, and I’ll say it again, without having to create a backend service, and database. Check out this page of customers using Parse:
Hello Kitty is using Parse!
Cocoa – Creating View Controllers from Code
Starting with an Empty Application, you have a program that contains a single class: AppDelegate and no storyboard. How do you build an application from this? Ignoring main.m and other esoteric code, your application begins at application:didFinishLaunchingWithOptions. When this method is called, your application has an empty window ready for you to populate with interesting objects.
Continue reading Cocoa – Creating View Controllers from Code
Objective-C – Delegates and Protocols
The delegate design pattern creates a system wherein one object passes work to another object. The first object stores a reference to another object, it’s delegate, and calls methods in the delegate object.
To make this system work there are two problems to solve. First. the main class needs a reference to the delegate object. The second problem is the need for the delegate object to implement the methods the delegator object will invoke. Without this guarantee your program runs the risk of no working or crashing.
The first problem is easily solved by adding a property to the delegator that holds a reference to it’s delegate object.
The second problem is solved by declaring a protocol. A protocol declares methods and properties that an object will invoke in it’s delegate. Any class that will act as a delegate implements the protocol, and the methods the defined in the protocol.
When the compiler sees a class that implements a protocol, it checks that the methods declared in the protocol are defined in that class. If not you get a warning or an error.
Declare a protocol in the header file above of @interface with:
@protocol ProtcolName <Class>
-(void)aMethod;
@endDeclare a delegate property to hold an object that implements the protocol. The delegate property should be weak to avoid dependancies!
@property (weak, nonatomic) id <ProtcolName> delegate;Use the id type here since the delegate object could be of any type.