566 lines
20 KiB
Swift
566 lines
20 KiB
Swift
//
|
||
// Swiftfin is subject to the terms of the Mozilla Public
|
||
// License, v2.0. If a copy of the MPL was not distributed with this
|
||
// file, you can obtain one at https://mozilla.org/MPL/2.0/.
|
||
//
|
||
// Copyright (c) 2022 Jellyfin & Jellyfin Contributors
|
||
//
|
||
|
||
// Modification of https://github.com/zattoo/TvOSSlider
|
||
|
||
import GameController
|
||
import UIKit
|
||
|
||
enum DPadState {
|
||
case select
|
||
case right
|
||
case left
|
||
case up
|
||
case down
|
||
}
|
||
|
||
private let trackViewHeight: CGFloat = 5
|
||
private let animationDuration: TimeInterval = 0.3
|
||
private let defaultValue: Float = 0
|
||
private let defaultMinimumValue: Float = 0
|
||
private let defaultMaximumValue: Float = 1
|
||
private let defaultIsContinuous: Bool = true
|
||
private let defaultThumbTintColor: UIColor = .white
|
||
private let defaultTrackColor: UIColor = .gray
|
||
private let defaultMininumTrackTintColor: UIColor = .blue
|
||
private let defaultFocusScaleFactor: CGFloat = 1.05
|
||
private let defaultStepValue: Float = 0.1
|
||
private let decelerationRate: Float = 0.92
|
||
private let decelerationMaxVelocity: Float = 1000
|
||
|
||
/// A control used to select a single value from a continuous range of values.
|
||
public final class TvOSSlider: UIControl {
|
||
|
||
// MARK: - Public
|
||
|
||
/// The slider’s current value.
|
||
@IBInspectable
|
||
public var value: Float {
|
||
get {
|
||
storedValue
|
||
}
|
||
set {
|
||
storedValue = min(maximumValue, newValue)
|
||
storedValue = max(minimumValue, storedValue)
|
||
|
||
var offset = trackView.bounds.width * CGFloat((storedValue - minimumValue) / (maximumValue - minimumValue))
|
||
offset = min(trackView.bounds.width, offset)
|
||
thumbViewCenterXConstraint.constant = offset
|
||
}
|
||
}
|
||
|
||
/// The minimum value of the slider.
|
||
@IBInspectable
|
||
public var minimumValue: Float = defaultMinimumValue {
|
||
didSet {
|
||
value = max(value, minimumValue)
|
||
}
|
||
}
|
||
|
||
/// The maximum value of the slider.
|
||
@IBInspectable
|
||
public var maximumValue: Float = defaultMaximumValue {
|
||
didSet {
|
||
value = min(value, maximumValue)
|
||
}
|
||
}
|
||
|
||
/// A Boolean value indicating whether changes in the slider’s value generate continuous update events.
|
||
@IBInspectable
|
||
public var isContinuous: Bool = defaultIsContinuous
|
||
|
||
/// The color used to tint the default minimum track images.
|
||
@IBInspectable
|
||
public var minimumTrackTintColor: UIColor? = defaultMininumTrackTintColor {
|
||
didSet {
|
||
minimumTrackView.backgroundColor = minimumTrackTintColor
|
||
}
|
||
}
|
||
|
||
/// The color used to tint the default maximum track images.
|
||
@IBInspectable
|
||
public var maximumTrackTintColor: UIColor? {
|
||
didSet {
|
||
maximumTrackView.backgroundColor = maximumTrackTintColor
|
||
}
|
||
}
|
||
|
||
/// The color used to tint the default thumb images.
|
||
@IBInspectable
|
||
public var thumbTintColor: UIColor = defaultThumbTintColor {
|
||
didSet {
|
||
thumbView.backgroundColor = thumbTintColor
|
||
}
|
||
}
|
||
|
||
/// Scale factor applied to the slider when receiving the focus
|
||
@IBInspectable
|
||
public var focusScaleFactor: CGFloat = defaultFocusScaleFactor {
|
||
didSet {
|
||
updateStateDependantViews()
|
||
}
|
||
}
|
||
|
||
/// Value added or subtracted from the current value on steps left or right updates
|
||
public var stepValue: Float = defaultStepValue
|
||
|
||
/// Damping value for panning gestures
|
||
public var panDampingValue: Float = 5
|
||
|
||
// Size for thumb view
|
||
public var thumbSize: CGFloat = 30
|
||
|
||
public var fineTunningVelocityThreshold: Float = 600
|
||
|
||
/**
|
||
Sets the slider’s current value, allowing you to animate the change visually.
|
||
|
||
- Parameters:
|
||
- value: The new value to assign to the value property
|
||
- animated: Specify true to animate the change in value; otherwise, specify false to update the slider’s appearance immediately. Animations are performed asynchronously and do not block the calling thread.
|
||
*/
|
||
public func setValue(_ value: Float, animated: Bool) {
|
||
self.value = value
|
||
stopDeceleratingTimer()
|
||
|
||
if animated {
|
||
UIView.animate(withDuration: animationDuration) {
|
||
self.setNeedsLayout()
|
||
self.layoutIfNeeded()
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
Assigns a minimum track image to the specified control states.
|
||
|
||
- Parameters:
|
||
- image: The minimum track image to associate with the specified states.
|
||
- state: The control state with which to associate the image.
|
||
*/
|
||
public func setMinimumTrackImage(_ image: UIImage?, for state: UIControl.State) {
|
||
minimumTrackViewImages[state.rawValue] = image
|
||
updateStateDependantViews()
|
||
}
|
||
|
||
/**
|
||
Assigns a maximum track image to the specified control states.
|
||
|
||
- Parameters:
|
||
- image: The maximum track image to associate with the specified states.
|
||
- state: The control state with which to associate the image.
|
||
*/
|
||
public func setMaximumTrackImage(_ image: UIImage?, for state: UIControl.State) {
|
||
maximumTrackViewImages[state.rawValue] = image
|
||
updateStateDependantViews()
|
||
}
|
||
|
||
/**
|
||
Assigns a thumb image to the specified control states.
|
||
|
||
- Parameters:
|
||
- image: The thumb image to associate with the specified states.
|
||
- state: The control state with which to associate the image.
|
||
*/
|
||
public func setThumbImage(_ image: UIImage?, for state: UIControl.State) {
|
||
thumbViewImages[state.rawValue] = image
|
||
updateStateDependantViews()
|
||
}
|
||
|
||
/// The minimum track image currently being used to render the slider.
|
||
public var currentMinimumTrackImage: UIImage? {
|
||
minimumTrackView.image
|
||
}
|
||
|
||
/// Contains the maximum track image currently being used to render the slider.
|
||
public var currentMaximumTrackImage: UIImage? {
|
||
maximumTrackView.image
|
||
}
|
||
|
||
/// The thumb image currently being used to render the slider.
|
||
public var currentThumbImage: UIImage? {
|
||
thumbView.image
|
||
}
|
||
|
||
/**
|
||
Returns the minimum track image associated with the specified control state.
|
||
|
||
- Parameters:
|
||
- state: The control state whose minimum track image you want to use. Specify a single control state value for this parameter.
|
||
|
||
- Returns: The minimum track image associated with the specified state, or nil if no image has been set. This method might also return nil if you specify multiple control states in the state parameter. For a description of track images, see Customizing the Slider’s Appearance.
|
||
*/
|
||
public func minimumTrackImage(for state: UIControl.State) -> UIImage? {
|
||
minimumTrackViewImages[state.rawValue]
|
||
}
|
||
|
||
/**
|
||
Returns the maximum track image associated with the specified control state.
|
||
|
||
- Parameters:
|
||
- state: The control state whose maximum track image you want to use. Specify a single control state value for this parameter.
|
||
|
||
- Returns: The maximum track image associated with the specified state, or nil if an appropriate image could not be retrieved. This method might return nil if you specify multiple control states in the state parameter. For a description of track images, see Customizing the Slider’s Appearance.
|
||
*/
|
||
public func maximumTrackImage(for state: UIControl.State) -> UIImage? {
|
||
maximumTrackViewImages[state.rawValue]
|
||
}
|
||
|
||
/**
|
||
Returns the thumb image associated with the specified control state.
|
||
|
||
- Parameters:
|
||
- state: The control state whose thumb image you want to use. Specify a single control state value for this parameter.
|
||
|
||
- Returns: The thumb image associated with the specified state, or nil if an appropriate image could not be retrieved. This method might return nil if you specify multiple control states in the state parameter. For a description of track and thumb images, see Customizing the Slider’s Appearance.
|
||
*/
|
||
public func thumbImage(for state: UIControl.State) -> UIImage? {
|
||
thumbViewImages[state.rawValue]
|
||
}
|
||
|
||
// MARK: - Initializers
|
||
|
||
/// :nodoc:
|
||
// public override init(frame: CGRect) {
|
||
// super.init(frame: frame)
|
||
// setUpView()
|
||
// }
|
||
|
||
/// :nodoc:
|
||
// public required init?(coder aDecoder: NSCoder) {
|
||
// super.init(coder: aDecoder)
|
||
// setUpView()
|
||
// }
|
||
|
||
// MARK: VideoPlayerVieModel init
|
||
|
||
init(viewModel: VideoPlayerViewModel) {
|
||
self.viewModel = viewModel
|
||
super.init(frame: .zero)
|
||
setUpView()
|
||
}
|
||
|
||
@available(*, unavailable)
|
||
required init?(coder: NSCoder) {
|
||
fatalError("init(coder:) has not been implemented")
|
||
}
|
||
|
||
deinit {
|
||
NotificationCenter.default.removeObserver(self)
|
||
}
|
||
|
||
// MARK: - UIControlStates
|
||
|
||
/// :nodoc:
|
||
override public var isEnabled: Bool {
|
||
didSet {
|
||
panGestureRecognizer.isEnabled = isEnabled
|
||
updateStateDependantViews()
|
||
}
|
||
}
|
||
|
||
/// :nodoc:
|
||
override public var isSelected: Bool {
|
||
didSet {
|
||
updateStateDependantViews()
|
||
}
|
||
}
|
||
|
||
/// :nodoc:
|
||
override public var isHighlighted: Bool {
|
||
didSet {
|
||
updateStateDependantViews()
|
||
}
|
||
}
|
||
|
||
/// :nodoc:
|
||
override public func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
|
||
coordinator.addCoordinatedAnimations({
|
||
self.updateStateDependantViews()
|
||
}, completion: nil)
|
||
}
|
||
|
||
// MARK: - Private
|
||
|
||
private let viewModel: VideoPlayerViewModel!
|
||
|
||
private typealias ControlState = UInt
|
||
|
||
public var storedValue: Float = defaultValue
|
||
|
||
private var thumbViewImages: [ControlState: UIImage] = [:]
|
||
private var thumbView: UIImageView!
|
||
|
||
private var trackViewImages: [ControlState: UIImage] = [:]
|
||
private var trackView: UIImageView!
|
||
|
||
private var minimumTrackViewImages: [ControlState: UIImage] = [:]
|
||
private var minimumTrackView: UIImageView!
|
||
|
||
private var maximumTrackViewImages: [ControlState: UIImage] = [:]
|
||
private var maximumTrackView: UIImageView!
|
||
|
||
private var panGestureRecognizer: UIPanGestureRecognizer!
|
||
private var leftTapGestureRecognizer: UITapGestureRecognizer!
|
||
private var rightTapGestureRecognizer: UITapGestureRecognizer!
|
||
|
||
private var thumbViewCenterXConstraint: NSLayoutConstraint!
|
||
|
||
private var dPadState: DPadState = .select
|
||
|
||
private weak var deceleratingTimer: Timer?
|
||
private var deceleratingVelocity: Float = 0
|
||
|
||
private var thumbViewCenterXConstraintConstant: Float = 0
|
||
|
||
private func setUpView() {
|
||
setUpTrackView()
|
||
setUpMinimumTrackView()
|
||
setUpMaximumTrackView()
|
||
setUpThumbView()
|
||
|
||
setUpTrackViewConstraints()
|
||
setUpMinimumTrackViewConstraints()
|
||
setUpMaximumTrackViewConstraints()
|
||
setUpThumbViewConstraints()
|
||
|
||
setUpGestures()
|
||
|
||
NotificationCenter.default.addObserver(
|
||
self,
|
||
selector: #selector(controllerConnected(note:)),
|
||
name: .GCControllerDidConnect,
|
||
object: nil
|
||
)
|
||
updateStateDependantViews()
|
||
}
|
||
|
||
private func setUpThumbView() {
|
||
thumbView = UIImageView()
|
||
thumbView.layer.cornerRadius = thumbSize / 6
|
||
thumbView.backgroundColor = thumbTintColor
|
||
addSubview(thumbView)
|
||
}
|
||
|
||
private func setUpTrackView() {
|
||
trackView = UIImageView()
|
||
trackView.layer.cornerRadius = trackViewHeight / 2
|
||
trackView.backgroundColor = defaultTrackColor.withAlphaComponent(0.3)
|
||
addSubview(trackView)
|
||
}
|
||
|
||
private func setUpMinimumTrackView() {
|
||
minimumTrackView = UIImageView()
|
||
minimumTrackView.layer.cornerRadius = trackViewHeight / 2
|
||
minimumTrackView.backgroundColor = minimumTrackTintColor
|
||
addSubview(minimumTrackView)
|
||
}
|
||
|
||
private func setUpMaximumTrackView() {
|
||
maximumTrackView = UIImageView()
|
||
maximumTrackView.layer.cornerRadius = trackViewHeight / 2
|
||
maximumTrackView.backgroundColor = maximumTrackTintColor
|
||
addSubview(maximumTrackView)
|
||
}
|
||
|
||
private func setUpTrackViewConstraints() {
|
||
trackView.translatesAutoresizingMaskIntoConstraints = false
|
||
trackView.leadingAnchor.constraint(equalTo: leadingAnchor).isActive = true
|
||
trackView.trailingAnchor.constraint(equalTo: trailingAnchor).isActive = true
|
||
trackView.centerYAnchor.constraint(equalTo: centerYAnchor).isActive = true
|
||
trackView.heightAnchor.constraint(equalToConstant: trackViewHeight).isActive = true
|
||
}
|
||
|
||
private func setUpMinimumTrackViewConstraints() {
|
||
minimumTrackView.translatesAutoresizingMaskIntoConstraints = false
|
||
minimumTrackView.leadingAnchor.constraint(equalTo: trackView.leadingAnchor).isActive = true
|
||
minimumTrackView.trailingAnchor.constraint(equalTo: thumbView.centerXAnchor).isActive = true
|
||
minimumTrackView.centerYAnchor.constraint(equalTo: trackView.centerYAnchor).isActive = true
|
||
minimumTrackView.heightAnchor.constraint(equalToConstant: trackViewHeight).isActive = true
|
||
}
|
||
|
||
private func setUpMaximumTrackViewConstraints() {
|
||
maximumTrackView.translatesAutoresizingMaskIntoConstraints = false
|
||
maximumTrackView.leadingAnchor.constraint(equalTo: thumbView.centerXAnchor).isActive = true
|
||
maximumTrackView.trailingAnchor.constraint(equalTo: trackView.trailingAnchor).isActive = true
|
||
maximumTrackView.centerYAnchor.constraint(equalTo: trackView.centerYAnchor).isActive = true
|
||
maximumTrackView.heightAnchor.constraint(equalToConstant: trackViewHeight).isActive = true
|
||
}
|
||
|
||
private func setUpThumbViewConstraints() {
|
||
thumbView.translatesAutoresizingMaskIntoConstraints = false
|
||
thumbView.centerYAnchor.constraint(equalTo: centerYAnchor).isActive = true
|
||
thumbView.widthAnchor.constraint(equalToConstant: thumbSize / 3).isActive = true
|
||
thumbView.heightAnchor.constraint(equalToConstant: thumbSize).isActive = true
|
||
thumbViewCenterXConstraint = thumbView.centerXAnchor.constraint(equalTo: trackView.leadingAnchor, constant: CGFloat(value))
|
||
thumbViewCenterXConstraint.isActive = true
|
||
}
|
||
|
||
private func setUpGestures() {
|
||
panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(panGestureWasTriggered(panGestureRecognizer:)))
|
||
addGestureRecognizer(panGestureRecognizer)
|
||
|
||
leftTapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(leftTapWasTriggered))
|
||
leftTapGestureRecognizer.allowedPressTypes = [NSNumber(value: UIPress.PressType.leftArrow.rawValue)]
|
||
leftTapGestureRecognizer.allowedTouchTypes = [NSNumber(value: UITouch.TouchType.indirect.rawValue)]
|
||
addGestureRecognizer(leftTapGestureRecognizer)
|
||
|
||
rightTapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(rightTapWasTriggered))
|
||
rightTapGestureRecognizer.allowedPressTypes = [NSNumber(value: UIPress.PressType.rightArrow.rawValue)]
|
||
rightTapGestureRecognizer.allowedTouchTypes = [NSNumber(value: UITouch.TouchType.indirect.rawValue)]
|
||
addGestureRecognizer(rightTapGestureRecognizer)
|
||
}
|
||
|
||
private func updateStateDependantViews() {
|
||
thumbView.image = thumbViewImages[state.rawValue] ?? thumbViewImages[UIControl.State.normal.rawValue]
|
||
|
||
if isFocused {
|
||
thumbView.transform = CGAffineTransform(scaleX: focusScaleFactor, y: focusScaleFactor)
|
||
} else {
|
||
thumbView.transform = CGAffineTransform.identity
|
||
}
|
||
}
|
||
|
||
@objc
|
||
private func controllerConnected(note: NSNotification) {
|
||
guard let controller = note.object as? GCController else { return }
|
||
guard let micro = controller.microGamepad else { return }
|
||
|
||
let threshold: Float = 0.7
|
||
micro.reportsAbsoluteDpadValues = true
|
||
micro.dpad.valueChangedHandler = { [weak self] _, x, _ in
|
||
if x < -threshold {
|
||
self?.dPadState = .left
|
||
} else if x > threshold {
|
||
self?.dPadState = .right
|
||
} else {
|
||
self?.dPadState = .select
|
||
}
|
||
}
|
||
}
|
||
|
||
@objc
|
||
private func handleDeceleratingTimer(timer: Timer) {
|
||
let centerX = thumbViewCenterXConstraintConstant + deceleratingVelocity * 0.01
|
||
let percent = centerX / Float(trackView.frame.width)
|
||
value = minimumValue + ((maximumValue - minimumValue) * percent)
|
||
|
||
if isContinuous {
|
||
sendActions(for: .valueChanged)
|
||
}
|
||
|
||
thumbViewCenterXConstraintConstant = Float(thumbViewCenterXConstraint.constant)
|
||
|
||
deceleratingVelocity *= decelerationRate
|
||
if !isFocused || abs(deceleratingVelocity) < 1 {
|
||
stopDeceleratingTimer()
|
||
}
|
||
|
||
viewModel.sliderPercentage = Double(percent)
|
||
viewModel.sliderIsScrubbing = false
|
||
}
|
||
|
||
private func stopDeceleratingTimer() {
|
||
deceleratingTimer?.invalidate()
|
||
deceleratingTimer = nil
|
||
deceleratingVelocity = 0
|
||
sendActions(for: .valueChanged)
|
||
}
|
||
|
||
private func isVerticalGesture(_ recognizer: UIPanGestureRecognizer) -> Bool {
|
||
let translation = recognizer.translation(in: self)
|
||
if abs(translation.y) > abs(translation.x) {
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// MARK: - Actions
|
||
|
||
@objc
|
||
private func panGestureWasTriggered(panGestureRecognizer: UIPanGestureRecognizer) {
|
||
|
||
if self.isVerticalGesture(panGestureRecognizer) {
|
||
return
|
||
}
|
||
|
||
let translation = Float(panGestureRecognizer.translation(in: self).x)
|
||
let velocity = Float(panGestureRecognizer.velocity(in: self).x)
|
||
|
||
switch panGestureRecognizer.state {
|
||
case .began:
|
||
viewModel.sliderIsScrubbing = true
|
||
|
||
stopDeceleratingTimer()
|
||
thumbViewCenterXConstraintConstant = Float(thumbViewCenterXConstraint.constant)
|
||
case .changed:
|
||
viewModel.sliderIsScrubbing = true
|
||
|
||
let centerX = thumbViewCenterXConstraintConstant + translation / panDampingValue
|
||
let percent = centerX / Float(trackView.frame.width)
|
||
value = minimumValue + ((maximumValue - minimumValue) * percent)
|
||
if isContinuous {
|
||
sendActions(for: .valueChanged)
|
||
}
|
||
|
||
viewModel.sliderPercentage = Double(percent)
|
||
case .ended, .cancelled:
|
||
|
||
thumbViewCenterXConstraintConstant = Float(thumbViewCenterXConstraint.constant)
|
||
|
||
if abs(velocity) > fineTunningVelocityThreshold {
|
||
let direction: Float = velocity > 0 ? 1 : -1
|
||
deceleratingVelocity = abs(velocity) > decelerationMaxVelocity ? decelerationMaxVelocity * direction : velocity
|
||
deceleratingTimer = Timer.scheduledTimer(
|
||
timeInterval: 0.01,
|
||
target: self,
|
||
selector: #selector(handleDeceleratingTimer(timer:)),
|
||
userInfo: nil,
|
||
repeats: true
|
||
)
|
||
} else {
|
||
viewModel.sliderIsScrubbing = false
|
||
stopDeceleratingTimer()
|
||
}
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
|
||
@objc
|
||
private func leftTapWasTriggered() {
|
||
// setValue(value-stepValue, animated: true)
|
||
viewModel.playerOverlayDelegate?.didSelectBackward()
|
||
}
|
||
|
||
@objc
|
||
private func rightTapWasTriggered() {
|
||
// setValue(value+stepValue, animated: true)
|
||
viewModel.playerOverlayDelegate?.didSelectForward()
|
||
}
|
||
|
||
override public func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
|
||
for press in presses {
|
||
switch press.type {
|
||
case .select where dPadState == .left:
|
||
panGestureRecognizer.isEnabled = false
|
||
leftTapWasTriggered()
|
||
case .select where dPadState == .right:
|
||
panGestureRecognizer.isEnabled = false
|
||
rightTapWasTriggered()
|
||
case .select:
|
||
panGestureRecognizer.isEnabled = false
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
panGestureRecognizer.isEnabled = true
|
||
super.pressesBegan(presses, with: event)
|
||
}
|
||
}
|