#hackingwithswift

Now get to be introduce to UICollectionViewController.

Overall more or less the same as objective-c. And the author introduce new thing, fatalError() - it will crash the app and print out the error message the developer code but it’s something needed as well if one just want to terminate the app if certain things didn’t go right and maybe no point for the user to continue it.

From the tutorial , maybe need to add 1 more thing is estimate size on at the storyboard there need to change to “None” instead of automatic or else the cell size setting won’t work

Then follow by UIImagePickerController, which needs UIImagePickerControllerDelegate and UINavigationControllerDelegate as well.

If we need to access the image later on, or want to store it in app private storage, what we can do is get a file path, and write it to the path. For example:

let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask) let imageName = UUID().uuidString let imagePath = paths[0].appendingPathComponent(imageName) if let jpegData = image.jpegData(compressionQuality: 0.8) { try? jpegData.write(to: imagePath) }

Golden rules - access remote resources must do it in background thread instead of main thread since that will freeze the UI which has to be run on the main thread. And GCD can fix that

And async() is the keyword, to switch from main thread to background thread, and vice versa. Although it says it’s First In First Out (FIFO) but then since one can open many thread run at the same time, so it’s kinda hard to say it’s FIFO all the time, unless one define one single operation queue and every task share the same thing.

Each thread priority is control by quality of service (QoS) , and there’s 4 QoS - .userInteractive - highest priority, almost dedicate all available resource to this thread - .userInitiated - it’s important still because you’ll need that task to complete to show something - .utility - something that need maybe a long time to complete but no immediate attention require - .background - run task that’s not important or something user doesn’t care much

User Interactive and User Initiated thread will eat the battery to boost performance, Utility try boost performance as possible but w/o killing the battery much, like 50:50 , while Background mode only cares about the battery part , 0 concern on performance and let it run forever.

There’s default mode as well, which is in between User Interactive and User Initiated

And no weak self needed in GCD closure as it get discarded after finish run

Example DispatchQueue.global(qos: .userInitiated).async

But after go background thread, we need to come back to main thread as well to update the ui after finished the background task.

Example DispatchQueue.main.async

So .global vs .main , between background and main thread.

But how do I know at certain point I’m on background thread or main thread?

This time is build UI with just code

So far this subject is review how to write constraint by code level.

Nothing much new besides Collection.enumerated, String.replacingOccurrences and didSet for the Property observe

Here introduce to UITabBarController

“Swift has built-in support for working with JSON using a protocol called Codable. When you say “my data conforms to Codable”, Swift will allow you to convert freely between that data and JSON using only a little code.”

Definition by the author, let’s see how powerful is this.

So it’s quite convenient to parse the json data into swift native support data type, instead of self declare and unwrap it layer by layer.

Only 1 thing is the window code to add a new tab, I think it’s time to update it using SceneDelegate since window is omitted from AppDelegate with the latest Xcode.

https://www.hackingwithswift.com/read/6/2/advanced-auto-layout For this part, kinda hope the author can add in some visual aids instead of full text description on what to change as everyone may be using different screen size or different constraint to begin with

let label2 = UILabel() label2.translatesAutoresizingMaskIntoConstraints = false

translatesAutoresizingMaskIntoConstraints set to false to prevent iOS generate default auto layout constraints if we intend to do it manually

===========================

So time for Auto Layout Visual Format Language (VFL). I have try this before in ObjC, hope the syntax is not so complicated in swift

let viewsDictionary = ["label1": label1, "label2": label2, "label3": label3, "label4": label4, "label5": label5] view.addConstraints( NSLayoutConstraint.constraints(withVisualFormat: "H:|[label1]|", options: [], metrics: nil, views: viewsDictionary)) H = horizontal constraint | | = single pipe on both end means to go edge to edge in parent view (equivalent to leading space = 0,  trailing space = 0, or width = parent width)

view.addConstraints( NSLayoutConstraint.constraints(withVisualFormat: "V:|[label1]-[label2]-[label3]-[label4]-[label5]", options: [], metrics: nil, views: viewsDictionary))

