Merge branch 'develop'

# Conflicts:
#	Package.resolved
#	Package.swift

Author: sadeghgoo

Package.resolved

@@ -12,15 +12,15 @@ let package = Package(
             targets: ["MagicTimer"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/MagicTimerFW/MagicTimerCore", branch: "main")
+        .package(url: "https://github.com/sadeghgoo/MathOperators.git", branch: "main")
     ],
     targets: [
         .target(
             name: "MagicTimer",
             dependencies: [
                 .product(
-                    name: "MagicTimerCore",
-                    package: "MagicTimerCore"),
+                    name: "MathOperators",
+                    package: "MathOperators"),
             ]),
         .testTarget(
             name: "MagicTimerTests",

Package.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+public extension Date {
+    static func - (lhs: Date, rhs: Date) -> TimeInterval {
+        return lhs.timeIntervalSinceReferenceDate.minus(rhs.timeIntervalSinceReferenceDate)
+    }
+}

Sources/MagicTimer/Date+Extension.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+public extension TimeInterval {
+    /// Cast TimeInterval to Int.
+    func convertToInteger() -> Int {
+        return Int(self)
+    }
+    /// Cast TimeInterval to String.
+    func convertToString() -> String {
+        return String(self)
+    }
+}

Sources/MagicTimer/Double+Extension.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+public extension Int {
+    /// Cast Int to TimeInterval
+    func convertToTimeInterval() -> TimeInterval {
+        return TimeInterval(self)
+    }
+    /// Cast Int to String
+    func convertToString() -> String {
+        return String(self)
+    }
+    
+}
+
+public extension Double {
+    /// Check the number is positive(bigger than zero)
+    var isPositive: Bool {
+        get {
+            return self > 0
+        }
+    }
+    /// Cast Double to TimeInterval
+    func convertToTimeInterval() -> TimeInterval {
+        return TimeInterval(self)
+    }
+}

Sources/MagicTimer/Int+Extension.swift

@@ -1,5 +1,4 @@
 import Foundation
-import MagicTimerCore
 import MathOperators
 
 @available(*, unavailable, renamed: "MagicTimerMode")

Sources/MagicTimer/MagicTimer.swift

@@ -0,0 +1,46 @@
+import UIKit
+import MathOperators
+
+public protocol MagicTimerBackgroundCalculatorInterface {
+    /// The timer fired date.
+    var timerFiredDate: Date? { get set }
+    /// By changing this type timer decides to whether calcualte the time in background.
+    var isActiveBackgroundMode: Bool { get set }
+    
+    var backgroundTimeCalculateHandler: ((TimeInterval) -> Void)? { get set }
+}
+
+public final class MagicTimerBackgroundCalculator: MagicTimerBackgroundCalculatorInterface {
+    
+    public var timerFiredDate: Date?
+    public var isActiveBackgroundMode: Bool = true
+    public var backgroundTimeCalculateHandler: ((TimeInterval) -> Void)?
+    
+    public init() {
+        NotificationCenter.default.addObserver(self, selector: #selector(willEnterForegroundNotification), name: UIApplication.willEnterForegroundNotification, object: nil)
+    }
+    
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+  
+    private func invalidateFiredDate() {
+        timerFiredDate = nil
+    }
+    
+    private func calculateDateDiffrence() -> TimeInterval? {
+        guard let timerFiredDate else { return nil }
+        let validTimeSubtraction = abs(timerFiredDate - Date())
+        return validTimeSubtraction.convertToTimeInterval()
+    }
+    
+    @objc
+    private func willEnterForegroundNotification() {
+        guard isActiveBackgroundMode else { return }
+        
+        if let timeInterval = calculateDateDiffrence() {
+            backgroundTimeCalculateHandler?(timeInterval)
+        }
+    }
+}
+

Sources/MagicTimer/MagicTimerBackgroundCalculator.swift

@@ -0,0 +1,52 @@
+import Foundation
+import MathOperators
+
+public protocol MagicTimerCounterInterface {
+    /// The total counted value.
+    var totalCountedValue: TimeInterval { get set }
+    /// A number which is added or minused on each ``timeInterval``.
+    var effectiveValue: TimeInterval { get set }
+    /// The initial value of counter.
+    var defultValue: TimeInterval { get set }
+    /// Add effectiveValue to totalCountedValue.
+    func add()
+    /// Subtract effectiveValue from totalCountedValue.
+    func subtract()
+    /// Reset totalCountedValue to zero.
+    func resetTotalCounted()
+    /// Reset totalCountedValue to defultValue.
+    func resetToDefaultValue()
+}
+
+public final class MagicTimerCounter: MagicTimerCounterInterface {
+    
+    // MARK: - Public properties
+    public var totalCountedValue: TimeInterval = 0
+    public var effectiveValue: TimeInterval = 1.0
+    public var defultValue: TimeInterval = 0.0 {
+        didSet {
+            totalCountedValue = totalCountedValue.plus(defultValue)
+        }
+    }
+    
+    // MARK: - Constructors
+    public init() { }
+    
+    // MARK: - Public methods
+    public func add() {
+        totalCountedValue = totalCountedValue.plus(effectiveValue)
+    }
+    
+    public func subtract() {
+        totalCountedValue = totalCountedValue.minus(effectiveValue)
+    }
+    
+    public func resetTotalCounted() {
+        totalCountedValue = 0
+    }
+    
+    public func resetToDefaultValue() {
+        totalCountedValue = defultValue
+    }
+}
+

Sources/MagicTimer/MagicTimerCounter.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+public protocol MagicTimerExecutiveInterface {
+    /// Timer time interval.
+    var timeInterval: TimeInterval { get set }
+    /// Fire the timer.
+    func fire(compeltionHandler: (() -> Void)?)
+    /// Suspand the timer.
+    func suspand(completionHandler: (() -> Void)?)
+    /// A call back which is called on every time interval.
+    var scheduleTimerHandler: (() -> Void)? { get set }
+}
+
+public final class MagicTimerExecutive: MagicTimerExecutiveInterface {
+    
+    // MARK: - Public properties
+    public var scheduleTimerHandler: (() -> Void)?
+    public var timeInterval: TimeInterval = 1.0
+    
+    // MARK: - Private
+    private var scheduleTimer: Timer?
+    private var isTimerAlreadyStarted: Bool = false
+
+    // MARK: - Constructors
+    public init() {
+        scheduleTimer = Timer.scheduledTimer(withTimeInterval: timeInterval, repeats: true, block: { [weak self] _ in
+            self?.scheduleTimerHandler?()
+        })
+    }
+    
+    // MARK: - Public methods
+    public func fire(compeltionHandler: (() -> Void)?) {
+        isTimerAlreadyStarted = true
+        scheduleTimer?.fire()
+        RunLoop.main.add(scheduleTimer!, forMode: .common)
+        compeltionHandler?()
+    }
+    
+    public func suspand(completionHandler: (() -> Void)?) {
+        scheduleTimer?.invalidate()
+        isTimerAlreadyStarted = false
+        completionHandler?()
+    }
+}