Swift Programming for iOS

[icodeforios-blog]

PDFs as iOS assets

We can use PDFs in xcassets in xcode in place image files. 

Xcode under the hood converts them to appropriate 1x, 2x, 3x images as required. 

All we need to add the PDF file as image asset in xcassets and chose universal config in attributes inspector. Scale factor needs to be single vector and that’s it.

This single PDF file will be used to render images for all the different resolutions by xcode and used as PNGs only

[icodeforios-blog]

Being a Good Developer

Things to keep in mind while working on a project.

So working on numerous projects up till now has taught me numerous things. Coding part aside, there are many points to keep in mind while developing an app. 

5 mantra's for being a good coder are:

Follow the coding guidelines: A developer should always follow a set of rules which makes a code more readable. Coding for some us can be termed as an art. And every artist fashions a certain style otherwise its just tasteless. Wouldn't you say the same? Canon: Use DRY conventions, proper indentations and modularity.

Format your code: All right, so now I have good looking code but isn't it problematic if I can't browse through it with ease and if its pretty printed, I can't make sense of it at all ? Canon: Maintain proper folder structure, Add comments to the code.

Handle those exceptions: Its not a good app if it doesn't even works. Foresee the future and tackle forthcoming errors. Canon: Exceptions handling wherever there is a slightest stink of need.

Let's log those errors: Everything set, resolved all bugs, application live and BAM! a barrage of crashes and errors right on the face. Only If there was a way to evade these attacks. Canon: Find a way to log the errors, crashes related report and there easy access.

Manage the source code: Let's save ourselves from our own screw ups and from natural one's too. Power outage, system crash, SDK crash, human errors can undo hours of hard work. Canon: Use SCM or at least version control, mysteries in the coding can render your fully operation code, dead!

[icodeforios-blog]

Protocols and Delegates in Swift

In iOS development, a protocol is a set of methods encapsulated as a unit. The protocol itself doesn't have any definition of these methods; it merely contains the method declarations. Any class that declares itself to conform to this protocol must implement the methods dictated in the protocol.

Protocol Declaration

syntax used in swift is as follows:-

protocol DemoProtocol

{

    func myMethod()

}

Protocol Confirmation

The protocol name is declared after the superclass , separated with a comma.

Syntax is as follows:-

class MyClass: DemoProtocol

{

    func myMethod()

    {

    }

}

  class SecondClass: SomeSuperClass, DemoProtocol

{

    func myMethod()

    {

    }

}

Delegation of Protocol

Delegation is a design pattern that enables a class or structure to hand off (or delegate) some of its responsibilities to an instance of another type. 

In Swift, delegate property is just like any other property with protocol name as type of the property.

Question mark syntax indicates that it’s a property with an optional value.

Syntax is as follows:-

class FirstClass

{

    var delegate:DemoProtocol?

}

Calling the Delegate Methods

syntax to do so, is as follows:-

  delegate?.someMethod()

// "?" checks if the method exists, if not, nothing after the ? for the statement is executed.

[icodeforios-blog]

Xcode 6 - Live Rendering of UI

Hi All, 

In Xcode 6, apple has added an interesting new feature- Live rendering of UI i.e. UI designing programmatically can be rendered real time in storyboards.

And all we have to do is add keyboard "IB_DESIGNABLE" in our class. That's it.

Other interesting feature to be noted is the use of keyword "IBInspectable". We can declare properties of our custom object as IBInspectable and they will be visible in attribute inspector in storyboards.

Let's elaborate on this with an example:-

Fire up a new project in Xcode 6, add a new object class, I am using a UIView here.

# Declare the view as "IB_DESIGNABLE"

# Declare the property as "IBInspectable"

Moving on, let's make some changes in .m file for the same

Here, I have overridden the method drawRect and given the view's layer a border using the variable we declared as IBInspectable earlier. And to differentiate the border is coloured red.

Now all we gotta do is, add a UIVIEW on our default view controller through storyboard and assign that view the class we just made.

Now we can tinker with the property we wrote through storyboards and see the difference in realtime. :D

[icodeforios-blog]

