#swifttutorial

When using UICollectionView’s with the default single selection type. Deselecting the cell can be an issue and none of the deselect Delegate methods get called :/

So how to work around it?

Utilising another delegate method “shouldSelectItemAtIndexPath” you can detect whether a cell is selected or not and respond accordingly.

func collectionView(collectionView: UICollectionView, shouldSelectItemAtIndexPath indexPath: NSIndexPath) -> Bool {

       let cell = collectionView.cellForItemAtIndexPath(indexPath)

       if let selected = cell?.selected where selected  {

          //Preform any custom deselect logic

           collectionView.deselectItemAtIndexPath(indexPath, animated: false)

           return false

       }

       return true

   }

   func collectionView(collectionView: UICollectionView, didSelectItemAtIndexPath indexPath: NSIndexPath) {

       //Preform selection logic

Hey what's up everyone! Hope ya'll been staying humble and tryna learn something new everyday. I know It's hard to stay consistent but If these up and coming rappers can post outside of shopping malls all day with a mediocre flow and a cd player, we can definitely sit at our Macbooks and chill with a lil tutorial (whatever that means lol).

Today we're going to build a basic app that displays the multiplications table for a number given to us by our UISlider! 

As Dan Dotson from Storage Wars would say, "Are you ready? Let's go!"

First we're going to open up XCode and select, Create New Project

Select** Single View Application**

We'll call our Product Name: TimesTables

(I'm going to call it TimesTabless because I already have a project named TimesTables) 

Also leave "Use Core Data" checkbox unchecked!

Once you have all that we can click Next

After that we should be presented with a nice blank project including a ViewController.swift hooked up to our View begging to be modified! 

But before we start coding, lets first look inside the Main.storyboard file! It should be on your left hand side under the ViewController.swift file.

Your screen should look like this:

Make sure your Utilities Pane is open (the farthest icon on the top right corner should be highlighted like in the photo above) use those icons to show or hide those panes. When that pane is revealed make sure that your Object Library is selected (the small square inside the circle)

When you have that open, you can scroll down or use the text field on the bottom to search for the Slider object. Once you find the Slider, you can click and drag it to the View Controller.

Drag the slider towards the top of the View Controller and expand it so that it can go across the the top of the screen.

Now if you don't know about Auto Layout, it's Apple's way of helping developers manage screen sizes across multiple devices. 

For that we use Constraints. We give an object constraints to have them clipped to certain objects or the screen, so that no matter what device the user is on the object will always be, for example, the same distance from the top of the screen. 

It's very easy to add a constraint to an object. Simply click on the object in this case our Slider and look for the small "hieroglyphic" type icons on the bottom right of our Main.storyboard. Click on the second one that looks like a spaceship.

To keep our Slider consistent across multiple devices we clip our slider to the top distance of the screen, the left and right side as well. To do that we have to highlight those distances by clicking on the small red lines. Then click on Add 3 Constraints

Now when we run this project on our simulator the slider will take up the same amount of screen on any device or rotation.

Now how do we actually use this slider?

Let's close our Utilities Pane by un-highlighting the small icon farthest to the right on the top right corner of our project window. 

Now slightly to the left of those 3 icons is yet another set of 3 icons. 

Click on the Assistant Editor (the tuxedo icon or the two circle icon if your Mac is running Yosemite) to connect our Slider to our code.

Your screen should look something like this

If it does then congratulations, you puttin' in work like those up and coming rappers outside Fox Hills Mall!

To use our slider in code we have to create an IBOutlet for it. 

To do that we have to CTRL-Click and drag to our ViewController.swift file! Make sure to drag inside our class and above the viewDidLoad method

For your connection type choose: Outlet

Name: sliderValue

Type: UISlider

Storage: Weak

Click Connect

Then we're going to make another connection on the same slider object but this time make sure the Outlet type is Action! 

Name: sliderMoved

Your screen should look like this now:

Now let's close our Assistant Editor and go back to our Standard Editor.

Let's go back to our Main.storyboard file and drag a Table View item from our Objects menu to our View Controller, just like how we added the Slider.

Also you guys are smart now, make sure that you expand the** Table View to take up the whole screen below the slider and add Constraints just like we did before, except this time to all 4 sides.**

COOL! Now we got a lil table view and a lil slider chillin on the screen that both use Auto-Layout to manage multiple screen sizes. 

Before we move on make sure have your Utilities Pane open and set the Prototype Cells to 1

Click on that cell and set the Identifier to "Cell"

Also make sure that you set the Delegate and Datasource of the Table View by CTRL-Click and drag the Table View to our view (small yellow circle on top of view controller)

You should have this now 

Okay, now let's focus on this Table View that we just added. Let's open up our ViewController.swift file and add a UITableViewDelegate

This just tells the View Controller that it is responsible for the Table View. Once we add that Delegate to our ViewController class. We have to add our Table View Delegate Methods.

https://gist.github.com/8d5250ffcb820c6be866.git

Add these two delegate methods above your viewDidLoad. You should have some errors but don't worry we'll make those go away right now (:

Usually our numberOfRowsInSection method counts a set of data and returns that value but for now we're just going to return an Integer (20).

Your numberOfRowsInSection method should look like this

https://gist.github.com/7e1a78c15277a942bfeb

Once you have that we can start tweaking our cellForRowAtIndexPath method. First we're going to create a UITableViewCell object for us to return at the end of the method. After that we're going to create a constant called timesTable. Then we're going to set the text of our cell to our timesTable constant. Sounds a bit confusing but it's not that crazy.

Your cellForRowAtIndexPath method should look like this now.

https://gist.github.com/84a4183d8475c41ae060

If you build your application now you should see this

Cool! We're almost done! Our slider is giving us a stock value of ten, and as we can see it seems to be multiplying 10 x (the index of the cell). Let's slide the slider and...wait?! It doesn't change the text of all the cells!!

To fix that all we have to do is reload the table data every time we move the slider! But to do that we have to be able to call on our Table View directly.

Let's create an outlet for our for our Table View. 

CTRL-Click and drag to our ViewController.swift 

So now we need to update our table data every time our slider gets moved.

Oh yeah don't we have a sliderMoved function?

let's reload our table data every time the sliderMoved is executed !

Your sliderMoved function should look like this now:

https://gist.github.com/ChristianNavarrete/54124c969d6213f895fe

And if we build our project now we should see our table data update when we move our slider!

Awesome, we did it! But now this 0 is annoying me. That's because our cell index starts at 0. Let's fix that! Let's go back to our cellForRowAtIndexPath method and tweak it a bit. We're just going to add 1 to each cell index so that the count can start at 1 instead of 0.

Your cellForRowAtIndexPath method should look like this now:

https://gist.github.com/ChristianNavarrete/410a907659728b0a3ead

Now you should see something like this:

AWESOME! 

This tutorial might be over but them rappers is still tryna slang mixtapes outside of Fox Hills Mall as we speak. We must always show respect to them and their hustle. Even if their music sucks, you gotta try and match their passion. Some Hood words of wisdom from your Swift teacher lol 

Now we can chill and get back to this Justified album!

IOC in swift is a difficult problem to solve. Generics and reflect as still very immature so creating an instance on an object in pure swift is difficult.

Most of the solutions I could find utilise objective-c. Which is find for class that conform to NSObject or have the flag obj-c. So what about swift objects

Basic Constructor 

One solution is to use dictionary containing closures that return an instance of your object.

You can then retrieve an instance of an object by calling the get function on the injector.

let simpleService: Service1 = Injector().getSimpleClass(Service1)

Im sure we have all experienced the joys of autolayout. Its fantastic when it goes well, but when it goes wrong your in a world of pain.

The easiest way to using autolayout is though interface builder but what about views that and created programmatically??

Swift provides a way to manipulate your views dynamically without the need to manually set frame position which will inevitably go wrong.

A NSLayoutConstraint must first be created that maps the relationship between the parent view and child. 

The below sample, creates a constraint which positions newView in the CenterX of the parent.

NSLayoutConstraint(item: newView, attribute: .CenterX, relatedBy: .Equal, toItem: self.view, attribute: .CenterX, multiplier: 1.0, constant: 0)

This constraint must then be applied to the parent view to enable so the layout can take place.

let centerX= NSLayoutConstraint(item: newView, attribute: .CenterX, relatedBy: .Equal, toItem: self.view, attribute: .CenterX, multiplier: 1.0, constant: 0)

self.view.addConstraint(centerX)

Autolayout Not Working?

In order to get the constrains to change the views layout, autoresizingmask must be set to false.

newView.setTranslatesAutoresizingMaskIntoConstraints(false)

Full Example

let newValue = UIView(frame: CGRect(0,0,300,300))

newValue.setTranslatesAutoresizingMaskIntoConstraints(false)

self.view.addSubview(newValue)

let centerX = NSLayoutConstraint(item: newValue, attribute: .CenterX, relatedBy: .Equal, toItem: self.view, attribute: .CenterX, multiplier: 1.0, constant: 0)

self.addConstraint(centerX)

let centerY = NSLayoutConstraint(item: newValue, attribute: .CenterY, relatedBy: .Equal, toItem: self.view, attribute: .CenterY, multiplier: 1.0, constant: 0)

In previous ios versions you would create a launch asset catalog containing the different image resolution that would be used on depending on the version. With the introduction of iOS8 there is now a new way.

Interface Builder

First create a new file from under "User Interface" and select the option called "Launch Screen"

Using autolayout design the first view of you app so it scales to suit all resolutions that your app supports.

Using the new Launch Screen

Under the app setting select the newly created Launch Screen from the app options.

I think everyone would agree the notification pattern within objective-c is a great way to decouple views from services.

Swift implementation

Posting a notification in swift is similar to the objective-c implement just with the new syntax.

NSNotificationCenter.defaultCenter.postNotification(name: “notificationName”, object: nil)

When adding an observer to the Notification Center in swift. The class that is being set as the observer must be an objective-c type (Derive from NSObject). When the class isn’t an objective-c type, when the notification selector fires and exception is thrown crashing the app.

NSNotificationCenter.defaultCenter.addObserver(selector: “methodToInvoke:”, name: “notificationName”)

fund methodToInvoke(notification: NSNotification) { //Do Stuff }

Testing NSNotificationCenter

Currently this is no native mocking framework for swift meaning the only viable way to mock object is using hand rolled mocks.

In the test target create a new swift class called: MockNSNotificationCenter. In the new class, subclass NSNotificationCenter then override the methods your test is expecting to call as described below:

class MockNSNotificationCenter: NSNotificationCenter {

    var observerCount = 0

    var postCount = 0

    var lastPostedNotificationName:String?

    override func addObserver(observer: AnyObject, selector aSelector: Selector, name aName: String?, object anObject: AnyObject?) {

        observerCount++

    }

    override func postNotificationName(aName: String?, object anObject: AnyObject?) {

        lastPostedNotificationName = aName!

        postCount++

    }

}

Then in your real class you use lazy instantiation to allow the mock notification center to be injected.

class RealClass {

    lazy var notificationCenter: NSNotificationCenter = {

        return NSNotificationCenter.defaultCenter()

  }()

    func someMethodPostNotification() {

        notificationCenter.postNotification(name: “notificationName”, object: nil)

    }

}

In your test class you can assert that a notification is posted when a method is called

class RealClassTests: XCTestCase {

    let sut = RealClass()

    let mockNotification = MockNSNotificationCenter()

    func testNotification() {

        sut.notificationCenter = mockNotification

        sut.someMethodPostNotification()

        XCTAssertEqual(mockNotification.postCount, 1, "a notification should be posted")

    }