Dactyloidae iOS initial commit

mobile/ios/Client/Frontend/Browser/BackForwardListViewController.swift

@@ -0,0 +1,249 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import UIKit
+import Shared
+import WebKit
+import Storage
+import SnapKit
+
+struct BackForwardViewUX {
+    static let RowHeight: CGFloat = 50
+    static let BackgroundColor = UIColor(rgb: 0xf9f9fa).withAlphaComponent(0.4)
+}
+
+class BackForwardListViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, UIGestureRecognizerDelegate {
+
+    fileprivate let BackForwardListCellIdentifier = "BackForwardListViewController"
+    fileprivate var profile: Profile
+    fileprivate lazy var sites = [String: Site]()
+    fileprivate var dismissing = false
+    fileprivate var currentRow = 0
+    fileprivate var verticalConstraints: [Constraint] = []
+    
+    lazy var tableView: UITableView = {
+        let tableView = UITableView()
+        tableView.separatorStyle = .none
+        tableView.dataSource = self
+        tableView.delegate = self
+        tableView.alwaysBounceVertical = false
+        tableView.register(BackForwardTableViewCell.self, forCellReuseIdentifier: self.BackForwardListCellIdentifier)
+        tableView.backgroundColor = BackForwardViewUX.BackgroundColor
+        let blurEffect = UIBlurEffect(style: .extraLight)
+        let blurEffectView = UIVisualEffectView(effect: blurEffect)
+        tableView.backgroundView = blurEffectView
+        
+        return tableView
+    }()
+    
+    lazy var shadow: UIView = {
+        let shadow = UIView()
+        shadow.backgroundColor = UIColor(white: 0, alpha: 0.2)
+        return shadow
+    }()
+    
+    var tabManager: TabManager!
+    weak var bvc: BrowserViewController?
+    var currentItem: WKBackForwardListItem?
+    var listData = [WKBackForwardListItem]()
+
+    var tableHeight: CGFloat {
+        get {
+            assert(Thread.isMainThread, "tableHeight interacts with UIKit components - cannot call from background thread.")
+            return min(BackForwardViewUX.RowHeight * CGFloat(listData.count), self.view.frame.height/2)
+        }
+    }
+    
+    var backForwardTransitionDelegate: UIViewControllerTransitioningDelegate? {
+        didSet {
+            self.transitioningDelegate = backForwardTransitionDelegate
+        }
+    }
+    
+    var snappedToBottom: Bool = true
+    
+    init(profile: Profile, backForwardList: WKBackForwardList) {
+        self.profile = profile
+        super.init(nibName: nil, bundle: nil)
+        
+        loadSites(backForwardList)
+        loadSitesFromProfile()
+    }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.addSubview(shadow)
+        view.addSubview(tableView)
+        snappedToBottom = bvc?.toolbar != nil
+        tableView.snp.makeConstraints { make in
+            make.height.equalTo(0)
+            make.left.right.equalTo(self.view)
+        }
+        shadow.snp.makeConstraints { make in
+            make.left.right.equalTo(self.view)
+        }
+        remakeVerticalConstraints()
+        view.layoutIfNeeded()
+        scrollTableViewToIndex(currentRow)
+        setupDismissTap()
+    }
+    
+    func loadSitesFromProfile() {
+        let sql = profile.favicons as! SQLiteHistory
+        let urls = listData.flatMap {$0.url.isLocal ? $0.url.getQuery()["url"]?.unescape() : $0.url.absoluteString}
+
+        sql.getSitesForURLs(urls).uponQueue(.main) { result in
+            guard let results = result.successValue else {
+                return
+            }
+            // Add all results into the sites dictionary
+            results.flatMap({$0}).forEach({site in
+                if let url = site?.url {
+                    self.sites[url] = site
+                }
+            })
+            self.tableView.reloadData()
+        }
+    }
+
+    func homeAndNormalPagesOnly(_ bfList: WKBackForwardList) {
+        let items = bfList.forwardList.reversed() + [bfList.currentItem].flatMap({$0}) + bfList.backList.reversed()
+        
+        //error url's are OK as they are used to populate history on session restore.
+        listData = items.filter({return !($0.url.isLocal && ($0.url.originalURLFromErrorURL?.isLocal ?? true)) || $0.url.isAboutHomeURL})
+    }
+    
+    func loadSites(_ bfList: WKBackForwardList) {
+        currentItem = bfList.currentItem
+        
+        homeAndNormalPagesOnly(bfList)
+    }
+    
+    func scrollTableViewToIndex(_ index: Int) {
+        guard index > 1 else {
+            return
+        }
+        let moveToIndexPath = IndexPath(row: index-2, section: 0)
+        tableView.reloadRows(at: [moveToIndexPath], with: .none)
+        tableView.scrollToRow(at: moveToIndexPath, at: UITableViewScrollPosition.middle, animated: false)
+    }
+    
+    override func willTransition(to newCollection: UITraitCollection, with coordinator: UIViewControllerTransitionCoordinator) {
+        super.willTransition(to: newCollection, with: coordinator)
+        guard let bvc = self.bvc else {
+            return
+        }
+        if bvc.shouldShowFooterForTraitCollection(newCollection) != snappedToBottom {
+            tableView.snp.updateConstraints { make in
+                if snappedToBottom {
+                    make.bottom.equalTo(self.view).offset(0)
+                } else {
+                    make.top.equalTo(self.view).offset(0)
+                }
+                make.height.equalTo(0)
+            }
+            snappedToBottom = !snappedToBottom
+        }
+    }
+    
+    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
+        super.viewWillTransition(to: size, with: coordinator)
+        let correctHeight = {
+            self.tableView.snp.updateConstraints { make in
+                make.height.equalTo(min(BackForwardViewUX.RowHeight * CGFloat(self.listData.count), size.height / 2))
+            }
+        }
+        coordinator.animate(alongsideTransition: nil) { _ in
+            self.remakeVerticalConstraints()
+            correctHeight()
+        }
+    }
+    
+    func remakeVerticalConstraints() {
+        guard let bvc = self.bvc else {
+            return
+        }
+        for constraint in self.verticalConstraints {
+            constraint.deactivate()
+        }
+        self.verticalConstraints = []
+        tableView.snp.makeConstraints { make in
+            if snappedToBottom {
+                verticalConstraints += [make.bottom.equalTo(self.view).offset(-bvc.footer.frame.height).constraint]
+            } else {
+                verticalConstraints += [make.top.equalTo(self.view).offset(bvc.header.frame.height + UIApplication.shared.statusBarFrame.size.height).constraint]
+            }
+        }
+        shadow.snp.makeConstraints() { make in
+            if snappedToBottom {
+                verticalConstraints += [
+                    make.bottom.equalTo(tableView.snp.top).constraint,
+                    make.top.equalTo(self.view).constraint
+                ]
+                
+            } else {
+                verticalConstraints += [
+                    make.top.equalTo(tableView.snp.bottom).constraint,
+                    make.bottom.equalTo(self.view).constraint
+                ]
+            }
+        }
+    }
+
+    func setupDismissTap() {
+        let tap = UITapGestureRecognizer(target: self, action: #selector(BackForwardListViewController.handleTap))
+        tap.cancelsTouchesInView = false
+        tap.delegate = self
+        view.addGestureRecognizer(tap)
+    }
+    
+    func handleTap() {
+        dismiss(animated: true, completion: nil)
+    }
+    
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+        if touch.view?.isDescendant(of: tableView) ?? true {
+            return false
+        }
+        return true
+    }
+    
+    required init?(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    // MARK: - Table view
+    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+        return listData.count
+    }
+    
+    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+        let cell = self.tableView.dequeueReusableCell(withIdentifier: BackForwardListCellIdentifier, for: indexPath) as! BackForwardTableViewCell
+        let item = listData[indexPath.item]
+        let urlString = item.url.isLocal ? item.url.getQuery()["url"]?.unescape() : item.url.absoluteString
+        
+        cell.isCurrentTab = listData[indexPath.item] == self.currentItem
+        cell.connectingBackwards = indexPath.item != listData.count-1
+        cell.connectingForwards = indexPath.item != 0
+
+        guard let url = urlString, !item.url.isAboutHomeURL else {
+            cell.site = Site(url: item.url.absoluteString, title: Strings.FirefoxHomePage)
+            return cell
+        }
+
+        cell.site = sites[url] ?? Site(url: url, title: item.title ?? "")
+        cell.setNeedsDisplay()
+        
+        return cell
+    }
+
+    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
+        tabManager.selectedTab?.goToBackForwardListItem(listData[indexPath.item])
+        dismiss(animated: true, completion: nil)
+    }
+    
+    func tableView(_ tableView: UITableView, heightForRowAt  indexPath: IndexPath) -> CGFloat {
+        return BackForwardViewUX.RowHeight
+    }
+}