V = vertical constraint | = single pipe at the start point means align from top - = dash in between, it’s vertical spacing , default = 10 points (equivalent to top spacing or bottom spacing, depends on the relationship between 2 views)

Now try update to this view.addConstraints( NSLayoutConstraint.constraints(withVisualFormat: "V:|[label1(==88)]-[label2(==88)]-[label3(==88)]-[label4(==88)]-[label5(==88)]-(>=10)-|", options: [], metrics: nil, views: viewsDictionary))

==88, 88 points for height (since it’s V) >=10, minimum bottom spacing 10 points (since it’s V)

Imagine if one need to change the height very frequent due to certain circumstances, human error may occur when wrong value input into it. So one can make use of metric, meaning aside the value to a variable and use that variable whenever needed, then can reduce human error

let metrics = ["labelHeight": 88]

view.addConstraints( NSLayoutConstraint.constraints(withVisualFormat: "V:|[label1(labelHeight)]-[label2(labelHeight)]-[label3(labelHeight)]-[label4(labelHeight)]-[label5(labelHeight)]->=10-|", options: [], metrics: metrics, views: viewsDictionary))

===========================

If turn to landscape, there will be constraint issue since the total height probably can’t fulfil 5 labels with 88 points height with the addition spacing in between. So we need to tell which constraint get higher priority

Constraint priority is a value between 1 and 1000. The higher the number, the higher the priority. 1000 = must follow. Since we know 88 points for height is impossible to be fulfilled in landscape mode, so can make that optional

view.addConstraints( NSLayoutConstraint.constraints(withVisualFormat: "V:|[label1(labelHeight@999)]-[label2(label1)]-[label3(label1)]-[label4(label1)]-[label5(label1)]->=10-|", options: [], metrics: metrics, views: viewsDictionary))

labelHeight@999 = set labelHeight with priority value 999 , so if it can’t fulfil the height set, auto layout can shrink it since it’s not 1000 label2(label1) = label2 copy label1 height (equivalent to label 2 equal height to label 1)

===========================

And then it’s Anchor time

Each view comes with widthAnchor, heightAnchor, topAnchor, bottomAnchor, leftAnchor, rightAnchor, leadingAnchor, trailingAnchor, centerXAnchor, and centerYAnchor.

If device language is those type from right to left, like Arabic, using leadingAnchor and trailingAnchor will flip the view the other way around. If want remain the same as leadingAnchor and trailingAnchor with language like English as device language, one need to use leftAnchor and rightAnchor instead.

var previous: UILabel?