Fundamentals of Swift

  VARIABLES

  As with every programming language you have variables which allow you to store data. To declare a variable you have to use the keyword var.

  var greeting: String = "Hello World"

The above code instructs the system that you want to create a variable named greeting which is of type String and it will contain the text, “Hello World”.

  Swift is smart enough to infer that if you are assigning a string to a variable and in fact that variable will be of type string. So you need not explicitly specify the type as in the above example. A better and common way of writing the above example would be:

  var greeting = "Hello World" // Inferred type String

Variables can be modified once created so we could add another line and change our greeting to something else.

  var greeting = "Hello World" // Inferred type String

  greeting = "Hello Swift"

  While writing an application there are many instances where you don’t want to change a variable once it has been initialized. Apple has always had two variants of types mutable and immutable. Mutable meaning the variable can be modified and immutable that it cannot be modified. They prefer immutability by default which means that the values aren’t going to change and it makes your app faster and safer in a multi-threaded environment. To create an immutable variable you need to use the keyword let.

  If we change our greeting example to use let instead of var then the second line will give us a compiler error because we cannot modify greeting.

  let greeting = "Hello World"

greeting = "Hello Swift" //Compiler error

    Lets see how we can concatenate two strings by using the + operator.

  let title = "Guide to Swift"

let review = "Its Awesome!"

let description = title + " - " + review

// description = "Guide to Swift - Its Awesome!"

Strings have a powerful string interpolation feature where it’s easy to use variables to create a strings.

  let datePublished = "September, 2014"

  let postMeta = "Blog Post published on: \(datePublished)"

  // postMeta = "Blog Post published on: September, 2014"

In all the above examples, I have been using the keyword let which means you cannot modify the string once it has been created. However, if you do need to modify the string then simply use the keyword var.

  OTHER TYPES

  A Float and Double vary in precision and how large of a number you can store.

  Float: represents a 32-bit floating-point number and the precision of Float can be as little as 6 decimal digits.

Double: represents a 64-bit floating point number and has a precision of at least 15 decimal digits.

By default when you write a floating-point number it is inferred as a Double.

  var version = 1.0 // inferred as Double

You can explicitly specify a Float.

  var version: Float = 1.0

    Collection Types

ARRAY

  Collections come in two varieties. Firstly, an array which is a collection of data items which can be accessed via an index beginning with 0.

  var cardNames: [String] = ["Jack", "Queen", "King"]

  // Swift can infer [String] so we can also write it as:

  var cardNames = ["Jack", "Queen", "King"] // inferred as [String]

  You can create two types of arrays: an array of a single type or an array with multiple types. Swift is keen on being safe so it prefers the former but can accommodate the later with generic types. The example above is an array of strings which means that it is a single type array.

  To access an item from the array you need to use the subscript:

  println(cardNames[0])

Note: we used a function above called println which will print the value “Jack” to the console and then add a new line.

  MODIFYING AN ARRAY

  Lets create a new array that contains a todo list.

  var todo = ["Write Tip","Return Call"]

  Make sure that you use the keyword var so that we can modify our array.

  To add another item to our todo array we use the ‘+=’ operator:

  todo += "Get Grocery"

  To add multiple items to our todo array we simply append an array:

  todo += ["Send email", "Pickup Laundry"]

  To replace an existing item in the array simply subscript that item and provide a new value:

  todo[0] = "Proofread Blog Post"

  To replace an entire range of items:

  todo[2..<5] = ["Pickup Laundry","Get Grocery", "Cook Dinner"]

  DICTIONARY

  The other collection type is a Dictionary which is similar to a Hash Table in other programming languages. A dictionary allows you to store key-value pairs and access the value by providing the key.

  For example, we can specify our cards by providing their keys and subsequent values.

  var cards = ["Jack" : 11, "Queen" : 12, "King" : 13]

Above we have specified the card names as the keys and their corresponding numerical value. Keys are not restricted to the String type, they can be of any type and so can the values.

  MODIFYING A DICTIONARY

  What if we wanted to add an “ace” to our cards dictionary? All we have to do is use the key as a subscript and assign it a value. Note: cards is defined as a var which means it can be modified.

  cards["ace"] = 15

