Beginner iOS Notes

Helpful resource:

Good resource on how OAuth 2 works:

 http://www.quora.com/How-does-OAuth-2-0-work

 Summary of best answer:

 In order for Site A to access User X’s information on Site B, the following steps occur:

1. Site A registers User X with Site B. Site A obtains a Secret and an ID.

2. User X tells Site A to access Site B. User X is sent to Site B; Site B is informed to give Site A permission to specific information.

3. Site B redirects User X to Site A. Site B also provides User X an Authorization Code.

4. Site A sends its Authorization Code and Secret to Site B in return for a Security Token.

The code below would clear Instagram cookies:

-(void) clearInstagramCookies { for (NSHTTPCookie *cookie in [[NSHTTPCookieStorage sharedHTTPCookie Storage] cookies]) { NSRange domainRange = [cookie.domain rangeOfString:@"instagram.com"]; if(domainRange.location != NSNotFound) { [[NSHTTPCookieStorage shared HTTPCookie Storage] deleteCookie:cookie]; } } }

Basic functions in Swift are also fairly intuitive. As an example:

func favoriteSaramagoNovel() {

         println(“The last days of Ricardo Reis”)

}

//Output would look like:

// The last days of Ricardo Reis

  Now let’s try it by passing a parameter with no default value

func favoriteSaramagoNovel(novel: String) {

    println("My favorite Saramago novel is \(novel).")

}

favoriteSaramagoNovel("Blindness")

//Output would look like this assuming favoriteSaramagoNovel(“Blindness”):

//My favorite Saramago novel is Blindness

  We can leverage tuples to compound multiple values and return more than one piece of data.  As an example:

func favoriteMovies(name: String = “Blade 2”)  -> (Int, String) {

         let rottenTomatoRating = 99

         let movieTitle = “My favorite vampire movie is “  + name

         return (rottenTomatoesRating, movieTitle)

}

Putting this to use:

func favoriteMovieName(name: String = "Blade 2") -> (Int, String) {

    let rottenTomatoRating = 99

    let movieTitle = "My favorite vampire movie is " + name

    return (rottenTomatoRating, movieTitle)

}

let (ratingFromTomato, movieName) = favoriteMovieName()

Dictionaries and arrays are very easy to specify in Swift. For example, vs. Objective-C

Objective C (Arrays)

NSMutableArray *favoriteDrinks = [NSMutableArray arrayWithArray:@[@”Gunpowder tea”, @”Coconut water”]];

Swift:

var *favoriteDrinks = [“Gunpowder tea”, “Coconut water”]

Note that arrays in Objective-C can include all types of objects; arrays in Swift usually include like-type items.

Objective C (Dictionaries):

NSMutableDictionary *quantifiedSelf = [NSMutableDictionary dictionaryWithDictionary:@{@”Wristband”: @”Fitbit”, @”Alarm”:  @”Lightbox”}]; 

Swift (Dictionaries):

let quantifiedSelf = [“Wristband”: “Fitbit”, “Alarm” : “Lightbox”]

If we were to iterate over the above array in Objective-C, it would look like:

NSMutableDictionary *quantifiedSelf = [NSMutableDictionary

for (NSString *key in quantifiedSelf) {

            NSLog(@The quantified self item %@ is %@.”, key, quantifiedSelf[key]);

Output from above would be:

// The quantified self item Wristband is Fitbit.

// The quantified self item Alarm is Lightbox.

In Swift, it would like:

let quantifiedSelf = [“Wristband”: “Fitbit”, “Alarm” : “Lightbox”]

for (item, nameOfItem) in quantifiedSelf {

            println(“The quantified self item \(item) is \(nameOfItem).”)

}

 // The output is:

 // The quantified self item Wristband is Fitbit.

In Swift, creating properties and setting default values for them is very easy. For example:

 let excellentBreakfast = “Corned beef hash”

var myFavoriteChicagoHotel = “The Peninsula”

Note that let is used for immutable variables; var is used for variables that could change (though I’m not sure the above is a great example). The type of each variable is inferred by Swift based on the specified default values. Classes do not need to be specified. That said, if you choose not to specify a default value, you do need to declare what class the variable belongs to, for example:

let whitStillmanMovieTitle : String

 String interpolation in Swift is also fairly straightforward. For example

let googleShares = 1000

let restaurant = “Hot Dougs”

let sentence = “I cashed in all \(googleShares) shares of Google stock to build up  a huge inventory of pickled meats from \(restaurant).”

If we wanted to spend some of the money from our share redemption on Bubble tea, we might change things slightly:

let googleShares = 1000

var restaurant = “Hot Dougs”

restaurant += “ and Joy Yee.”

Functions in swift resemble methods in Objective-C. However, they can also do the following:

A function’s parameters can have default values

Functions can return more than one value using Tuples. As an example, in Objective-C, you can only return one variable from a method, i.e.:

-(NSString *) scifiWriterFirstName

In Swift, you can create a Tuple, and group multiple values into one variable:

let fullScifiWriterName = (“Neal”, “Stephenson”)

The above tuple – fullScifiWriterName – could be returned from a method, but would contain two separate values. Note that tuples aren’t restricted by type, and could contain a variety of types. For example:

let goodRestaurants = (“Masa”, 1847, “Don’s Bogam”)

Functions are objects, and they can be passed along to other functions

Setting up an observer of a property is a three-step process: 

1. Determine whether your problem is one where key-value observing could be beneficial; a good example is a situation where an object needs to be notified when there are changes to a specific property in another object. An example from the Apple Docs is a PersonObject wanting to know when the @property int accountBalance changes on BankObject.

2. In order for KVO to work, the PersonObject has to register as an observer of the BankObject’s accountBalance property. It does so by sending an addObserver:forKeyPath:options:context message, in code:

[bankInstance addObserver:personInstance forKeyPath:@”accountbalance” options:NSKeyValueObservingOptionNew context:NULL];

The code above generates a connection between the two objects – not between the two closes.

3. In order to respond to change notifications, the observer has to implement the observeValueForKeyPath:ofObject:change:context: method. In code:

-(void) observeValueForKeyPath:(NSString *)keyPathofObject:(id)object change:(NSDictionary *)change context:(void *)context {

//custom implementation; call the superclass’s implementation if the superclass implements it

}

The above method is invoked when the value of an observed property is changed in a KVO-compliant manner, or if a key upon which it depends is changed. For instance:

A Brief Primer on Auto Layout (Part I)

Auto Layout is based on the Cassowary constraint-solving toolkit. Per the Cassowary SourceForge project page:

“The Cassowary incremental constraint solving toolkit efficiently solves systems of linear equations and inequalities. Constraints may be either requirements or preferences. Re-solving the system happens rapidly, supporting UI applications.”

User interfaces naturally generate inequality and equality relationships; the Cassowary allows for a rules-based system that lets developers describe relationships between views using constraints. The constraints are rules that define how one view’s layouts are set and/or limited in relation to another view’s layouts.

By defining these relationships, AutoLayout can, for example:

-       Match one view’s size to another view’s size; for example, they will always remain the same height or width

-       Center a view in a superview; even if the superview reshapes, the view remains centered within it

-       Offset a pair of items by a constant padding

You use constraints to describe the view layout. Constraints define how things relate to one another, and how they can be laid out. For example, you might say, “always line up this series of items in a vertical row”, or, “this item will resize itself to match the width of that item”.

Constraints belong to the NSLayoutConstraint class. The class specifies relationships between view attributes – items like height, width, positions, and centers – using both equalities and greater or less than equal relations. It is required that constraints be both satisfiable and sufficient. In order for constraint satisfaction to occur, the rule must make sense individually and as part of a whole – i.e., a valid rule that plays part of a larger whole. As an example, a view can’t be both above another view and below it. Rules need to be consistent. In addition, rules also need to be specific enough and/or sufficient; for example, you want to provide a well-defined size and position for a view so they aren’t scattered all over the user interface.

Table  views are user interface objects that present data in a scrollable list of multiple rows that may be divided into specific sections. Generally, table views are used for the following purposes:

 1. Navigate hierarchically structured data

2. Present an indexed list of items

3. Display detailed information and controls clustered by group

4. Present a list of options for user selection

 Table views consist of only one column that allows for vertical scrolling. The table view has rows in each section. Each section can have a header or a footer that will display text or an image. UIKit framework identifies rows and sections through an index number. The index numbers for sections range from 0 to n-1 from the top of a table view to the bottom element; rows are numbered from 0 to n-1 within a section. Table views can themselves have their own headers and footer, distinct from a section header and footer. Table headers show up above the first row of the first section; table footers show up after the last row of the last section.

 A table view itself is an instance of the UITableViewClass. It is set as one of two styles – plain or grouped. Plain table views are unbroken lists; grouped tables have distinct sections. Table views have a datasource and might have delegates. Data sources provide – you guessed it, the data that is used to fill in the sections and rows of the table view. The data source mediates between the app’s data model (i.e., the model objects) and the table view. Delegate objects are used to further customize appearance and behavior. The data source and delegate are often the same object, which is usually a custom subclass of UITableViewController. The data source adopts the UITableViewDataSource protocol. UITableViewDataSource has two required methods, the tableView:numberOfRowsInSection: method that tells the table view how many rows to display in each section, and the tableView:cellForRowAtIndexPath: method, which provides the cell to display for each row in the table. The delegate adopts the UITableViewDelegate protocol, which has no required methods. The protocol declares methods that allow the delegate to modify visual elements of the table view, manage selections within the table view, and support editing of individual rows in the table view.

 Visible rows within a table view are drawn using cells, which are UITableViewCell objects. Cells are views that can display text, images, or other content. They can also have background views for normal and selected states. UIKit defiens four standard cell styles – each with its own layout of the three default content elements: main label, detail label, and image.

 When a user taps on a row, the delegate of the table view is made aware via message. The delegate is passed the index of the row and the section that the row is located in; it then uses this information to locate the corresponding item in the app’s model. The item will be either an intermediate level in a hierarchy of data or a “leaf node” in a hierarchy.

Visual formatting strings let you draw an outline of your views by utilizing keyboard characters. Take a look at this sample code:

 ```

[self.contentView addconstraints:[NSLayoutConstraint constraintsWithVisualFormat:@”H:|[_someImageView]|” options:kNilOptions metrics:nil views:viewDictionary]];

``` 

Introspection is a feature of the Objective C runtime. Introspection allows an object to answer questions about itself. As an example, NSObject has a method named respondsToSelector:. It looks like the following:

-(BOOL)respondsToSelector:(SEL)aSelector;

Key-Value Observing allows you to receive a notification when a particular property of an object is adjusted or changed. As an example, you might tell a Thomas Pink shirt object, "I want you to watch your pattern property. When that property changes, send me a notification". So, when a setPattern: method gets called, we will get a message from the Thomas Pink shirt object saying, "My pattern has a new value." 

A class has only one designated initializer method. If the class contains other initializers, then the implementation of the other initializers has to either directly or indirectly call the designated initializer. 

Quick fix for Chapter 31 iTahDoodle App in Big Nerd Ranch Objective C Programming Guide:

In the code, you enter:

[self.taskTable registerClass:[UITableViewCell class] forCellReuseIdentifier:@"Cell"];

Later in the app in the table view management section, make sure that when you call the UITableViewCell method you use capital "C" in cell:

(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath 

{

// To improve performance, this method first checks for an existing cell object that we can reuse; if there isn't one, then a new cell is created

UITableViewCell *c = [self.taskTable dequeueReusableCellWithIdentifier:@"Cell"];