for label in [label1, label2, label3, label4, label5] {    label.widthAnchor.constraint(equalTo: view.widthAnchor).isActive = true    label.heightAnchor.constraint(equalToConstant: 88).isActive = true

   if let previous = previous {        // we have a previous label – create a height constraint        label.topAnchor.constraint(equalTo: previous.bottomAnchor, constant: 10).isActive = true    }

   // set the previous label to be the current one, for the next loop iteration    previous = label }

By default the view will stick to the top if we don’t assign anything, so for the first label, we don’t need the topAnchor, only the following one onwards. BUT there’s one problem. To make sure the view look nice at iPhone X series or iPhone with notch, we need to ensure the top or bottom view is within the safe area zone

if let previous = previous {    // we have a previous label – create a height constraint    label.topAnchor.constraint(equalTo: previous.bottomAnchor, constant: 10).isActive = true } else {    // this is the first label    label.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 0).isActive = true }

Resuming….the closure nightmare

Weak vs strong vs unowned

class Singer {    func playSong() {        print("Shake it off!")    } }

func sing() -> () -> Void {    let taylor = Singer()

   let singing = {        taylor.playSong()        return    }

   return singing }

“taylor” inside the sing closure will never get destroy even after the function has returned, under “strong” reference.

===================== func sing() -> () -> Void {    let taylor = Singer()

   let singing = { [weak taylor] in        taylor?.playSong()        return    }

   return singing }

If change to “weak” then it’s possible to get destroy when it gets “nil”

“taylor” now become optional now, since it’s possible to be destroy at any time. But that also means “taylor” only exist inside sing()

======================

Alternative to weak will be “unowned”

func sing() -> () -> Void {    let taylor = Singer()

   let singing = { [unowned taylor] in        taylor.playSong()        return    }

   return singing }

Unowned is like implicit unwrap, meaning from the previous example, the “weak” taylor need to use “?” or “!” before calling playSong(), unowned is like weak + “!” together .

===================

Project Part

Array.randomElement = randomly return 1 object from the array

Introduction to WKWebview

“The delegation solution is brilliant: we can tell WKWebView that we want to be informed when something interesting happens. In our code, we're setting the web view's navigationDelegate property to self, which means "when any web page navigation happens, please tell me – the current view controller.” Definition of delegation by the author, this will comes in handle when we create our own custom delegate after this.

class ViewController: UIViewController, WKNavigationDelegate

Parent class comes first, then only protocol next

@objc func openTapped() { let ac = UIAlertController(title: "Open page…", message: nil, preferredStyle: .actionSheet)        ac.addAction(UIAlertAction(title: "apple.com", style: .default, handler: openPage))        ac.addAction(UIAlertAction(title: "hackingwithswift.com", style: .default, handler: openPage))        ac.addAction(UIAlertAction(title: "Cancel", style: .cancel))        ac.popoverPresentationController?.barButtonItem = self.navigationItem.rightBarButtonItem        present(ac, animated: true) }

func openPage(action: UIAlertAction) { let url = URL(string: "https://" + action.title!)!        webView.load(URLRequest(url: url)) }

action.title is refer to the title set at the new instance of UIAlertAction

================== And the very first delegate we use under WKNavigationDelegate

func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {        title = webView.title }

Whenever web view finished load a page, it will change the navigation title to be the same as web view title

==================

Now introduce UIToolbar and UIProgressView

var progressView: UIProgressView = UIProgressView(progressViewStyle: .default) progressView.sizeToFit() let progressButton = UIBarButtonItem(customView: progressView)

let spacer = UIBarButtonItem(barButtonSystemItem: .flexibleSpace, target: nil, action: nil) let refresh = UIBarButtonItem(barButtonSystemItem: .refresh, target: webView, action: #selector(webView.reload))

toolbarItems = [progressButton, spacer, refresh]

Wrap the progress button in UIBarButtonItem and add it to toolbarItems =============

Key-value observing (KVO)

To update the progressView we need to know the web view loading progress

webView.addObserver(self, forKeyPath: #keyPath(WKWebView.estimatedProgress), options: .new, context: nil)

Usually when do addObserver(), one need to take care of removeObserver() to ensure everything run fine

Then add the following method to get the value

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {    if keyPath == "estimatedProgress" {        progressView.progress = Float(webView.estimatedProgress)    } }

Since we want to observe the key path of WKWebView.estimatedProgress, then inside the method, we check if the key path of the value is actually same as WKWebView.estimatedProgress. If it’s the same, we get the estimate progress and update the progressView progress.

The extra float casting is needed since webView.estimatedProgress is a Double, and progressView.progress only accept Float.

================= func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {    let url = navigationAction.request.url

   if let host = url?.host {        for website in websites {            if host.contains(website) {                decisionHandler(.allow)                return            }        }    }

   decisionHandler(.cancel) }

To ensure user can’t navigate to other page, need this delegate method to control the site, but need to read more on @escaping closure

Review of project 1, project 2 and project 3

So far learn how to use UITableView, UIViewController, UIButton, UIImageView, UIBarButtonItem. And how to edit some of the view property using CALayer properties, such as  borderWidth, borderColor , and etc And learn about assistant editor view, to add IBOutlet and IBAction as well. And access resources using Bundle, and FileManager, like using the image assets, with the @2x , @3x concept

let items = try! fm.contentsOfDirectory(atPath: path)

Assume fm is FileManager object, swift will enforce you to wrap it in try catch when call contentsOfDirectory, that’s because the path might not exist or you type wrong name, but since our sample code won’t face that issue, we can just direct use try! instead of proper try catch.