We made a mistake and want to change the value of “ace”. Once again just use the key as the subscript and assign it a new value.

  cards["ace"] = 1

To retrieve a value from the dictionary

  println(cards["ace"])

  Control Flow

  LOOPING

  What it good is a collection if you cannot loop over it? Swift provides while, do-while,for and for-in loops. Lets take a look at each one of them.

  The easiest one of them is the while loop which states while something is true execute a block of code. It stops execution when that condition turns to false.

  while !complete {

println("Downloading...")

}

Note: the exclamation mark before the variable complete denotes not and is read as “not complete”.

  Likewise, you have the do-while loop which ensures that your block of code is executed at least once.

  var message = "Starting to download"

do

{

println(message)

message = "Downloading.."

} while !complete 

Subsequent calls to the println statement will print “Downloading..”

  You have the regular for loop where you can specify a number and increment that number to a certain value:

  for var i = 1; i < cardNames.count; ++i

{

println(cardNames[i])

}

Or you can simply use the for-in variant where it creates a temporary variable and assigns it a value while iterating over the array.

  for cardName in cardNames

{

println(cardName)

}

The above code will print out all the card names in the array. We can also use a range. A range of values is denoted by two dots or three dots.

  For example:

  1…10 – is a range of numbers from 1 to 10. The three dots are known as a closed range because the upper limit is inclusive.

1..<10 – is a range of numbers from 1 to 9. The two dots with a lesser-than sign is known as a half-closed range because the upper limit is non-inclusive.

Lets print out the 2 times table using for-in with a range:

  for number in 1...10

{

println("\(number) times 2 is \(number*2)")

}

We can also iterate over the cards dictionary to print out both the key and the value:

  for (cardName, cardValue) in cards

{

println("\(cardName) = \(cardValue)")

}

IF STATEMENTS

  To control the flow of our code we of course have an if statement.

  if cardValue == 11

{

println("Jack")

}

else if cardValue == 12

{

println("Queen")

}

else

{

println("Not found")

}

Note: The if syntax can have parenthesis but they are optional. However, the braces {} are mandatory unlike other languages.

  SWITCH STATEMENT

  The switch statement in Swift is very versatile and has a lot of features. Some basic rules about the switch statement:

  It doesn’t require a break statement after each case statement

The switch is not limited to integer values. You can match against any values such as: String, Int, Double or any object for that matter.

The switch statement must match against every value possible if not you must have a default case which makes your code safer. If you don’t provide a case for every value or a default then you will get a compiler error saying: “switch must be exhaustive”.

switch cardValue

{

case 11:

println("Jack")

case 12: 

println("Queen")

default:

println("Not found")

}

Lets say you have a distance variable and you are trying to print a message based on distance. You can use multiple values for each case statement:

  switch distance

{

case 0:

println("not a valid distance")

case 1,2,3,4,5:

println("near")

case 6,7,8,9,10:

println("far")

default:

println("too far")

}

There are times when even multiple values are limiting. For those instances you can use ranges. What if any distance greater than 10 and less than 100 was considered far?

  switch distance

{

case 0:

println("not a valid distance")

  case 1..10:

println("near")

  case 10..100 :

println("far")

  default:

println("too far")

  }

  Functions

  Finally, we have been using println in a lot of our examples which is an example of how to use a function. But how can you create your own function?

  It is simple, you have to use the keyword func and provide it with with a name.

  func printCard()

{

println("Queen")

}

What good is a function if it always going to just print “Queen” as the card name. What if we want to pass it a parameter so it can print any card name?

  func printCard(cardName: String)

{

println(cardName)

}

Of course, we are not restricted to just one parameter. We can pass in multiple parameters:

  func printCard(cardName: String, cardValue: Int)

{

println("\(cardName) = \(cardValue)")

}

What if we simply wanted our function to build a string and return the value instead of printing it? Then we can specify a return it which is specified at the end of the function declaration followed by an array ->.

  func buildCard(cardName: String, cardValue: Int) -> String

{

return "\(cardName) = \(cardValue)"

}

Above we are saying that we are creating a function named buildCard which takes in two parameters and returns a String.