(passwordView: T) where T : IHPPasswordView {
136 |
137 | }
138 |
139 | }
140 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPDebugKit/resources/guide.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Rrerequisite
28 |
30 |
1.This plugin only support storyboard
31 | 2.This plugin's initial viewcontroller must be a navigation controller
32 | 3.This plugin's root viewcontroller must be HDKRootViewController
33 |
34 |
35 | How to apply self-defined theme or config to this plugin
36 | First implement the ADKTheme or ADKConfig protocol, then set it to HDKContext singleton before using this plugin
38 |
39 | Descriptions of ADKTheme's parameters
40 | Default theme is ADKDefaultTheme
42 |
43 |
44 | Var. Description
45 |
46 |
47 | description -
48 |
49 |
50 | mainColor background color of floating button and all viewcontrollers' navigation bar initialized by applying method applyADKNavigationBar of UIViewController extension
51 |
52 |
53 | fontColor text color of all texts on build-in viewcontroller's navigation bar
54 |
55 |
56 | floatingButtonSize -
57 |
58 |
59 | floatingButtonText -
60 |
61 |
62 | floationButtonTextColor -
63 |
64 |
65 | floationButtonFontSize -
66 |
67 |
68 |
69 | Descriptions of ADKConfig's parameters
70 | Default config is ADKDefaultConfig
72 |
73 |
74 | Var. Description
75 |
76 |
77 | storyboardName_phone storyboard file name of iPhone,leave empty if current device is iPad
78 |
79 |
80 | storyboardName_pad storyboard file name of iPad,leave empty if current device is iPhone
81 |
82 |
83 | rootPageConfigFileName config file name of plugin's root viewcontroller
84 |
85 |
86 | settingPageConfigFileName config file name of plugin's setting viewcontroller
87 |
88 |
89 | storyboardName storyboard name of current platform
90 |
91 |
92 | storyboard storyboard instance of current platform
93 |
94 |
95 | rootPageCellReuseID -
96 |
97 |
98 | defaultItems default build-in items, like guideItem and settingItem
99 |
100 |
101 |
102 | Description of root config file
103 | Demo file : HDKRootConfig.plist
105 |
106 |
107 |
108 |
109 | Field Required Type Comment
110 |
111 |
112 | title true String cell item title
113 |
114 |
115 | segueID false String segue identifier of cell click action in the plugin storyboard
116 |
117 |
118 | controllerName false String full classname of the viewcontroller you want to push without storyboard, like AnwDebugKitDemo.HDKTest2ViewController
119 |
120 |
121 | controllerID false String controller id in the external storyboard
122 |
123 |
124 | controllerContainer false String name of the external storyboard which holds the viewcontroller you want to push
125 |
126 |
127 |
128 | Description of setting config file
129 | Demo file : HDKSettingConfig.plist
131 |
132 |
133 |
134 | Field Required Type Comment
135 |
136 |
137 | title true String cell item title
138 |
139 |
140 | type true String
141 | one cell type of below:
148 |
149 |
150 | action false String string name of the selector which will response to the cell action
151 |
152 |
153 | defaultValue false String string name of the selector which will response to the cell default value action
154 |
155 |
156 | How to register a event handler of setting viewcontroller
157 | First implement a class which contains all the selectors defined in setting config file, refer to demo class HDKSettingEventHandler , then register it using ADKSettingCellEventCenter.register(eventHandler: HDKSettingEventHandler.init())
159 |
160 | Selector name of a selector
161 |
164 | selector selector name func testSelector1() -> Any testSelector1 func testSelector2(_ param: Any) -> Any testSelector2: func testSelector3(with param: Any) -> Any testSelector3With: func testSelector4(with param1: Any, and param2: Any) -> Any testSelector4With:and:
170 |
171 |
172 |
173 |
--------------------------------------------------------------------------------
/HPPluginRepo/Common/HPExts.swift:
--------------------------------------------------------------------------------
1 | //
2 | // AnwExts.swift
3 | // HPPluginRepo
4 | //
5 | // Created by Hu, Peng on 30/11/2017.
6 | // Copyright © 2017 Hu, Peng. All rights reserved.
7 | //
8 |
9 | import Foundation
10 | import UIKit
11 |
12 | extension Float {
13 | static func == (lhs: Float, rhs: Float) -> Bool {
14 | return fabsf(rhs - lhs) < Float.ulpOfOne
15 | }
16 | static func != (lhs: Float, rhs: Float) -> Bool {
17 | return fabsf(rhs - lhs) >= Float.ulpOfOne
18 | }
19 | }
20 |
21 | //extension Date {
22 | // func beginDateOfThisWeek() -> Date {
23 | // let calendar = Calendar(identifier:.gregorian)
24 | // let d = calendar.component(.weekday, from: self)
25 | // return self
26 | //// return self.addingTimeInterval(<#T##timeInterval: TimeInterval##TimeInterval#>)
27 | // }
28 | // func endDateOfThisWeek() -> Date {
29 | // return self
30 | // }
31 | //}
32 |
33 | extension CGPoint {
34 | func add(_ point: CGPoint) -> CGPoint {
35 | return CGPoint(x: self.x + point.x, y: self.y + point.y)
36 | }
37 |
38 | func divide(by point: CGPoint) -> CGPoint {
39 | return CGPoint(x: self.x / point.x, y: self.y / point.y)
40 | }
41 |
42 | func restricted(to bound: CGRect) -> CGPoint {
43 | var x = self.x
44 | var y = self.y
45 | x = max(x, bound.minX)
46 | x = min(x, bound.maxX)
47 | y = max(y, bound.minY)
48 | y = min(y, bound.maxY)
49 | return CGPoint(x: x, y: y)
50 | }
51 |
52 | func slope(with point: CGPoint) -> Float {
53 | return Float((self.y - point.y) / (self.x - point.x))
54 | }
55 | }
56 |
57 | extension CGRect {
58 | static func rectOfCircle(center:CGPoint, radius: CGFloat) -> CGRect {
59 | return CGRect(x: center.x - radius, y: center.y - radius, width: 2 * radius, height: 2 * radius)
60 | }
61 |
62 | var center: CGPoint {
63 | return CGPoint(x: self.width/2.0 + self.origin.x, y: self.height/2.0 + self.origin.y)
64 | }
65 |
66 | static func rect(with center: CGPoint, size: CGSize) -> CGRect {
67 | let origin = CGPoint(x: center.x - size.width * 0.5, y: center.y - size.height * 0.5)
68 | return CGRect(origin: origin, size: size)
69 | }
70 | }
71 |
72 | extension UIViewController {
73 |
74 | func quickAdd(childViewController: UIViewController) {
75 | childViewController.willMove(toParentViewController: self)
76 | self.view.addSubview(childViewController.view)
77 | self.addChildViewController(childViewController)
78 | childViewController.didMove(toParentViewController: self)
79 | }
80 |
81 | func quickRemove(childViewController: UIViewController) {
82 | childViewController.willMove(toParentViewController: nil)
83 | childViewController.view.removeFromSuperview()
84 | childViewController.removeFromParentViewController()
85 | childViewController.didMove(toParentViewController: nil)
86 |
87 | }
88 |
89 | static func loadFromStoryboard(_ storyboardName: String? = nil ,with identifier: String?=nil) -> UIViewController {
90 |
91 | let _identifier = identifier == nil ? self.nameOfClass : identifier
92 | var sb = UIStoryboard.default()
93 | if storyboardName != nil {
94 | sb = UIStoryboard.init(name: storyboardName!, bundle: nil)
95 | }
96 |
97 | return sb.instantiateViewController(withIdentifier:_identifier!)
98 | }
99 | }
100 |
101 | extension UIStoryboard {
102 |
103 | static func `default`() -> UIStoryboard {
104 | let infoKey = UIDevice.isPhone() ? "UIMainStoryboardFile~iphone" : "UIMainStoryboardFile~ipad"
105 | var value: String? = Bundle.main.object(forInfoDictionaryKey: infoKey) as? String
106 | value = value ?? "Main"
107 | return UIStoryboard(name: value!, bundle: Bundle.main)
108 | }
109 | }
110 |
111 | extension UIDevice {
112 | static func isPhone() -> Bool {
113 | return UIDevice.current.model == "iPhone"
114 | }
115 | }
116 |
117 | extension NSObject {
118 | class var nameOfClass: String{
119 | return NSStringFromClass(self).components(separatedBy: ".").last!
120 | }
121 |
122 | var nameOfClass: String {
123 | return NSStringFromClass(self as! AnyClass).components(separatedBy: ".").last!
124 | }
125 | }
126 |
127 | extension Float {
128 | static var random099: Float {
129 | return Float(arc4random()%100)/100.0
130 | }
131 | }
132 |
133 | extension UIColor {
134 | static var randomColor: UIColor {
135 | return UIColor(red: CGFloat(Float.random099), green: CGFloat(Float.random099), blue: CGFloat(Float.random099), alpha: 1.0)
136 | }
137 | static func color01(from tuple: (r: CGFloat, g: CGFloat, b: CGFloat, a: CGFloat)) -> UIColor {
138 | return UIColor(red: tuple.r, green: tuple.g, blue: tuple.b, alpha: tuple.a)
139 | }
140 | static func color255(from tuple: (r: CGFloat, g: CGFloat, b: CGFloat, a: CGFloat)) -> UIColor {
141 | return UIColor(red: tuple.r/255.0, green: tuple.g/255.0, blue: tuple.b/255.0, alpha: tuple.a)
142 | }
143 |
144 | static func colorFrom(hex: String, with alpha: CGFloat = 1.0) -> UIColor {
145 |
146 | /*
147 | * legnth of hex string should be 6 or 8
148 | */
149 | guard hex.count == 6 || hex.count == 8 else {
150 | return UIColor.gray
151 | }
152 |
153 | var cString: String = hex.uppercased()
154 |
155 | if cString.hasPrefix("0X") {
156 | let index = cString.index(cString.startIndex, offsetBy: 2)
157 | cString = String(cString[index...])
158 | }
159 |
160 | guard cString.count == 6 else {
161 | return UIColor.gray
162 | }
163 | var fromIndex = hex.index(hex.startIndex, offsetBy: 0)
164 | var toIndex = hex.index(hex.startIndex, offsetBy: 2)
165 | let rStr = String(cString[fromIndex..()
12 |
13 | public class ADKSettingCellEventCenter {
14 |
15 | public static let sharedInstance = ADKSettingCellEventCenter()
16 |
17 | private init() {}
18 |
19 | public static func register(eventHandler : NSObject) {
20 |
21 | for handler in _eventHandlers {
22 | if type(of: handler) === type(of: eventHandler) {
23 | return
24 | }
25 | }
26 | _eventHandlers.append(eventHandler)
27 | }
28 |
29 | @discardableResult
30 | func handleEvent(with selectorName: String, params: Any? = nil, callback:((AnyObject?) -> Swift.Void)? = nil) -> Unmanaged! {
31 |
32 | let selector = NSSelectorFromString(selectorName)
33 | for eventHandler in _eventHandlers {
34 | if !eventHandler.responds(to: selector) {
35 | continue
36 | }
37 |
38 | if callback != nil {
39 | DispatchQueue.global(qos: .userInitiated).async {
40 | // TBD : may cause some leak if result is a retained object
41 | let result = eventHandler.perform(selector) != nil ? eventHandler.perform(selector).takeUnretainedValue() : nil
42 | DispatchQueue.main.async {
43 | callback!(result)
44 | }
45 | }
46 | return nil
47 | } else {
48 | return eventHandler.perform(selector, with: params)
49 | }
50 |
51 | }
52 | return nil
53 | }
54 | }
55 |
56 | class ADKSettingCell: UITableViewCell, UITextFieldDelegate {
57 | @IBOutlet weak var titleLabel: UILabel!
58 | @IBOutlet weak var switchControl: UISwitch!
59 | @IBOutlet weak var sliderControl: UISlider!
60 | @IBOutlet weak var textField: UITextField!
61 | @IBOutlet weak var indicatorView: UIActivityIndicatorView!
62 | private var cellItem: ADKSettingCellItem?
63 |
64 | @IBAction func valueChanged(_ sender: AnyObject) {
65 | var value = NSNumber(value: 0)
66 | if let control = sender as? UISwitch {
67 | value = NSNumber(value: control.isOn)
68 | } else if let control = sender as? UISlider {
69 | value = NSNumber(value: control.value)
70 | }
71 | ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem!.action!, params: value)
72 |
73 | }
74 |
75 | override func prepareForReuse() {
76 | super.prepareForReuse()
77 | }
78 |
79 | func configCell(with cellItem: ADKSettingCellItem) {
80 | self.cellItem = cellItem
81 | if titleLabel != nil {
82 | if cellItem.varTitle != nil {
83 | let title = ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem.varTitle!).takeUnretainedValue() as! String
84 | titleLabel.text = title
85 | } else {
86 | titleLabel.text = cellItem.title
87 | }
88 | }
89 |
90 | switch cellItem.type! {
91 | case .inputValue:
92 | let placeHolder = ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem.defaultValue!).takeUnretainedValue() as! String
93 | textField.text = placeHolder
94 | case .switchValue:
95 | let isOn = ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem.defaultValue!).takeUnretainedValue() as! NSNumber
96 | switchControl.isOn = isOn.boolValue
97 | case .sliderValue:
98 | let value = ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem.defaultValue!).takeUnretainedValue() as! NSNumber
99 | sliderControl.value = value.floatValue
100 | case .async:
101 | cellItem.processing ? indicatorView.startAnimating() : indicatorView.stopAnimating()
102 | default:
103 | break
104 | }
105 | }
106 |
107 | func handleEvent() {
108 | switch cellItem!.type! {
109 | case .async:
110 | cellItem!.processing = true
111 | indicatorView.startAnimating()
112 | ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem!.action!, callback:{
113 | [unowned self] (result) in
114 | self.indicatorView.stopAnimating()
115 | })
116 | case .detail:
117 | ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem!.action!)
118 | default:
119 | break
120 | }
121 | }
122 |
123 | func textFieldDidEndEditing(_ textField: UITextField, reason: UITextFieldDidEndEditingReason) {
124 | ADKSettingCellEventCenter.sharedInstance.handleEvent(with: cellItem!.action!, params: textField.text)
125 | }
126 | }
127 |
128 |
129 | class HDKSettingViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
130 | private let config = HDKContext.shared.config
131 | private lazy var items: (sections: Array, rows: Array>) = ADKSettingCellItem.parse(file: config.settingPageConfigFileName)
132 |
133 | override func viewDidLoad() {
134 | super.viewDidLoad()
135 | }
136 |
137 | override var preferredStatusBarStyle: UIStatusBarStyle {
138 | return UIStatusBarStyle.lightContent
139 | }
140 |
141 | @IBAction func dismissBtnClicked(_ sender: Any) {
142 | HDKFloatingButton.shrink()
143 | }
144 |
145 | @IBAction func backBtnClicked(_ sender: Any) {
146 | self.navigationController?.popViewController(animated: true)
147 | }
148 |
149 | func numberOfSections(in tableView: UITableView) -> Int {
150 | return items.sections.count
151 | }
152 |
153 | func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
154 | let section = items.sections[section]
155 | return section.title
156 | }
157 |
158 |
159 | func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
160 | let rows = items.rows
161 | return rows[section].count
162 | }
163 |
164 | func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
165 | let rows = items.rows[indexPath.section]
166 | let item = rows[indexPath.row]
167 | let cell = tableView.dequeueReusableCell(withIdentifier: item.type!.rawValue) as! ADKSettingCell
168 | cell.configCell(with: item)
169 | return cell
170 | }
171 |
172 | func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
173 | let cell = tableView.cellForRow(at: indexPath) as! ADKSettingCell
174 | cell.handleEvent()
175 | }
176 | }
177 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPDebugKit/HDKFloatingButton.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HDKFloatingButton.swift
3 | // AnwDebugKitDemo
4 | //
5 | // Created by Hu, Peng on 23/10/2017.
6 | // Copyright © 2017 Hu, Peng. All rights reserved.
7 | //
8 |
9 | import UIKit
10 |
11 | public let HDKFloatingButtonShrinkNotifName = Notification.Name("HDKFloatingButtonShrinkNotifName")
12 | public let HDKFloatingButtonExpandNotifName = Notification.Name("HDKFloatingButtonExpandNotifName")
13 |
14 |
15 |
16 | public class HDKFloatingButton: UIWindow {
17 |
18 | class ADKPlaceHolderViewController : UIViewController {
19 | override var preferredStatusBarStyle: UIStatusBarStyle {
20 | return UIStatusBarStyle.lightContent
21 | }
22 | }
23 |
24 | public var isShow = false
25 |
26 | static let sharedInstance = HDKFloatingButton(frame: UIScreen.main.bounds)
27 | static let holdOnDuration: TimeInterval = 10.0
28 | private var activeTime: NSDate?
29 | private var panCenter: CGPoint?
30 | private var isExpand = false
31 | private let control: UILabel = UILabel()
32 | private let theme = HDKContext.shared.theme
33 | private let config = HDKContext.shared.config
34 |
35 | private let placeHolder = ADKPlaceHolderViewController()
36 |
37 | private override init(frame: CGRect) {
38 |
39 | super.init(frame: frame)
40 | let insets = self.safeAreaInsets
41 | // init floating button
42 | control.frame = CGRect(origin: CGPoint(x: insets.left, y: insets.top), size: HDKContext.shared.theme.floatingButtonSize)
43 | control.backgroundColor = theme.floationButtonColor
44 | control.text = theme.floatingButtonText
45 | control.textAlignment = NSTextAlignment.center
46 | control.textColor = theme.floationButtonTextColor
47 | control.font = UIFont.boldSystemFont(ofSize: theme.floationButtonFontSize)
48 | control.layer.cornerRadius = theme.floatingButtonSize.width * 0.5
49 | control.adjustsFontSizeToFitWidth = true
50 | control.clipsToBounds = true
51 | self.addSubview(control)
52 |
53 | // add gesture handlers
54 | let tapGesture = UITapGestureRecognizer(target: self, action: #selector(tap(_:)))
55 | control.addGestureRecognizer(tapGesture)
56 | let panGesture = UIPanGestureRecognizer(target: self, action: #selector(pan(_:)))
57 | control.addGestureRecognizer(panGesture)
58 |
59 | self.rootViewController = placeHolder
60 | }
61 |
62 | public override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
63 | if(self.rootViewController!.isKind(of: UINavigationController.self)) {
64 | return super.hitTest(point, with: event)
65 | } else if (control.frame.contains(point)) {
66 | return control
67 | } else {
68 | return nil
69 | }
70 | }
71 |
72 | required public init?(coder aDecoder: NSCoder) {
73 | super.init(coder: aDecoder)
74 | }
75 |
76 | // gesture handlers
77 | @objc
78 | func tap(_ sender: UIGestureRecognizer) {
79 | if isExpand {
80 | shrink()
81 | } else {
82 | expand()
83 | }
84 | }
85 | @objc
86 | func pan(_ sender: UIPanGestureRecognizer) {
87 |
88 | let point = __CGPointApplyAffineTransform(sender.translation(in: self), self.transform)
89 | let w = self.bounds.width
90 | let h = self.bounds.height
91 | let controlHalfW = control.bounds.width * 0.5
92 | activeTime = NSDate()
93 |
94 | if sender.state == UIGestureRecognizerState.began {
95 | panCenter = control.center
96 | } else if sender.state == UIGestureRecognizerState.changed {
97 | control.center = panCenter!.add(point).restricted(to: self.bounds.insetBy(dx: controlHalfW, dy: controlHalfW))
98 | } else {
99 | let pinLeft = control.center.divide(by: CGPoint(x: w, y: h)).x <= 0.5
100 | let controlY = control.center.y
101 | UIView.animate(withDuration: 0.25, delay: 0.0, usingSpringWithDamping: 0.5, initialSpringVelocity: 0.2, options: UIViewAnimationOptions(rawValue: 0x01), animations: {
102 | [unowned self] in
103 |
104 | if pinLeft {
105 | self.control.center = CGPoint(x: controlHalfW, y: controlY)
106 | self.control.autoresizingMask = UIViewAutoresizing(rawValue: UIViewAutoresizing.flexibleRightMargin.rawValue | UIViewAutoresizing.flexibleTopMargin.rawValue | UIViewAutoresizing.flexibleBottomMargin.rawValue )
107 |
108 | } else {
109 | self.control.center = CGPoint(x: w - controlHalfW, y: controlY)
110 | self.control.autoresizingMask = UIViewAutoresizing(rawValue: UIViewAutoresizing.flexibleLeftMargin.rawValue | UIViewAutoresizing.flexibleTopMargin.rawValue | UIViewAutoresizing.flexibleBottomMargin.rawValue )
111 | }
112 |
113 | }, completion: { [unowned self](finished) in
114 | self.perform(#selector(HDKFloatingButton.resignActive), with: nil, afterDelay: HDKFloatingButton.holdOnDuration)
115 | })
116 | }
117 | }
118 |
119 | // private methods
120 | func expand() {
121 |
122 | let scaleRatio = min(self.bounds.width/control.bounds.width, self.bounds.height/control.bounds.height)
123 |
124 | UIView.animate(withDuration: 0.15, animations: {
125 | [unowned self] in
126 | self.control.transform = CGAffineTransform.init(scaleX: scaleRatio, y: scaleRatio)
127 | self.control.alpha = 0.0;
128 |
129 | }) { [unowned self](finished) in
130 | let sb = self.config.storyboard
131 | let rootVC = sb.instantiateInitialViewController()
132 |
133 | assert(rootVC != nil, "storyboard \(self.config.storyboardName) must have a root viewcontroller")
134 | assert(rootVC!.isKind(of: UINavigationController.self), "root view controller of storyboard \(self.config.storyboardName) must be a navigation controller")
135 |
136 | self.rootViewController = rootVC
137 |
138 | self.isExpand = !self.isExpand
139 | NotificationCenter.default.post(name: HDKFloatingButtonExpandNotifName, object: nil)
140 | }
141 | }
142 | func shrink() {
143 | self.rootViewController = placeHolder
144 | UIView.animate(withDuration: 0.15, animations: {
145 | [unowned self] in
146 | self.control.transform = CGAffineTransform.identity
147 | self.control.alpha = 1.0
148 | }) { [unowned self](finised) in
149 | self.isExpand = !self.isExpand
150 |
151 | NotificationCenter.default.post(name: HDKFloatingButtonShrinkNotifName, object: nil)
152 | }
153 | }
154 |
155 | func shift() {
156 | isShow = !isShow
157 | if isShow {
158 | self.makeKeyAndVisible()
159 | self.perform(#selector(HDKFloatingButton.resignActive), with: nil, afterDelay: HDKFloatingButton.holdOnDuration)
160 | } else {
161 | UIApplication.shared.delegate?.window??.makeKeyAndVisible()
162 | }
163 | }
164 |
165 | @objc
166 | func resignActive() {
167 | // if activeTime == nil || activeTime!.timeIntervalSinceNow < -5 {
168 | // control.center = CGPoint(x: 0, y: control.center.y)
169 | // }
170 | }
171 |
172 | // public APIS
173 | public static func shift() {
174 | HDKFloatingButton.sharedInstance.shift()
175 | }
176 | public static func expand() {
177 | HDKFloatingButton.sharedInstance.expand()
178 | }
179 | public static func shrink() {
180 | HDKFloatingButton.sharedInstance.shrink()
181 | }
182 | }
183 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPPasswordPlugin/BuildInViews/HPSimplePasscodeView.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HPSimplePasscodeView.swift
3 | // HPPluginRepo
4 | //
5 | // Created by Hu, Peng on 22/12/2017.
6 | // Copyright © 2017 Hu, Peng. All rights reserved.
7 | //
8 |
9 | import UIKit
10 |
11 | class HPPasscodeInputViewCursor: UIView {
12 |
13 | private var _show = false
14 | var show: Bool {
15 | set(newValue) {
16 | _show = newValue
17 | if newValue {
18 | timer.fire()
19 | } else {
20 | timer.invalidate()
21 | self.isHidden = true
22 | }
23 | }
24 | get {
25 |
26 | return _show
27 | }
28 | }
29 | var _timer: Timer?
30 |
31 | var timer: Timer {
32 | if _timer == nil || !_timer!.isValid {
33 | _timer = Timer.scheduledTimer(withTimeInterval: 0.4, repeats: true) { (t) in
34 | self.isHidden = !self.isHidden
35 | }
36 | }
37 | return _timer!
38 | }
39 | }
40 |
41 | @IBDesignable class HPPasscodeInputView: UIView {
42 |
43 | enum BorderMask: Int {
44 | case none = 0
45 | case top = 1
46 | case right = 2
47 | case bottom = 4
48 | case left = 8
49 | case all = 15
50 | }
51 |
52 | @IBInspectable var borderColor: UIColor = UIColor.color255(from: (r: 12.0, g: 81.0, b: 149, a: 1.0))
53 | @IBInspectable var errorColor: UIColor = UIColor.color255(from: (r: 255.0, g: 78.0, b: 78.0, a: 1.0))
54 | @IBInspectable var borderWidth: CGFloat = 1
55 | @IBInspectable var borderMask: Int = BorderMask.all.rawValue
56 |
57 | @IBOutlet weak var cursor: HPPasscodeInputViewCursor!
58 | @IBOutlet weak var titleLabel: UILabel!
59 |
60 | private var _selected: Bool = false;
61 | private var _text: String?
62 |
63 | var showError: Bool = false
64 |
65 | var selected: Bool {
66 | get {
67 | return _selected
68 | }
69 | set(newValue) {
70 | cursor.show = newValue
71 | _selected = newValue
72 | }
73 | }
74 |
75 | var text: String? {
76 | get {
77 | return _text
78 | }
79 | set(newValue) {
80 |
81 | _text = newValue
82 | titleLabel.text = newValue
83 | }
84 | }
85 |
86 | override func awakeFromNib() {
87 | super.awakeFromNib()
88 | self.selected = false
89 | }
90 |
91 | override func draw(_ rect: CGRect) {
92 | super.draw(rect)
93 | let w = rect.width
94 | let h = rect.height
95 | let context = UIGraphicsGetCurrentContext()!
96 | context.setStrokeColor(showError ? errorColor.cgColor : borderColor.cgColor)
97 | context.setLineWidth(borderWidth)
98 | if borderMask | BorderMask.top.rawValue > 0 {
99 | context.move(to: CGPoint.zero)
100 | context.addLine(to: CGPoint(x: w, y: 0))
101 | context.strokePath()
102 | context.saveGState()
103 | }
104 |
105 | if borderMask | BorderMask.right.rawValue > 0 {
106 | context.move(to: CGPoint(x: w, y: 0))
107 | context.addLine(to: CGPoint(x: w, y: h))
108 | context.strokePath()
109 | context.saveGState()
110 | }
111 |
112 | if borderMask | BorderMask.bottom.rawValue > 0 {
113 | context.move(to: CGPoint(x: w, y: h))
114 | context.addLine(to: CGPoint(x: 0, y: h))
115 | context.strokePath()
116 | context.saveGState()
117 | }
118 |
119 | if borderMask | BorderMask.left.rawValue > 0 {
120 | context.move(to: CGPoint(x: 0, y: h))
121 | context.addLine(to: CGPoint(x: 0, y: 0))
122 | context.strokePath()
123 | context.saveGState()
124 | }
125 | }
126 | }
127 |
128 | class HPSimplePasscodeViewStorage: NSObject, IHPPasswordStorage {
129 |
130 | static let passwordKey = "com.hpDemo.simplePasswordView.key"
131 |
132 | let defaultStorage = UserDefaults.standard
133 | var _password: String?
134 | var password: String? {
135 | if _password == nil {
136 | _password = defaultStorage.string(forKey: HPSimplePasscodeViewStorage.passwordKey)
137 | }
138 | return _password
139 | }
140 |
141 | func save(password: String) {
142 | defaultStorage.set(password, forKey: HPSimplePasscodeViewStorage.passwordKey)
143 | }
144 |
145 | func deletePassword() {
146 | defaultStorage.removeObject(forKey: HPSimplePasscodeViewStorage.passwordKey)
147 | }
148 | func validate(password: Any?) -> Bool {
149 | return true
150 | }
151 |
152 | func password(from: Any?) -> String? {
153 | guard let passcodeArr = from as? Array else {
154 | return nil
155 | }
156 | return passcodeArr.joined(separator: "-")
157 | }
158 | }
159 |
160 | @IBDesignable class HPSimplePasscodeView: UIView, IHPPasswordView, UITextFieldDelegate {
161 |
162 | @IBOutlet var inputViews: [HPPasscodeInputView]!
163 | @IBOutlet weak var textField: UITextField!
164 | private var enable: Bool = true
165 |
166 | var tmpPassword: Any? {
167 | get {
168 | return [inputViews[0].text, inputViews[1].text, inputViews[2].text, inputViews[3].text]
169 | }
170 | set(newValue) {
171 | guard let textArr = newValue as? Array else {
172 | return
173 | }
174 | inputViews[0].text = textArr[0]
175 | inputViews[1].text = textArr[1]
176 | inputViews[2].text = textArr[2]
177 | inputViews[3].text = textArr[3]
178 | }
179 |
180 | }
181 | var maxTryTime: Int {
182 | return 3
183 | }
184 | var status: HPPasswordViewStatus = .create
185 |
186 | var delegate: HPPasswordViewDelegate?
187 |
188 | private var _decorator: HPPasswordViewDecorator? = nil
189 |
190 | private var decorator: HPPasswordViewDecorator {
191 | if _decorator == nil {
192 | _decorator = HPPasswordViewDecorator(passwordView: self, storage: HPSimplePasscodeViewStorage())
193 | }
194 | return _decorator!
195 | }
196 |
197 | private var currentIndex = 0
198 | lazy private var leftTryTime = self.maxTryTime
199 |
200 |
201 | override func didMoveToSuperview() {
202 | super.didMoveToSuperview()
203 | textField.becomeFirstResponder()
204 | inputViews.first!.selected = true
205 | }
206 |
207 | @objc private func resetView() {
208 |
209 | for inputView in inputViews {
210 | inputView.text = nil
211 | inputView.selected = false
212 | inputView.showError = false
213 | inputView.setNeedsDisplay()
214 | }
215 | currentIndex = 0
216 | enable = true
217 | inputViews[currentIndex].selected = true
218 | }
219 |
220 | private func showErrorStatus() {
221 |
222 |
223 | inputViews[currentIndex].selected = false
224 | for inputView in inputViews {
225 | inputView.showError = true
226 | inputView.setNeedsDisplay()
227 | }
228 | }
229 |
230 | // MARK: - IHPPasswordView
231 | func passwordImage() -> UIImage? {
232 | return nil
233 | }
234 |
235 | func updateView(with change: HPPasswordViewStatusChange) {
236 | let toStatus = change.to
237 | leftTryTime = change.tryTimes
238 | enable = false
239 | if toStatus != .mismatch && toStatus != .invalid {
240 | perform(#selector(resetView), with: nil, afterDelay: 0.5)
241 | } else {
242 | showErrorStatus()
243 | perform(#selector(resetView), with: nil, afterDelay: 1)
244 | }
245 | }
246 |
247 | // MARK: - IHPPasswordView
248 | func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
249 |
250 | if !enable {
251 | return false
252 | }
253 |
254 | inputViews[currentIndex].text = string
255 | inputViews[currentIndex].selected = false
256 | currentIndex = (currentIndex + 1)%inputViews.count
257 | inputViews[currentIndex].selected = true
258 |
259 | if currentIndex == 0 {
260 | decorator.triggerStatusChange(HPPasswordViewStatusChange(from: self.status, to: .empty, tryTimes: self.leftTryTime))
261 | }
262 |
263 | return false
264 | }
265 | }
266 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPTaskManager/HPTaskManager.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HPTaskManager.swift
3 | // HPPluginRepo
4 | //
5 | // Created by 胡鹏 on 23/12/2017.
6 | // Copyright © 2017 Hu, Peng. All rights reserved.
7 | //
8 |
9 | import UIKit
10 |
11 | private func __HPTaskManagerDateFormatter() -> DateFormatter {
12 | let formatter = DateFormatter()
13 | formatter.dateFormat = "yyyy-MM-dd"
14 | formatter.calendar = Calendar.init(identifier: .gregorian)
15 | return formatter
16 | }
17 |
18 | enum HPTaskManagerError: Error {
19 | case duplicatedTask(key: String, user: String)
20 | case taskNotFound(key: String, user: String)
21 | case taskHasBeenCompleted(key: String, user: String)
22 | case taskInactive(key: String, user: String)
23 | case invalidParameter(message: String)
24 | }
25 |
26 | public class HPTaskManager {
27 |
28 | public typealias TaskTimeDuration = Array
29 | public typealias TaskTimeWeekdays = Int
30 | public typealias TaskTimeWeekday = Int
31 | public static let Monday: TaskTimeWeekday = 1 << 0
32 | public static let Tuesday: TaskTimeWeekday = 1 << 1
33 | public static let Wednesday: TaskTimeWeekday = 1 << 2
34 | public static let Thursday: TaskTimeWeekday = 1 << 3
35 | public static let Friday: TaskTimeWeekday = 1 << 4
36 | public static let Saturday: TaskTimeWeekday = 1 << 5
37 | public static let Sunday: TaskTimeWeekday = 1 << 6
38 |
39 | public enum TaskType: Int {
40 | /*
41 | * task can be registed anytime
42 | * task can be completed anytime
43 | */
44 | case normal
45 | /*
46 | * task will be refreshed everyday automatically
47 | */
48 | case daily
49 | /*
50 | * task will be achievable only on specified weekdays
51 | */
52 | case weekly
53 | /*
54 | * task can only be registed before the end date of the duration
55 | * task will be removed after the end date of the duration
56 | */
57 | case periodic
58 | }
59 |
60 | public struct TaskTimeArg {
61 | var duration: TaskTimeDuration?
62 | var weekdays: TaskTimeWeekdays?
63 |
64 | init(duration: TaskTimeDuration) throws {
65 | guard duration.count == 2 else {
66 | throw HPTaskManagerError.invalidParameter(message: "duration must has two date string element")
67 | }
68 | self.duration = duration
69 | }
70 | init(weekdays: TaskTimeWeekdays) {
71 | self.weekdays = weekdays
72 | }
73 | }
74 |
75 | public struct Task: Equatable {
76 |
77 | let type: TaskType
78 | let key : String
79 | var user: String
80 | let taskTimeArg: TaskTimeArg?
81 | var times: Int
82 | var leftTimes: Int
83 | // string of date & dateFormat = "yyyy-MM-dd"
84 | var updateTime: String
85 |
86 | init(type: TaskType = .normal,
87 | key: String,
88 | user: String = "com.hp.task.default.key",
89 | arg: TaskTimeArg? = nil,
90 | times: Int = 1) {
91 |
92 | self.type = type
93 | self.key = key
94 | self.user = user
95 | self.taskTimeArg = arg
96 | self.times = Task.taskIsActive(with: arg) ? times : 0
97 | self.leftTimes = times
98 | self.updateTime = Task.getLatestUpdateTime()
99 | }
100 | public static func weekDay(of date: Date) -> TaskTimeWeekday {
101 | let cal = Calendar.init(identifier: .gregorian)
102 | let weekDay = cal.component(.weekday, from: Date())
103 | switch weekDay {
104 | case 1:
105 | return HPTaskManager.Sunday
106 | case 2:
107 | return HPTaskManager.Monday
108 | case 3:
109 | return HPTaskManager.Tuesday
110 | case 4:
111 | return HPTaskManager.Wednesday
112 | case 5:
113 | return HPTaskManager.Thursday
114 | case 6:
115 | return HPTaskManager.Friday
116 | case 7:
117 | return HPTaskManager.Saturday
118 | default:
119 | return HPTaskManager.Sunday
120 | }
121 | }
122 |
123 | public static func taskIsActive(with arg: TaskTimeArg?) -> Bool {
124 | guard let taskTimeArg = arg else {
125 | return true
126 | }
127 | let today = Date()
128 | if taskTimeArg.duration != nil {
129 | let beginDate = taskTimeArg.duration![0]
130 | let endDate = taskTimeArg.duration![1]
131 | guard today.timeIntervalSince(beginDate) < 0 else {
132 | return false
133 | }
134 | guard today.timeIntervalSince(endDate) > 0 else {
135 | return false
136 | }
137 | } else if taskTimeArg.weekdays != nil {
138 | let today = weekDay(of: Date())
139 | return today | taskTimeArg.weekdays! > 0
140 | }
141 | return true
142 | }
143 | public static func getLatestUpdateTime() -> String {
144 | let formatter = __HPTaskManagerDateFormatter()
145 | return formatter.string(from: Date())
146 | }
147 | public static func == (lhs: Task, rhs: Task) -> Bool {
148 | return lhs.key == rhs.key && lhs.user == rhs.user
149 | }
150 | public static func != (lhs: Task, rhs: Task) -> Bool {
151 | return lhs.key != rhs.key || lhs.user != rhs.user
152 | }
153 | }
154 |
155 | static let `default` = HPTaskManager()
156 | private var tasks: Array = []
157 | private let persistence = UserDefaults.standard
158 | private let cacheKey = "com.HPTaskManager.tasks.cacheKey"
159 | private let threadSafeQueue = DispatchQueue(label: "com.HPTaskManager.threadSafeQ", attributes: .concurrent)
160 |
161 | private init() {
162 | loadTasks()
163 |
164 | NotificationCenter.default.addObserver(forName: NSNotification.Name.UIApplicationDidEnterBackground, object: self, queue: nil) { (notif) in
165 | self.saveTasks()
166 | }
167 | NotificationCenter.default.addObserver(forName: NSNotification.Name.UIApplicationWillTerminate, object: self, queue: nil) { (notif) in
168 | self.saveTasks()
169 | }
170 | }
171 |
172 | private func saveTasks() {
173 | persistence.set(tasks, forKey: cacheKey)
174 | }
175 |
176 | private func loadTasks() {
177 | let caches: Array = (persistence.object(forKey: cacheKey) as? Array) ?? []
178 | for t in caches {
179 | var task = t
180 | let type = task.type
181 | let today = Task.getLatestUpdateTime()
182 | if type == .normal {
183 | if task.leftTimes > 0 { // remove completed tasks
184 | tasks.append(task)
185 | }
186 | } else if type == .daily {
187 | if today != task.updateTime { // refresh daily task
188 | task.leftTimes = task.times
189 | task.updateTime = today
190 | }
191 | tasks.append(task)
192 | } else if type == .weekly {
193 | if today != task.updateTime { // refresh weekly task
194 | let isSpecifiedWeekday = Task.taskIsActive(with: task.taskTimeArg)
195 | task.leftTimes = isSpecifiedWeekday ? task.times : 0
196 | task.updateTime = today
197 | }
198 | tasks.append(task)
199 | } else if type == .periodic {
200 | let endDate = task.taskTimeArg!.duration![1]
201 | if Date().timeIntervalSince(endDate) <= 0 { // remove expired task
202 | tasks.append(task)
203 | }
204 | }
205 | }
206 |
207 | }
208 |
209 | public func register(task: Task) throws {
210 | let index = tasks.index(of: task)
211 | guard index == nil else {
212 | throw HPTaskManagerError.duplicatedTask(key: task.key, user: task.user)
213 | }
214 | tasks.append(task)
215 | }
216 |
217 | public func revoke(task: Task) throws {
218 | let index = tasks.index(of: task)
219 | guard let unwrappedIndex = index else {
220 | throw HPTaskManagerError.taskNotFound(key: task.key, user: task.user)
221 | }
222 | tasks.remove(at: unwrappedIndex)
223 | }
224 |
225 | public func complete( task: inout Task) throws {
226 | let index = tasks.index(of: task)
227 | guard index != nil else {
228 | throw HPTaskManagerError.taskNotFound(key: task.key, user: task.user)
229 | }
230 | guard Task.taskIsActive(with: task.taskTimeArg) != false else {
231 | throw HPTaskManagerError.taskInactive(key: task.key, user: task.user)
232 | }
233 | guard task.leftTimes > 0 else {
234 | throw HPTaskManagerError.taskHasBeenCompleted(key: task.key, user: task.user)
235 | }
236 | task.leftTimes -= 1
237 | }
238 |
239 | }
240 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPDebugKit/HDKContext.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ADKTheme.swift
3 | // AnwDebugKitDemo
4 | //
5 | // Created by Hu, Peng on 23/10/2017.
6 | // Copyright © 2017 Hu, Peng. All rights reserved.
7 | //
8 |
9 | import UIKit
10 |
11 | enum ADKError : Error {
12 | case invalidClassName(className: String)
13 | case invalidSelectorName(selectorName: String)
14 | }
15 |
16 | enum ADKCellType : String {
17 | case groupHeader = "ADKCellTypeGroupHeader"
18 | case plain = "ADKCellTypePlain"
19 | case detail = "ADKCellTypeDetail"
20 | case async = "ADKCellTypeAsync"
21 | case inputValue = "ADKCellTypeInput"
22 | case switchValue = "ADKCellTypeSwitch"
23 | case sliderValue = "ADKCellTypeSlider"
24 | }
25 |
26 | public struct ADKRootCellItem {
27 | var title: String? // ===> item title displayed on the cell
28 | var segueID: String? // ===> id of segue which connected to this controller in the root storyboard
29 | var controllerName: String? // ===> class name of this controller
30 | var controllerID: String? // ===> stoaryboard id of this controller
31 | // ===> stoaryboard name which contains this controller
32 | var controllerContainer : String? = HDKContext.shared.config.storyboardName
33 |
34 | func controller () throws -> UIViewController? {
35 | if controllerName != nil {
36 | guard let clz = NSClassFromString(controllerName!) else {
37 | throw ADKError.invalidClassName(className: controllerName!)
38 | }
39 | let controllerClz = clz as! UIViewController.Type
40 | return controllerClz.init()
41 | } else if controllerID != nil {
42 | let sb = UIStoryboard(name: controllerContainer!, bundle: nil)
43 | return sb.instantiateViewController(withIdentifier: controllerID!)
44 | } else {
45 | return nil
46 | }
47 | }
48 |
49 | init(title: String?, segueID: String?, controllerName: String?, controllerID: String? ,controllerContainer: String?) {
50 | self.title = title
51 | self.segueID = segueID
52 | self.controllerName = controllerName
53 | self.controllerID = controllerID
54 | self.controllerContainer = controllerContainer
55 | }
56 |
57 | static func parse(file: String) -> Array {
58 | let path = Bundle.main.path(forResource: file, ofType: "plist")
59 | assert(path != nil, "config file [\(file)] not found")
60 | let rawItems = NSArray(contentsOfFile: path!)
61 | var items = Array()
62 |
63 | for rawItem in rawItems! {
64 | let rawItemInfo: NSDictionary = rawItem as! NSDictionary
65 | let item = ADKRootCellItem(title: (rawItemInfo["title"] as? String),
66 | segueID: (rawItemInfo["segueID"] as? String),
67 | controllerName: (rawItemInfo["controllerName"] as? String),
68 | controllerID: nil,
69 | controllerContainer: nil)
70 | items.append(item)
71 | }
72 | return items
73 | }
74 | }
75 |
76 | public struct ADKSettingCellItem {
77 | var title: String? // ===> cell title
78 | var varTitle: String? // ===> string value of cell title selector
79 | var action: String? // ===> string value of cell action selector
80 | var type: ADKCellType? // ===> cell type
81 | var defaultValue: String? // ===> string value of cell default value selector
82 | var processing = false // ===> only used for async cell type
83 |
84 | static func parse(file: String) -> (sections: Array, rows: Array>) {
85 | let path = Bundle.main.path(forResource: file, ofType: "plist")
86 | assert(path != nil, "config file [\(file)] not found")
87 | let rawSections = NSArray(contentsOfFile: path!)
88 |
89 | guard rawSections != nil else {
90 | return ([], [])
91 | }
92 |
93 | var rows = Array>()
94 | var sections = Array()
95 |
96 | for rawSection in rawSections! {
97 |
98 | let rawSectionInfo: NSDictionary = rawSection as! NSDictionary
99 | var section = ADKSettingCellItem()
100 | section.title = rawSectionInfo["title"] as? String
101 | section.type = ADKCellType(rawValue: rawSectionInfo["type"] as! String)
102 |
103 | let rawRows: NSArray? = rawSectionInfo["items"] as? NSArray
104 | var sectionRows = Array()
105 |
106 | if rawRows != nil {
107 | for rawRow in rawRows! {
108 | let rawRowInfo: NSDictionary = rawRow as! NSDictionary
109 | var item = ADKSettingCellItem()
110 | item.title = rawRowInfo["title"] as? String
111 | item.action = rawRowInfo["action"] as? String
112 | item.type = ADKCellType(rawValue: rawRowInfo["type"] as! String)
113 | item.defaultValue = rawRowInfo["defaultValue"] as? String
114 | item.varTitle = rawRowInfo["varTitle"] as? String
115 | sectionRows.append(item)
116 | }
117 | }
118 | sections.append(section)
119 | rows.append(sectionRows)
120 | }
121 | return (sections: sections, rows: rows)
122 | }
123 | }
124 |
125 | public let settingItem = ADKRootCellItem(title: "Settings",
126 | segueID: nil,
127 | controllerName: nil,
128 | controllerID: "HDKSettingViewController",
129 | controllerContainer: "ADKStoryboard_container")
130 |
131 | public let guideItem = ADKRootCellItem(title: "Guide",
132 | segueID: nil,
133 | controllerName: nil,
134 | controllerID: "HDKGuideViewController",
135 | controllerContainer: "ADKStoryboard_container")
136 |
137 |
138 | public protocol ADKTheme {
139 | var description: String { get }
140 | var mainColor: UIColor { get }
141 | var fontColor: UIColor { get }
142 | var floatingButtonSize: CGSize { get }
143 | var floationButtonColor: UIColor { get }
144 | var floatingButtonText: String { get }
145 | var floationButtonTextColor: UIColor { get }
146 | var floationButtonFontSize: CGFloat { get }
147 | }
148 |
149 | public protocol ADKConfig {
150 | var storyboardName_phone: String { get }
151 | var storyboardName_pad: String { get }
152 | var rootPageConfigFileName: String { get }
153 | var settingPageConfigFileName: String { get }
154 |
155 | var storyboardName: String { get }
156 | var storyboard: UIStoryboard { get }
157 | var rootPageCellReuseID: String { get }
158 | var defaultItems: Array { get }
159 | }
160 |
161 | public struct ADKDefaultConfig: ADKConfig {
162 | public var storyboardName_phone: String {
163 | return "HDKStoryboard_phone"
164 | }
165 | public var storyboardName_pad: String {
166 | return "ADKStoryboard_pad"
167 | }
168 | public var rootPageConfigFileName: String {
169 | return "HDKRootConfig"
170 | }
171 | public var settingPageConfigFileName: String {
172 | return "HDKSettingConfig"
173 | }
174 | public var storyboardName: String {
175 | return UIDevice.current.userInterfaceIdiom == UIUserInterfaceIdiom.pad ? storyboardName_pad : storyboardName_phone
176 | }
177 | public var storyboard: UIStoryboard {
178 | return UIStoryboard(name: storyboardName, bundle: nil)
179 | }
180 | public var rootPageCellReuseID: String {
181 | return "cell"
182 | }
183 | public var defaultItems: Array {
184 | return [guideItem ,settingItem]
185 | }
186 | }
187 |
188 | public struct ADKDefaultTheme : ADKTheme {
189 |
190 | public var description: String {
191 | return "ADKDefaultTheme"
192 | }
193 | public var mainColor: UIColor {
194 | return UIColor(red: 137.0/255.0, green: 49.0/255.0, blue: 234.0/255.0, alpha: 1.0)
195 | }
196 | public var fontColor: UIColor {
197 | return UIColor.white
198 | }
199 | public var floatingButtonSize: CGSize {
200 | return CGSize(width: 60, height: 60)
201 | }
202 | public var floationButtonColor: UIColor {
203 | return UIColor(red: 137.0/255.0, green: 49.0/255.0, blue: 234.0/255.0, alpha: 1.0)
204 | }
205 | public var floatingButtonText: String {
206 | return NSLocalizedString("Debug", comment: self.description)
207 | }
208 | public var floationButtonTextColor: UIColor {
209 | return UIColor.white
210 | }
211 | public var floationButtonFontSize: CGFloat {
212 | return 14.0
213 | }
214 | }
215 |
216 | public class HDKContext {
217 | public static let shared = HDKContext()
218 | public var theme: ADKTheme = ADKDefaultTheme()
219 | public var config: ADKConfig = ADKDefaultConfig()
220 | private init() {}
221 | }
222 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPPasswordPlugin/BuildInViews/HPNineDotView.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HPNineDotView.swift
3 | // HPPluginRepo
4 | //
5 | // Created by Hu, Peng on 15/12/2017.
6 | // Copyright © 2017 Hu, Peng. All rights reserved.
7 | //
8 |
9 | import UIKit
10 |
11 | let kNDVMainColor = UIColor.color255(from: (r: 91.0, g: 153.0, b: 238.0, a: 1.0))
12 | let kNDVSelectedBorderColor = UIColor.color255(from: (r: 53.0, g: 183.0, b: 127.0, a: 1.0))
13 | let kNDVErrorLineColor = UIColor.color255(from: (r: 255.0, g: 78.0, b: 78.0, a: 1.0))
14 |
15 | class HPNineDotViewStorage: NSObject, IHPPasswordStorage {
16 |
17 | static let passwordKey = "com.hpDemo.9DotView.password.key"
18 | let defaultStorage = UserDefaults.standard
19 | var _password: String?
20 | var password: String? {
21 | if _password == nil {
22 | _password = defaultStorage.string(forKey: HPNineDotViewStorage.passwordKey)
23 | }
24 | return _password
25 | }
26 |
27 | func save(password: String) {
28 | defaultStorage.set(password, forKey: HPNineDotViewStorage.passwordKey)
29 | }
30 |
31 | func deletePassword() {
32 | defaultStorage.removeObject(forKey: HPNineDotViewStorage.passwordKey)
33 | }
34 |
35 | func validate(password: Any?) -> Bool {
36 |
37 | guard let dots = password as? Array else {
38 | return false
39 | }
40 | return dots.count >= 3
41 | }
42 |
43 | func password(from: Any?) -> String? {
44 | guard let dots = from as? Array else {
45 | return nil
46 | }
47 |
48 | return dots.map({ (dot) -> String in
49 | return "\(dot.index)"
50 | }) .joined(separator: "-")
51 | }
52 | }
53 |
54 | @IBDesignable open class HPNineDotView: UIView, IHPPasswordView {
55 |
56 | public struct Dot {
57 | var center: CGPoint {
58 | return rect.center
59 | }
60 | var rect: CGRect
61 | var index: Int
62 |
63 | init(rect: CGRect, index: Int) {
64 | self.rect = rect
65 | self.index = index
66 | }
67 |
68 | func contains(_ point: CGPoint) -> Bool {
69 | return rect.contains(point)
70 | }
71 |
72 | static func == (lhs: Dot, rhs: Dot) -> Bool {
73 | return lhs.index == rhs.index
74 | }
75 | static func != (lhs: Dot, rhs: Dot) -> Bool {
76 | return lhs.index != rhs.index
77 | }
78 | }
79 |
80 | // UI Var.
81 | @IBInspectable var dotRadius: CGFloat = 30
82 | @IBInspectable var dotMargin: CGFloat = 30
83 | @IBInspectable var dotBorderWidth: CGFloat = 1
84 | @IBInspectable var dotBorderColor: UIColor = kNDVMainColor
85 | @IBInspectable var dotSelectedBorderColor: UIColor = kNDVSelectedBorderColor
86 |
87 |
88 | @IBInspectable var connectLineWidth: CGFloat = 2
89 | @IBInspectable var connectLineColor: UIColor = kNDVMainColor
90 |
91 | @IBInspectable var errorLineColor: UIColor = kNDVErrorLineColor
92 |
93 | @IBOutlet weak var draggedLineMaskView: UIImageView!
94 | @IBOutlet weak var connectedLineMaskView: UIImageView!
95 |
96 |
97 | private var effectViews: Array = []
98 | private var selectedDots: Array = []
99 |
100 | // Logic Var.
101 | private var dots: Array = []
102 | private var preDot: Dot?
103 | lazy private var leftTryTime = self.maxTryTime
104 |
105 | // MARK: - IHPPasswordView implementation
106 | var maxTryTime: Int {
107 | return 3
108 | }
109 |
110 | var status: HPPasswordViewStatus = .create
111 |
112 | var tmpPassword: Any? {
113 | get {
114 | return selectedDots
115 | }
116 | set(newValue) {
117 | selectedDots = newValue as! Array
118 | }
119 |
120 | }
121 |
122 | var delegate: HPPasswordViewDelegate?
123 |
124 | //
125 |
126 | private var _decorator: HPPasswordViewDecorator? = nil
127 |
128 | private var decorator: HPPasswordViewDecorator {
129 | if _decorator == nil {
130 | _decorator = HPPasswordViewDecorator(passwordView: self, storage: HPNineDotViewStorage())
131 | }
132 | return _decorator!
133 | }
134 |
135 | override open func touchesBegan(_ touches: Set, with event: UIEvent?) {
136 |
137 | self.delegate?.beginInput(passwordView: self)
138 |
139 | let touch = touches.first!
140 | let point = touch.location(in: self)
141 |
142 | let dot = selectedDot(with: point)
143 |
144 | guard dot != nil else {
145 | return
146 | }
147 | didSelect(dot: dot!)
148 | }
149 |
150 | override open func touchesMoved(_ touches: Set, with event: UIEvent?) {
151 |
152 | guard preDot != nil else {
153 | return
154 | }
155 |
156 | let touch = touches.first!
157 | let point = touch.location(in: self)
158 |
159 | connect(point: preDot!.center, to: point)
160 |
161 | let dot = selectedDot(with: point)
162 |
163 | guard dot != nil else {
164 | return
165 | }
166 |
167 | guard dot! != preDot! else {
168 | return
169 | }
170 |
171 | let midDot = middleDot(between: preDot!, and: dot!)
172 |
173 | if midDot != nil {
174 | connect(preDot!, to: midDot!)
175 | didSelect(dot: midDot!)
176 | }
177 |
178 | connect(preDot!, to: dot!)
179 | didSelect(dot: dot!)
180 | }
181 |
182 | override open func touchesEnded(_ touches: Set, with event: UIEvent?) {
183 |
184 | guard preDot != nil else {
185 | return
186 | }
187 |
188 | decorator.triggerStatusChange(HPPasswordViewStatusChange(from: self.status, to: .empty, tryTimes: leftTryTime))
189 | draggedLineMaskView.image = nil
190 |
191 | self.delegate?.endInput(passwordView: self)
192 | }
193 |
194 | open override func touchesCancelled(_ touches: Set, with event: UIEvent?) {
195 | touchesEnded(touches, with: event)
196 | }
197 |
198 | override open func draw(_ rect: CGRect) {
199 |
200 | super.draw(rect)
201 | let context = UIGraphicsGetCurrentContext()!
202 | for i in 0..<9 {
203 | let center = centerOfDot(at: i)
204 | draw(dot: (radius: CGFloat(dotRadius), center: center), with: context)
205 | let dot = Dot(rect:CGRect.rectOfCircle(center: center, radius: dotRadius), index: i)
206 | dots.append(dot)
207 | }
208 | }
209 |
210 | @objc private func resetView() {
211 | connectedLineMaskView.image = nil
212 | draggedLineMaskView.image = nil
213 | selectedDots.removeAll()
214 | preDot = nil
215 | for view in effectViews {
216 | view.removeFromSuperview()
217 | }
218 | effectViews.removeAll()
219 | }
220 |
221 | private func showErrorStatus() {
222 |
223 | var preDot = selectedDots.first!
224 |
225 | for dot in selectedDots {
226 |
227 | if dot != preDot {
228 | connect(preDot, to: dot, error: true)
229 | preDot = dot
230 | }
231 | applySelectedEffect(to: dot, error: true)
232 | }
233 |
234 | }
235 |
236 | // MARK: - IHPPasswordView implementation
237 |
238 | open func passwordImage() -> UIImage? {
239 | return nil
240 | }
241 |
242 | func updateView(with change: HPPasswordViewStatusChange) {
243 |
244 | let toStatus = change.to
245 | leftTryTime = change.tryTimes
246 |
247 | if toStatus != .mismatch && toStatus != .invalid {
248 | resetView()
249 | } else {
250 | showErrorStatus()
251 | perform(#selector(resetView), with: nil, afterDelay: 1)
252 | }
253 | }
254 |
255 | // MARK: -
256 | private func centerOfDot(at index: Int) -> CGPoint {
257 | let w = self.bounds.width
258 | let h = self.bounds.height
259 |
260 | let viewCenter = CGPoint(x: w/2.0, y: h/2.0)
261 | let viewCenterRow = 1
262 | let viewCenterColumn = 1
263 |
264 | let row = index/3
265 | let column = index%3
266 |
267 | let x = viewCenter.x + CGFloat(column - viewCenterRow) * (dotRadius * 2 + dotMargin)
268 | let y = viewCenter.y + CGFloat(row - viewCenterColumn) * (dotRadius * 2 + dotMargin)
269 | return CGPoint(x: x, y: y)
270 | }
271 |
272 | open func draw(dot: (radius: CGFloat, center: CGPoint), with context: CGContext) {
273 | context.addArc(center: dot.center, radius: dot.radius, startAngle: 0, endAngle: CGFloat(2 * Double.pi), clockwise: false)
274 | context.setStrokeColor(dotBorderColor.cgColor)
275 | context.setLineWidth(dotBorderWidth)
276 | context.strokePath()
277 | }
278 |
279 | private func selectedDot(with touchPoint: CGPoint) -> Dot? {
280 |
281 | var matchedDot: Dot? = nil
282 | for dot in dots {
283 | if dot.contains(touchPoint) {
284 | matchedDot = dot
285 | break
286 | }
287 | }
288 |
289 | // case: no matched dot has been found
290 | guard matchedDot != nil else {
291 | return nil
292 | }
293 |
294 | // case: first dot always can be selected
295 | guard preDot != nil else {
296 | return matchedDot
297 | }
298 |
299 | // case: duplicated seleted index
300 | let duplicated = selectedDots.contains { (dot) -> Bool in
301 | return dot == matchedDot!
302 | }
303 |
304 | guard !duplicated else {
305 | return nil
306 | }
307 |
308 | // case: some special connect logic has not been fulfilled
309 | guard can(connect: preDot!, to: matchedDot!) else {
310 | return nil
311 | }
312 |
313 | return matchedDot
314 | }
315 |
316 | private func middleDot(between oneDot: Dot, and anotherDot: Dot) -> Dot? {
317 |
318 | guard (oneDot.index + anotherDot.index)%2 == 0 else {
319 | return nil
320 | }
321 |
322 | let middleIndex = (oneDot.index + anotherDot.index)/2
323 | let midDot = dots[middleIndex]
324 |
325 | let duplicated = selectedDots.contains { (dot) -> Bool in
326 | return dot == midDot
327 | }
328 |
329 | guard !duplicated else {
330 | return nil
331 | }
332 |
333 | let fromPoint = oneDot.center
334 | let toPoint = anotherDot.center
335 | let midPoint = midDot.center
336 |
337 | guard midPoint.slope(with: fromPoint) == midPoint.slope(with: toPoint) else {
338 | return nil
339 | }
340 | return midDot
341 | }
342 |
343 | /*
344 | * override this function if there are some special demands
345 | * ex. only nearby point can be connected to each other...
346 | */
347 | open func can(connect dot: Dot, to anotherDot: Dot) -> Bool {
348 | return true
349 | }
350 |
351 | private func didSelect(dot: Dot) {
352 | selectedDots.append(dot)
353 | preDot = dot
354 | applySelectedEffect(to: dot, error: false)
355 | }
356 |
357 | open func applySelectedEffect(to dot: Dot, error: Bool) {
358 |
359 | let effectView = UIView(frame: dot.rect.insetBy(dx: -dotBorderWidth, dy: -dotBorderWidth))
360 | effectView.backgroundColor = error ? errorLineColor : connectLineColor
361 | effectView.layer.cornerRadius = effectView.frame.width * 0.5
362 | effectView.layer.borderWidth = dotBorderWidth
363 | effectView.layer.borderColor = error ? errorLineColor.cgColor : connectLineColor.cgColor
364 |
365 |
366 | let animatedLayerSize: CGFloat = 20.0
367 | let scale = animatedLayerSize/dot.rect.width
368 | let animatedLayer = CALayer()
369 | animatedLayer.frame = effectView.bounds
370 | animatedLayer.cornerRadius = effectView.layer.cornerRadius
371 | animatedLayer.backgroundColor = UIColor.color255(from: (r: 245.0, g: 246.0, b: 247.0, a: 1.0)).cgColor
372 |
373 | let animation = CABasicAnimation(keyPath: "transform")
374 | animation.fromValue = CATransform3DMakeAffineTransform(CGAffineTransform(scaleX: scale, y: scale))
375 | animation.toValue = CATransform3DIdentity
376 | animation.duration = 0.2
377 | animation.isRemovedOnCompletion = false
378 | animatedLayer.add(animation, forKey: "scale")
379 |
380 |
381 | let centerLayer = CALayer()
382 | centerLayer.frame = CGRect.rect(with: effectView.bounds.center, size: CGSize(width: animatedLayerSize, height: animatedLayerSize))
383 | centerLayer.cornerRadius = animatedLayerSize * 0.5
384 | centerLayer.backgroundColor = error ? errorLineColor.cgColor : connectLineColor.cgColor
385 |
386 | effectView.layer.addSublayer(animatedLayer)
387 | effectView.layer.addSublayer(centerLayer)
388 |
389 | self.addSubview(effectView)
390 | effectViews.append(effectView)
391 |
392 | }
393 |
394 | private func connect(_ dot: Dot, to anotherDot: Dot, error: Bool = false) {
395 |
396 | let fromPoint = dot.center
397 | let toPoint = anotherDot.center
398 |
399 | UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, UIScreen.main.scale)
400 | let context = UIGraphicsGetCurrentContext()!
401 | connectedLineMaskView.image?.draw(in: self.bounds)
402 | context.saveGState()
403 |
404 | let line = (width: connectLineWidth, color: error ? errorLineColor : connectLineColor)
405 | connect(point: fromPoint, to: toPoint, in: context, with: line)
406 |
407 | connectedLineMaskView.image = UIGraphicsGetImageFromCurrentImageContext()
408 | context.saveGState()
409 | UIGraphicsEndImageContext()
410 |
411 | }
412 |
413 | open func connect(point: CGPoint, to anotherPoint: CGPoint) {
414 | UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, UIScreen.main.scale)
415 | let context = UIGraphicsGetCurrentContext()!
416 | context.saveGState()
417 | let line = (width: connectLineWidth, color: connectLineColor)
418 | connect(point: point, to: anotherPoint, in: context, with: line)
419 | draggedLineMaskView.image = UIGraphicsGetImageFromCurrentImageContext()
420 | context.saveGState()
421 | UIGraphicsEndImageContext()
422 | }
423 |
424 | open func connect(point: CGPoint, to anotherPoint: CGPoint, `in` context: CGContext, with line:(width: CGFloat, color: UIColor)) {
425 |
426 | let lineColor = line.color
427 | let lineWidth = line.width
428 |
429 | context.setLineCap(.round)
430 | context.move(to: point)
431 | context.addLine(to: anotherPoint)
432 | context.setLineWidth(lineWidth)
433 | context.setStrokeColor(lineColor.cgColor)
434 | context.strokePath()
435 | context.saveGState()
436 | }
437 | }
438 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPPasswordPlugin/BuildInViews/HPSimplePasscodeView.xib:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 |
7 |
10 |
11 |
14 |
17 |
18 |
20 |
21 |
27 |
28 |
31 |
34 |
35 |
36 |
38 |
47 |
48 |
51 |
52 |
53 |
55 |
56 |
61 |
62 |
65 |
68 |
69 |
70 |
72 |
79 |
80 |
83 |
84 |
85 |
87 |
88 |
93 |
94 |
97 |
100 |
101 |
102 |
104 |
111 |
112 |
115 |
116 |
117 |
119 |
120 |
125 |
126 |
129 |
132 |
133 |
134 |
136 |
143 |
144 |
147 |
148 |
149 |
154 |
156 |
157 |
158 |
160 |
178 |
179 |
185 |
187 |
188 |
189 |
--------------------------------------------------------------------------------
/HPPluginRepo/Plugins/HPCalendarExt/BuildInView/HPCalendarView.xib:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 |
7 |
11 |
12 |
13 | HelveticaNeue
14 |
15 |
16 |
17 |
20 |
23 |
24 |
26 |
27 |
32 |
33 |
35 |
38 |
40 |
42 |
43 |
44 |
47 |
49 |
50 |
51 |
53 |
63 |
64 |
65 |
67 |
68 |
73 |
74 |
79 |
80 |
85 |
86 |
91 |
92 |
97 |
98 |
103 |
104 |
109 |
110 |
112 |
142 |
143 |
144 |
149 |
152 |
153 |
154 |
156 |
167 |
168 |
171 |
173 |
174 |
175 |
178 |
179 |
--------------------------------------------------------------------------------