Path: blob/main/Signal/Calls/UserInterface/GroupCallViewController.swift
1 views
//
// Copyright 2020 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only
//
import Combine
import LibSignalClient
import SignalRingRTC
import SignalServiceKit
import SignalUI
import SwiftUI
import UIKit
// MARK: - GroupCallViewController
// TODO: Eventually add 1:1 call support to this view
// and replace CallViewController
final class GroupCallViewController: UIViewController {
// MARK: Properties
private let call: SignalCall
private let groupCall: GroupCall
private let ringRtcCall: SignalRingRTC.GroupCall
private lazy var callControlsConfirmationToastManager = CallControlsConfirmationToastManager(
presentingContainerView: callControlsConfirmationToastContainerView,
)
private lazy var bottomSheet: CallDrawerSheet = {
let dataSource: any CallDrawerSheetDataSource = switch groupCall.concreteType {
case .groupThread(let groupThreadCall):
GroupCallSheetDataSource(groupCall: groupThreadCall)
case .callLink(let callLinkCall):
GroupCallSheetDataSource(groupCall: callLinkCall)
}
return CallDrawerSheet(
call: call,
callSheetDataSource: dataSource,
callService: callService,
confirmationToastManager: callControlsConfirmationToastManager,
callControlsDelegate: self,
sheetPanDelegate: self,
callDrawerDelegate: self,
)
}()
private lazy var fullscreenLocalMemberAddOnsView = SupplementalCallControlsForFullscreenLocalMember(
call: call,
groupCall: groupCall,
callService: callService,
)
private lazy var callControlsConfirmationToastContainerView = UIView()
private var callService: CallService { AppEnvironment.shared.callService }
private var incomingCallControls: IncomingCallControls?
private lazy var callHeader = CallHeader(groupCall: groupCall, delegate: self)
private lazy var notificationView = GroupCallNotificationView(groupCall: groupCall)
/// A UIStackView which allows taps on its subviews, but passes taps outside of those or in explicitly ignored views through to the parent.
private class PassthroughStackView: UIStackView {
var ignoredViews: WeakArray<UIView> = []
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
// super.hitTest will return the deepest view hit, so if it's
// just `self`, the highest view, that means a subview wasn't hit.
let hitView = super.hitTest(point, with: event)
if let hitView, hitView == self || ignoredViews.contains(hitView) {
return nil
}
return hitView
}
}
/// A container view which allows taps in the given height range, but
/// passes through taps outside of it.
private class ApprovalStackContainerView: UIView {
var stackHeight: CGFloat = 0
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
let isPointInStack = (self.height - point.y) <= stackHeight
if isPointInStack {
return super.hitTest(point, with: event)
}
return nil
}
}
private let bottomVStack = PassthroughStackView()
private let videoOverflowContainer = UIView()
private let raisedHandsToastContainer = UIView()
private lazy var raisedHandsToast = RaisedHandsToast(call: self.groupCall)
private lazy var remoteMuteToast = RemoteMuteToast(call: self.groupCall)
private var approvalRequestActionsSubscription: AnyCancellable?
private lazy var callLinkApprovalViewModel: CallLinkApprovalViewModel = {
let viewModel = CallLinkApprovalViewModel()
approvalRequestActionsSubscription = viewModel.performRequestAction
.sink { [weak self] action, request in
guard let self else { return }
switch action {
case .approve:
self.ringRtcCall.approveUser(request.aci.rawUUID)
case .deny:
self.ringRtcCall.denyUser(request.aci.rawUUID)
case .viewDetails:
self.presentApprovalRequestDetails(approvalRequest: request)
}
}
return viewModel
}()
private let approvalStackContainer = ApprovalStackContainerView()
/// The `UIHostingController` with the approval request views in a stack.
private lazy var approvalStack = UIHostingController(rootView: VStack {
Spacer()
ApprovalRequestStack(
viewModel: self.callLinkApprovalViewModel,
didTapMore: { [weak self] requests in
self?.presentBulkApprovalSheet()
},
didChangeHeight: { [weak self] height in
self?.approvalStackHeightConstraint?.constant = height
self?.approvalStackContainer.stackHeight = height
self?.updateCallUI(shouldAnimateViewFrames: true)
},
)
})
/// A view used in `bottomVStack` that takes the height of the approval stack. Does not actually hold any content.
private let approvalStackHeightView = UIView()
private lazy var callLinkLobbyToastLabel = UILabel()
private lazy var callLinkLobbyToast: UIView = {
let backgroundView = UIVisualEffectView(effect: UIBlurEffect(style: .systemMaterialDark))
backgroundView.layer.cornerRadius = 10
backgroundView.clipsToBounds = true
backgroundView.contentView.addSubview(callLinkLobbyToastLabel)
backgroundView.contentView.layoutMargins = .init(margin: 12)
callLinkLobbyToastLabel.autoPinEdgesToSuperviewMargins()
callLinkLobbyToastLabel.font = .dynamicTypeFootnote
callLinkLobbyToastLabel.textColor = .white
callLinkLobbyToastLabel.textAlignment = .center
callLinkLobbyToastLabel.numberOfLines = 0
return backgroundView
}()
private lazy var videoGrid: GroupCallVideoGrid = {
let result = GroupCallVideoGrid(call: call, groupCall: groupCall)
result.memberViewErrorPresenter = self
return result
}()
private lazy var videoOverflow: GroupCallVideoOverflow = {
let result = GroupCallVideoOverflow(call: call, groupCall: groupCall, delegate: self)
result.memberViewErrorPresenter = self
return result
}()
private lazy var speakerView: CallMemberView = {
let result = CallMemberView(type: .remoteInGroup(.speaker))
result.errorPresenter = self
return result
}()
private lazy var localMemberView: CallMemberView = {
let result = CallMemberView(type: .local)
result.errorPresenter = self
result.animatableLocalMemberViewDelegate = self
return result
}()
private var didUserEverSwipeToSpeakerView: Bool
private var didUserEverSwipeToScreenShare: Bool
private let swipeToastView = GroupCallSwipeToastView()
private let speakerPage = UIView()
private let scrollView = UIScrollView()
private enum Page {
case grid
case speaker
}
private var page: Page = .grid {
didSet {
guard page != oldValue else { return }
videoOverflow.reloadData()
updateCallUI(shouldAnimateViewFrames: true)
ImpactHapticFeedback.impactOccurred(style: .light)
}
}
private let incomingReactionsView = IncomingReactionsView()
private var isCallMinimized = false {
didSet {
speakerView.isCallMinimized = isCallMinimized
scheduleBottomSheetTimeoutIfNecessary()
}
}
private var isAutoScrollingToScreenShare = false
private var isAnyRemoteDeviceScreenSharing = false {
didSet {
guard oldValue != isAnyRemoteDeviceScreenSharing else { return }
// Scroll to speaker view when presenting begins.
if isAnyRemoteDeviceScreenSharing {
isAutoScrollingToScreenShare = true
scrollView.setContentOffset(CGPoint(x: 0, y: speakerPage.frame.origin.y), animated: true)
}
}
}
private lazy var tapGesture = UITapGestureRecognizer(target: self, action: #selector(didTouchRootView))
private lazy var bottomVStackTopConstraint = self.bottomVStack.autoPinEdge(.bottom, to: .top, of: self.view)
private lazy var videoOverflowTrailingConstraint = videoOverflow.autoPinEdge(toSuperviewEdge: .trailing)
private var approvalStackHeightConstraint: NSLayoutConstraint?
private lazy var bottomSheetStateManager: GroupCallBottomSheetStateManager = {
return GroupCallBottomSheetStateManager(delegate: self)
}()
private var hasUnresolvedSafetyNumberMismatch = false
private var hasDismissed = false
private var membersAtJoin: Set<SignalServiceAddress>?
private static let keyValueStore = KeyValueStore(collection: "GroupCallViewController")
private static let didUserSwipeToSpeakerViewKey = "didUserSwipeToSpeakerView"
private static let didUserSwipeToScreenShareKey = "didUserSwipeToScreenShare"
/// When the local member view (which is displayed picture-in-picture) is
/// tapped, it expands. If the frame is expanded, its enlarged frame is
/// stored here. If the pip is not in the expanded state, this value is nil.
private var expandedPipFrame: CGRect?
/// Whether the local member view pip has an animation currently in progress.
private var isPipAnimationInProgress = false
/// Whether a relayout needs to occur after the pip animation completes.
/// This is true when we suspended an attempted relayout triggered during
/// the pip animation.
private var shouldRelayoutAfterPipAnimationCompletes = false
private var postAnimationUpdateMemberViewFramesSize: CGSize?
private lazy var reactionsBurstView: ReactionsBurstView = {
ReactionsBurstView(burstAligner: self.incomingReactionsView)
}()
private lazy var reactionsSink: ReactionsSink = {
ReactionsSink(reactionReceivers: [
self.incomingReactionsView,
self.reactionsBurstView,
])
}()
private lazy var callControlsOverflowView: CallControlsOverflowView = {
return CallControlsOverflowView(
call: self.call,
reactionSender: self.ringRtcCall,
reactionsSink: self.reactionsSink,
raiseHandSender: self.ringRtcCall,
emojiPickerSheetPresenter: self.bottomSheet,
callControlsOverflowPresenter: self,
)
}()
private var callControlsOverflowBottomConstraint: NSLayoutConstraint?
private var callControlsConfirmationToastContainerViewBottomConstraint: NSLayoutConstraint?
static func load(call: SignalCall, groupCall: GroupCall, tx: DBReadTransaction) -> GroupCallViewController {
let didUserEverSwipeToSpeakerView = keyValueStore.getBool(
didUserSwipeToSpeakerViewKey,
defaultValue: false,
transaction: tx,
)
let didUserEverSwipeToScreenShare = keyValueStore.getBool(
didUserSwipeToScreenShareKey,
defaultValue: false,
transaction: tx,
)
let phoneNumberSharingMode = SSKEnvironment.shared.udManagerRef.phoneNumberSharingMode(tx: tx).orDefault
return GroupCallViewController(
call: call,
groupCall: groupCall,
didUserEverSwipeToSpeakerView: didUserEverSwipeToSpeakerView,
didUserEverSwipeToScreenShare: didUserEverSwipeToScreenShare,
phoneNumberSharingMode: phoneNumberSharingMode,
)
}
init(
call: SignalCall,
groupCall: GroupCall,
didUserEverSwipeToSpeakerView: Bool,
didUserEverSwipeToScreenShare: Bool,
phoneNumberSharingMode: PhoneNumberSharingMode,
) {
// TODO: Eventually unify UI for group and individual calls
self.call = call
self.groupCall = groupCall
self.ringRtcCall = groupCall.ringRtcCall
self.didUserEverSwipeToSpeakerView = didUserEverSwipeToSpeakerView
self.didUserEverSwipeToScreenShare = didUserEverSwipeToScreenShare
super.init(nibName: nil, bundle: nil)
groupCall.addObserver(self)
groupCall.addObserver(AppEnvironment.shared.callLinkProfileKeySharingManager)
NotificationCenter.default.addObserver(
self,
selector: #selector(didBecomeActive),
name: UIApplication.didBecomeActiveNotification,
object: nil,
)
NotificationCenter.default.addObserver(
self,
selector: #selector(didCompleteAnySpamChallenge),
name: SpamChallengeResolver.didCompleteAnyChallenge,
object: nil,
)
self.callLinkLobbyToastLabel.text = switch phoneNumberSharingMode {
case .everybody:
OWSLocalizedString(
"CALL_LINK_LOBBY_SHARING_INFO_PHONE_NUMBER_SHARING_ON",
comment: "Text that appears on a toast in a call lobby before joining a call link informing the user what information will be shared with other call members when they have phone number sharing turned on.",
)
case .nobody:
OWSLocalizedString(
"CALL_LINK_LOBBY_SHARING_INFO_PHONE_NUMBER_SHARING_OFF",
comment: "Text that appears on a toast in a call lobby before joining a call link informing the user what information will be shared with other call members when they have phone number sharing turned off.",
)
}
}
static func presentLobby(forGroupId groupId: GroupIdentifier, videoMuted: Bool = false) {
self._presentLobby { viewController, modalViewController -> (() -> Void)? in
return await self._prepareLobby(
from: viewController,
modalViewController: modalViewController,
shouldAskForCameraPermission: !videoMuted,
buildAndStartConnecting: {
let callService = AppEnvironment.shared.callService!
return callService.buildAndConnectGroupCall(for: groupId, isVideoMuted: videoMuted)
},
)
}
}
static func presentLobby(
for callLink: CallLink,
callLinkStateRetrievalStrategy: CallService.CallLinkStateRetrievalStrategy = .fetch,
) {
self._presentLobby { viewController, modalViewController in
do {
return try await self._prepareLobby(
from: viewController,
modalViewController: modalViewController,
shouldAskForCameraPermission: true,
buildAndStartConnecting: {
let callService = AppEnvironment.shared.callService!
return try await callService.buildAndConnectCallLinkCall(
callLink: callLink,
callLinkStateRetrievalStrategy: callLinkStateRetrievalStrategy,
)
},
)
} catch {
Logger.warn("Call link lobby presentation failed with error \(error)")
return {
OWSActionSheets.showActionSheet(
title: CallStrings.callLinkErrorSheetTitle,
message: OWSLocalizedString(
"CALL_LINK_JOIN_CALL_FAILURE_SHEET_DESCRIPTION",
comment: "Description of sheet presented when joining call from call link sheet fails.",
),
)
}
}
}
}
private static func _presentLobby(
prepareLobby: @escaping @MainActor (_ viewController: UIViewController, _ modalViewController: UIViewController) async -> (() -> Void)?,
) {
guard let frontmostViewController = UIApplication.shared.frontmostViewController else {
owsFail("Can't start a call if there's no view controller")
}
ModalActivityIndicatorViewController.present(
fromViewController: frontmostViewController,
title: CommonStrings.preparingModal,
canCancel: false,
presentationDelay: 0.25,
asyncBlock: { modal in
let presentLobbyOrError = await prepareLobby(frontmostViewController, modal)
modal.dismissIfNotCanceled(completionIfNotCanceled: presentLobbyOrError ?? {})
},
)
}
private static func _prepareLobby(
from viewController: UIViewController,
modalViewController: UIViewController,
shouldAskForCameraPermission: Bool,
buildAndStartConnecting: () async throws -> (SignalCall, GroupCall)?,
) async rethrows -> (() -> Void)? {
do throws(CallStarter.PrepareToStartCallError) {
_ = try await CallStarter.prepareToStartCall(
from: modalViewController,
shouldAskForCameraPermission: shouldAskForCameraPermission,
)
} catch {
return {
CallStarter.showPrepareToStartCallError(error, from: viewController)
}
}
guard let (call, groupCall) = try await buildAndStartConnecting() else {
owsFailDebug("Can't show lobby if the call can't start")
return nil
}
let vc = SSKEnvironment.shared.databaseStorageRef.read { tx in
return GroupCallViewController.load(call: call, groupCall: groupCall, tx: tx)
}
return {
vc.modalTransitionStyle = .crossDissolve
AppEnvironment.shared.windowManagerRef.startCall(viewController: vc)
}
}
required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
// MARK: Lifecycle
override func loadView() {
view = UIView()
view.clipsToBounds = true
view.backgroundColor = .ows_black
scrollView.delegate = self
view.addSubview(scrollView)
scrollView.isPagingEnabled = true
scrollView.showsVerticalScrollIndicator = false
scrollView.contentInsetAdjustmentBehavior = .never
scrollView.alwaysBounceVertical = false
scrollView.autoPinEdgesToSuperviewEdges()
view.addSubview(callHeader)
callHeader.autoPinWidthToSuperview()
callHeader.autoPinEdge(toSuperviewEdge: .top)
view.addSubview(notificationView)
notificationView.autoPinEdgesToSuperviewEdges()
view.addSubview(self.bottomVStack)
self.bottomVStack.autoPinWidthToSuperview()
self.bottomVStack.axis = .vertical
self.bottomVStack.spacing = Constants.bottomVStackSpacing
self.bottomVStack.preservesSuperviewLayoutMargins = true
self.bottomVStack.alignment = .center
self.bottomVStack.ignoredViews.append(fullscreenLocalMemberAddOnsView)
switch groupCall.concreteType {
case .groupThread:
break
case .callLink:
// Lobby text
self.bottomVStack.addArrangedSubview(self.callLinkLobbyToast)
self.callLinkLobbyToast.autoPinWidthToSuperviewMargins()
// Approvals
self.addChild(self.approvalStack)
approvalStackContainer.addSubview(self.approvalStack.view)
self.approvalStack.view.autoPinEdgesToSuperviewEdges()
self.view.addSubview(approvalStackContainer)
self.approvalStack.view.backgroundColor = .clear
self.approvalStack.didMove(toParent: self)
// If passthroughView changed height to match the height of its content,
// the SwiftUI content would jump around as the UIView's height changes,
// so instead, make it taller than it needs, and pin its bottom to a
// placeholder view that adjusts height based on the content.
self.bottomVStack.addArrangedSubview(self.approvalStackHeightView)
self.approvalStackHeightConstraint = self.approvalStackHeightView
.autoSetDimension(.height, toSize: 0)
self.pinWidthWithBottomSheetMaxWidth(approvalStackContainer)
approvalStackContainer.autoHCenterInSuperview()
approvalStackContainer.autoSetDimension(.height, toSize: 300)
approvalStackContainer.autoPinEdge(.bottom, to: .bottom, of: self.approvalStackHeightView)
}
videoOverflowContainer.addSubview(self.videoOverflow)
self.bottomVStack.addArrangedSubview(videoOverflowContainer)
self.bottomVStack.ignoredViews.append(videoOverflowContainer)
self.videoOverflowContainer.autoPinWidthToSuperview()
self.videoOverflow.autoPinHeightToSuperview()
self.videoOverflow.autoPinEdge(toSuperviewEdge: .leading)
self.bottomVStack.insertArrangedSubview(raisedHandsToastContainer, at: 0)
self.bottomVStack.ignoredViews.append(raisedHandsToastContainer)
raisedHandsToastContainer.layoutMargins = .init(margin: 0)
raisedHandsToastContainer.preservesSuperviewLayoutMargins = true
raisedHandsToastContainer.isHiddenInStackView = true
raisedHandsToastContainer.addSubview(raisedHandsToast)
self.pinWidthWithBottomSheetMaxWidth(raisedHandsToastContainer)
raisedHandsToast.autoPinEdges(toSuperviewMarginsExcludingEdge: .leading)
raisedHandsToast.autoPinEdge(toSuperviewMargin: .leading, relation: .greaterThanOrEqual)
raisedHandsToast.horizontalPinConstraint = raisedHandsToast.autoPinEdge(toSuperviewMargin: .leading)
raisedHandsToast.delegate = self
view.addSubview(remoteMuteToast)
remoteMuteToast.autoPinEdgesToSuperviewEdges()
scrollView.addSubview(videoGrid)
scrollView.addSubview(speakerPage)
view.addSubview(incomingReactionsView)
incomingReactionsView.autoPinEdge(.leading, to: .leading, of: view, withOffset: 22)
incomingReactionsView.autoPinEdge(.bottom, to: .top, of: self.bottomVStack, withOffset: -16)
incomingReactionsView.widthAnchor.constraint(equalToConstant: IncomingReactionsView.Constants.viewWidth).isActive = true
incomingReactionsView.heightAnchor.constraint(equalToConstant: IncomingReactionsView.viewHeight).isActive = true
scrollView.addSubview(swipeToastView)
swipeToastView.autoPinEdge(.bottom, to: .bottom, of: videoGrid, withOffset: -22)
swipeToastView.autoHCenterInSuperview()
swipeToastView.autoPinEdge(toSuperviewMargin: .leading, relation: .greaterThanOrEqual)
swipeToastView.autoPinEdge(toSuperviewMargin: .trailing, relation: .greaterThanOrEqual)
view.addSubview(callControlsConfirmationToastContainerView)
callControlsConfirmationToastContainerView.autoHCenterInSuperview()
view.addSubview(callControlsOverflowView)
callControlsOverflowView.isHidden = true
if UIDevice.current.isIPad {
callControlsOverflowView.centerXAnchor.constraint(equalTo: self.view.centerXAnchor).isActive = true
} else {
callControlsOverflowView.autoPinEdge(
.trailing,
to: .trailing,
of: view,
withOffset: -12,
)
}
self.callControlsConfirmationToastContainerViewBottomConstraint = callControlsConfirmationToastContainerView.autoPinEdge(
.bottom,
to: .bottom,
of: self.view,
withOffset: callControlsConfirmationToastContainerViewBottomConstraintConstant,
)
self.callControlsOverflowBottomConstraint = self.callControlsOverflowView.autoPinEdge(
.bottom,
to: .bottom,
of: self.view,
withOffset: callControlsOverflowBottomConstraintConstant,
)
view.addSubview(reactionsBurstView)
reactionsBurstView.autoPinEdgesToSuperviewEdges()
view.addGestureRecognizer(tapGesture)
}
override func viewDidLoad() {
super.viewDidLoad()
NotificationCenter.default.addObserver(
self,
selector: #selector(otherUsersProfileChanged(notification:)),
name: UserProfileNotifications.otherUsersProfileDidChange,
object: nil,
)
}
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
super.viewWillTransition(to: size, with: coordinator)
let wasOnSpeakerPage = self.page == .speaker
coordinator.animate(alongsideTransition: { _ in
self.updateCallUI(size: size)
self.videoGrid.reloadData()
self.videoOverflow.reloadData()
self.scrollView.contentOffset = wasOnSpeakerPage ? CGPoint(x: 0, y: size.height) : .zero
}, completion: nil)
}
private var hasAppeared = false
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
guard !hasAppeared else { return }
hasAppeared = true
callService.sendInitialPhoneOrientationNotification()
if let splitViewSnapshot = SignalApp.shared.snapshotSplitViewController(afterScreenUpdates: false) {
view.superview?.insertSubview(splitViewSnapshot, belowSubview: view)
splitViewSnapshot.autoPinEdgesToSuperviewEdges()
view.transform = .scale(1.5)
view.alpha = 0
UIView.animate(withDuration: 0.2, animations: {
self.view.alpha = 1
self.view.transform = .identity
}) { _ in
splitViewSnapshot.removeFromSuperview()
}
}
}
private var isReadyToHandleObserver = false
override func viewIsAppearing(_ animated: Bool) {
super.viewIsAppearing(animated)
self.isReadyToHandleObserver = true
updateCallUI()
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
if hasUnresolvedSafetyNumberMismatch, CurrentAppContext().isAppForegroundAndActive() {
// If we're not active yet, this will be handled by the `didBecomeActive` callback.
resolveSafetyNumberMismatch()
}
}
override func present(_ viewControllerToPresent: UIViewController, animated flag: Bool, completion: (() -> Void)? = nil) {
super.present(viewControllerToPresent, animated: flag, completion: completion)
scheduleBottomSheetTimeoutIfNecessary()
}
private var bottomSheetIsPresented: Bool {
bottomSheet.presentingViewController != nil
}
private func presentBottomSheet() {
guard !bottomSheetIsPresented else { return }
bottomSheet.setBottomSheetMinimizedHeight()
present(self.bottomSheet, animated: true)
}
private func dismissBottomSheet(animated: Bool = true) {
guard bottomSheetIsPresented else { return }
bottomSheet.dismiss(animated: animated)
}
@objc
private func didBecomeActive() {
if hasUnresolvedSafetyNumberMismatch {
resolveSafetyNumberMismatch()
}
}
@objc
private func didCompleteAnySpamChallenge() {
AppEnvironment.shared.callLinkProfileKeySharingManager.sendProfileKeyToParticipants(ofCall: self.groupCall)
self.ringRtcCall.resendMediaKeys()
}
// MARK: Call members
private func updateScrollViewFrames(size: CGSize? = nil) {
view.layoutIfNeeded()
let size = size ?? view.frame.size
if !self.hasAtLeastTwoOthers {
videoGrid.frame = .zero
videoGrid.isHidden = true
speakerPage.frame = CGRect(
x: 0,
y: 0,
width: size.width,
height: size.height,
)
scrollView.contentSize = size
scrollView.contentOffset = .zero
scrollView.isScrollEnabled = false
} else {
let wasVideoGridHidden = videoGrid.isHidden
let hasOverflowMembersInGridView = videoGrid.maxItems < ringRtcCall.remoteDeviceStates.count
let overflowGridHeight = hasOverflowMembersInGridView ? videoOverflow.height + 27 : 0
scrollView.isScrollEnabled = true
videoGrid.isHidden = false
let height: CGFloat
let offset: CGFloat
switch bottomSheetStateManager.bottomSheetState {
case .callControlsAndOverflow, .callControls, .callInfo, .transitioning:
offset = self.bottomSheet.minimizedHeight
case .hidden:
offset = 16
}
height = size.height - view.safeAreaInsets.top - offset - overflowGridHeight
videoGrid.frame = CGRect(
x: 0,
y: view.safeAreaInsets.top,
width: size.width,
height: height,
)
speakerPage.frame = CGRect(
x: 0,
y: size.height,
width: size.width,
height: size.height,
)
scrollView.contentSize = CGSize(width: size.width, height: size.height * 2)
if wasVideoGridHidden {
scrollView.contentOffset = .zero
}
}
}
func updateVideoOverflowTrailingConstraint() {
var trailingConstraintConstant = -(GroupCallVideoOverflow.itemHeight * ReturnToCallViewController.inherentPipSize.aspectRatio + 4)
if view.width + trailingConstraintConstant > videoOverflow.contentSize.width {
trailingConstraintConstant += 16
}
videoOverflowTrailingConstraint.constant = trailingConstraintConstant
view.layoutIfNeeded()
}
@discardableResult
private func pinWidthWithBottomSheetMaxWidth(_ view: UIView) -> [NSLayoutConstraint] {
let maxWidthConstraint = view.autoSetDimension(
.width,
toSize: bottomSheet.maxWidth,
relation: .lessThanOrEqual,
)
let edgesConstraints = view.autoPinWidthToSuperviewMargins(relation: .lessThanOrEqual)
let edgesConstraints2 = view.autoPinWidthToSuperviewMargins(relation: .equal)
edgesConstraints2.forEach { $0.priority = .defaultHigh }
return [maxWidthConstraint] + edgesConstraints + edgesConstraints2
}
private var addOnsConstraints: [NSLayoutConstraint]?
private func constrainAddOnsOutsideBottomVStack() {
addOnsConstraints.map(fullscreenLocalMemberAddOnsView.removeConstraints(_:))
addOnsConstraints = [
fullscreenLocalMemberAddOnsView.autoPinLeadingToSuperviewMargin(),
fullscreenLocalMemberAddOnsView.autoPinTrailingToSuperviewMargin(),
fullscreenLocalMemberAddOnsView.autoPinEdge(toSuperviewSafeArea: .bottom, withInset: Constants.flipCamButtonTrailingToSuperviewEdgePadding),
]
}
private func constrainAddOnsInsideBottomVStack() {
addOnsConstraints.map(fullscreenLocalMemberAddOnsView.removeConstraints(_:))
addOnsConstraints = pinWidthWithBottomSheetMaxWidth(fullscreenLocalMemberAddOnsView)
}
private func updateAddOnsViewPosition() {
let canFitNextToDrawer = view.width >= bottomSheet.maxWidth + view.layoutMargins.totalWidth + view.layoutMargins.trailing + 48
if canFitNextToDrawer {
guard fullscreenLocalMemberAddOnsView.superview != view else { return }
bottomVStack.removeArrangedSubview(fullscreenLocalMemberAddOnsView)
view.addSubview(fullscreenLocalMemberAddOnsView)
constrainAddOnsOutsideBottomVStack()
} else {
guard fullscreenLocalMemberAddOnsView.superview != bottomVStack else { return }
fullscreenLocalMemberAddOnsView.removeFromSuperview()
if
case .callLink = groupCall.concreteType,
let toastIndex = bottomVStack.arrangedSubviews.firstIndex(of: callLinkLobbyToast)
{
bottomVStack.insertArrangedSubview(fullscreenLocalMemberAddOnsView, at: toastIndex)
} else {
bottomVStack.addArrangedSubview(fullscreenLocalMemberAddOnsView)
}
constrainAddOnsInsideBottomVStack()
}
}
private var shouldHideAddOnsView: Bool {
!groupCall.isJustMe || (groupCall.isJustMe && call.isOutgoingVideoMuted) || hasDismissed
}
private func updateBottomVStackItems() {
let hasRaisedHands = !self.raisedHandsToast.raisedHands.isEmpty
self.raisedHandsToastContainer.isHiddenInStackView = !hasRaisedHands
self.fullscreenLocalMemberAddOnsView.isHiddenInStackView = self.shouldHideAddOnsView
self.updateAddOnsViewPosition()
/// If there are no approval requests, `callLinkApprovalViewModel`'s height
/// will be zero, but we don't want to hide it because the approval view
/// itself is pinned to it, and we want it to retain its position when
/// the last item animates out.
let hasApprovalRequests: Bool = switch self.groupCall.concreteType {
case .groupThread: false
case .callLink: !self.callLinkApprovalViewModel.requests.isEmpty
}
let hasOverflowMembers = self.videoOverflow.hasOverflowMembers
if hasOverflowMembers {
// Move video overflow to bottom
if self.bottomVStack.arrangedSubviews.last != self.videoOverflowContainer {
self.bottomVStack.removeArrangedSubview(self.videoOverflowContainer)
self.bottomVStack.addArrangedSubview(self.videoOverflowContainer)
}
} else {
// Move video overflow to top
if self.bottomVStack.arrangedSubviews.first != self.videoOverflowContainer {
self.bottomVStack.removeArrangedSubview(self.videoOverflowContainer)
self.bottomVStack.insertArrangedSubview(self.videoOverflowContainer, at: 0)
}
}
enum Item { case raisedHands, approvals }
func setSpacing(_ spacing: CGFloat, after item: Item) {
let view: UIView = switch item {
case .raisedHands: self.raisedHandsToastContainer
case .approvals: self.approvalStackHeightView
}
self.bottomVStack.setCustomSpacing(spacing, after: view)
}
let overflowNeedsPadding = hasOverflowMembers && self.page == .grid
switch (overflowNeedsPadding, hasRaisedHands, hasApprovalRequests) {
case (false, _, true):
setSpacing(Constants.bottomVStackSpacing, after: .raisedHands)
setSpacing(Constants.bottomVStackSpacing, after: .approvals)
case (false, _, false):
setSpacing(Constants.bottomVStackSpacing, after: .raisedHands)
setSpacing(0, after: .approvals)
case (true, _, true):
setSpacing(Constants.bottomVStackSpacing, after: .raisedHands)
setSpacing(Constants.videoOverflowExtraSpacing, after: .approvals)
case (true, true, false):
setSpacing(Constants.videoOverflowExtraSpacing, after: .raisedHands)
setSpacing(0, after: .approvals)
case (true, false, false):
// Raised hands view is hidden
setSpacing(0, after: .approvals)
}
}
private enum Constants {
static let spacingTopRaiseHandToastToBottomLocalPip: CGFloat = 12
static let flipCamButtonTrailingToSuperviewEdgePadding: CGFloat = 34
static let bottomVStackSpacing: CGFloat = 8
static let videoOverflowExtraSpacing: CGFloat = 24
}
private func updateMemberViewFrames(
size: CGSize? = nil,
shouldRepositionBottomVStack: Bool = true,
) {
guard !isPipAnimationInProgress else {
// Wait for the pip to reach its new size before re-laying out.
// Otherwise the pip snaps back to its size at the start of the
// animation, effectively undoing it. When the animation is
// complete, we'll call `updateMemberViewFrames`.
self.shouldRelayoutAfterPipAnimationCompletes = true
self.postAnimationUpdateMemberViewFramesSize = size
return
}
view.layoutIfNeeded()
let size = size ?? view.frame.size
let yMax: CGFloat
if shouldRepositionBottomVStack {
switch bottomSheetStateManager.bottomSheetState {
case .callControlsAndOverflow, .callControls, .callInfo, .transitioning:
yMax = size.height - bottomSheet.minimizedHeight - 16
case .hidden:
yMax = size.height - 32
}
bottomVStackTopConstraint.constant = yMax
} else {
yMax = bottomVStackTopConstraint.constant
}
updateVideoOverflowTrailingConstraint()
localMemberView.applyChangesToCallMemberViewAndVideoView { view in
view.removeFromSuperview()
}
speakerView.applyChangesToCallMemberViewAndVideoView { view in
view.removeFromSuperview()
}
if groupCall.isJustMe {
localMemberView.applyChangesToCallMemberViewAndVideoView { view in
speakerPage.addSubview(view)
view.frame = CGRect(origin: .zero, size: size)
}
} else {
speakerView.applyChangesToCallMemberViewAndVideoView { view in
speakerPage.addSubview(view)
view.autoPinEdgesToSuperviewEdges()
}
localMemberView.applyChangesToCallMemberViewAndVideoView { aView in
view.insertSubview(aView, belowSubview: callControlsConfirmationToastContainerView)
}
let pipSize = CallMemberView.pipSize(
expandedPipFrame: self.expandedPipFrame,
remoteDeviceCount: ringRtcCall.remoteDeviceStates.count,
)
let y: CGFloat
if nil != expandedPipFrame {
// Special case necessary because when the pip is
// expanded, the pip height does not follow along
// with that of the video overflow, which is tiny.
if self.raisedHandsToastContainer.isHiddenInStackView || (self.videoOverflow.hasOverflowMembers && self.page == .grid) {
// Bottom of pip should align with bottom of overflow (whether the overflow is hidden or not).
y = yMax - pipSize.height
} else {
// Bottom of pip should align with top of raised hand toast, plus padding.
y = yMax - pipSize.height - raisedHandsToastContainer.height - Constants.spacingTopRaiseHandToastToBottomLocalPip
}
} else {
let overflowY = videoOverflow.convert(videoOverflow.bounds.origin, to: self.view).y
let overflowPipHeightDifference = pipSize.height - videoOverflow.height
y = overflowY - overflowPipHeightDifference
}
localMemberView.applyChangesToCallMemberViewAndVideoView { view in
view.frame = CGRect(
x: size.width - pipSize.width - 16,
y: y,
width: pipSize.width,
height: pipSize.height,
)
}
flipCameraTooltipManager.presentTooltipIfNecessary(
fromView: self.view,
widthReferenceView: self.view,
tailReferenceView: localMemberView,
tailDirection: .down,
isVideoMuted: call.isOutgoingVideoMuted,
)
}
}
// MARK: Other UI
private func updateSwipeToastView() {
let isSpeakerViewAvailable = self.hasAtLeastTwoOthers
guard isSpeakerViewAvailable else {
swipeToastView.isHidden = true
return
}
if isAnyRemoteDeviceScreenSharing {
if didUserEverSwipeToScreenShare {
swipeToastView.isHidden = true
return
}
} else if didUserEverSwipeToSpeakerView {
swipeToastView.isHidden = true
return
}
swipeToastView.alpha = 1.0 - (scrollView.contentOffset.y / view.height)
swipeToastView.text = isAnyRemoteDeviceScreenSharing
? OWSLocalizedString(
"GROUP_CALL_SCREEN_SHARE_TOAST",
comment: "Toast view text informing user about swiping to screen share",
)
: OWSLocalizedString(
"GROUP_CALL_SPEAKER_VIEW_TOAST",
comment: "Toast view text informing user about swiping to speaker view",
)
if scrollView.contentOffset.y >= view.height {
swipeToastView.isHidden = true
if isAnyRemoteDeviceScreenSharing {
if !isAutoScrollingToScreenShare {
didUserEverSwipeToScreenShare = true
SSKEnvironment.shared.databaseStorageRef.asyncWrite { writeTx in
Self.keyValueStore.setBool(true, key: Self.didUserSwipeToScreenShareKey, transaction: writeTx)
}
}
} else {
didUserEverSwipeToSpeakerView = true
SSKEnvironment.shared.databaseStorageRef.asyncWrite { writeTx in
Self.keyValueStore.setBool(true, key: Self.didUserSwipeToSpeakerViewKey, transaction: writeTx)
}
}
} else if swipeToastView.isHidden {
swipeToastView.alpha = 0
swipeToastView.isHidden = false
UIView.animate(withDuration: 0.2, delay: 3.0, options: []) {
self.swipeToastView.alpha = 1
}
}
}
private var flipCameraTooltipManager = FlipCameraTooltipManager(db: DependenciesBridge.shared.db)
private var hasShownCallControls = false
private func updateCallUI(
size: CGSize? = nil,
shouldAnimateViewFrames: Bool = false,
bottomSheetChangedStateFrom oldBottomSheetState: BottomSheetState? = nil,
) {
let isFullScreen = groupCall.isJustMe
localMemberView.configure(
call: call,
isFullScreen: isFullScreen,
)
localMemberView.applyChangesToCallMemberViewAndVideoView { view in
// In the context of `isCallInPip`, the "pip" refers to when the entire call is in a pip
// (ie, minimized in the app). This is not to be confused with the local member view pip
// (ie, when the call is full screen and the local user is displayed in a pip).
// The following line disallows having a [local member] pip within a [call] pip.
view.isHidden = !isJustMe && AppEnvironment.shared.windowManagerRef.isCallInPip
}
if let speakerState = ringRtcCall.remoteDeviceStates.sortedBySpeakerTime.first {
speakerView.configure(
call: call,
remoteGroupMemberDeviceState: speakerState,
)
} else {
speakerView.clearConfiguration()
}
guard !isCallMinimized else { return }
if
case .groupThread(let groupThreadCall) = groupCall.concreteType,
groupThreadCall.groupCallRingState.isIncomingRing
{
dismissBottomSheet(animated: false)
createIncomingCallControlsIfNeeded().isHidden = false
// These views aren't visible at this point, but we need them to be configured anyway.
updateMemberViewFrames(size: size)
updateScrollViewFrames(size: size)
return
} else if !self.hasShownCallControls {
self.presentBottomSheet()
self.hasShownCallControls = true
}
if let incomingCallControls, !incomingCallControls.isHidden {
// We were showing the incoming call controls, but now we don't want to.
// To make sure all views transition properly, pretend we were showing the regular controls all along.
presentBottomSheet()
incomingCallControls.isHidden = true
}
self.callControlDisplayStateDidChange(
oldState: oldBottomSheetState ?? self.bottomSheetStateManager.bottomSheetState,
newState: self.bottomSheetStateManager.bottomSheetState,
size: size,
shouldAnimateViewFrames: shouldAnimateViewFrames,
)
// Update constraints that hug call controls sheet
callControlsOverflowBottomConstraint?.constant = callControlsOverflowBottomConstraintConstant
callControlsConfirmationToastContainerViewBottomConstraint?.constant = callControlsConfirmationToastContainerViewBottomConstraintConstant
if groupCall.isJustMe {
flipCameraTooltipManager.dismissTooltip()
}
updateSwipeToastView()
}
private var callControlsOverflowBottomConstraintConstant: CGFloat {
-self.bottomSheet.minimizedHeight - 12
}
private var callControlsConfirmationToastContainerViewBottomConstraintConstant: CGFloat {
return -self.bottomSheet.minimizedHeight - 16
}
private func callControlDisplayStateDidChange(
oldState: BottomSheetState,
newState: BottomSheetState,
size: CGSize?,
shouldAnimateViewFrames: Bool,
) {
func updateFrames(controlsAreHidden: Bool, shouldRepositionBottomVStack: Bool = true) {
let raisedHandsToastWasAlreadyHidden = self.raisedHandsToastContainer.isHidden
let action: () -> Void = {
self.updateBottomVStackItems()
self.updateMemberViewFrames(
size: size,
shouldRepositionBottomVStack: shouldRepositionBottomVStack,
)
self.updateScrollViewFrames(size: size)
}
let completion: () -> Void = {
if
self.raisedHandsToast.raisedHands.isEmpty,
!raisedHandsToastWasAlreadyHidden
{
self.raisedHandsToast.wasHidden()
}
}
if shouldAnimateViewFrames {
let animator = UIViewPropertyAnimator(duration: 0.3, springDamping: 1, springResponse: 0.3)
animator.addAnimations(action)
animator.addCompletion { _ in
completion()
}
animator.startAnimation()
} else {
action()
completion()
}
}
switch oldState {
case .callControlsAndOverflow:
switch newState {
case .callControlsAndOverflow:
updateFrames(controlsAreHidden: false)
case .callControls:
self.callControlsOverflowView.animateOut()
updateFrames(controlsAreHidden: false)
case .hidden:
// This can happen if you tap the root view fast enough in succession.
animateCallControls(
hideCallControls: true,
size: size,
)
self.callControlsOverflowView.animateOut()
case .callInfo, .transitioning:
self.callControlsOverflowView.animateOut()
}
case .callControls:
switch newState {
case .callControlsAndOverflow:
self.callControlsOverflowView.animateIn()
updateFrames(controlsAreHidden: false)
case .callControls:
updateFrames(controlsAreHidden: false)
case .hidden:
animateCallControls(
hideCallControls: true,
size: size,
)
case .callInfo, .transitioning:
break
}
case .hidden:
switch newState {
case .callControlsAndOverflow:
owsFailDebug("Impossible bottomSheetStateManager.bottomSheetState transition")
// But if you must...
animateCallControls(
hideCallControls: false,
size: size,
)
self.callControlsOverflowView.animateIn()
case .callControls, .callInfo, .transitioning:
animateCallControls(
hideCallControls: false,
size: size,
)
case .hidden:
updateFrames(controlsAreHidden: true)
}
case .callInfo, .transitioning:
switch newState {
case .callControlsAndOverflow:
self.callControlsOverflowView.animateIn()
case .callControls:
updateFrames(controlsAreHidden: false, shouldRepositionBottomVStack: false)
case .callInfo, .transitioning:
updateFrames(controlsAreHidden: true, shouldRepositionBottomVStack: false)
case .hidden:
owsFailDebug("Impossible bottomSheetStateManager.bottomSheetState transition")
}
}
}
private func animateCallControls(
hideCallControls: Bool,
size: CGSize?,
) {
if hideCallControls {
dismissBottomSheet()
} else {
bottomSheet.setBottomSheetMinimizedHeight()
presentBottomSheet()
}
bottomSheet.transitionCoordinator?.animateAlongsideTransition(in: view, animation: { _ in
self.callHeader.alpha = hideCallControls ? 0 : 1
self.updateBottomVStackItems()
self.updateMemberViewFrames(size: size)
self.updateScrollViewFrames(size: size)
self.view.layoutIfNeeded()
}, completion: { _ in
self.callHeader.isHidden = hideCallControls
// If a hand is raised during this animation, the toast will be
// positioned wrong unless this is called again in the completion.
self.updateBottomVStackItems()
if self.raisedHandsToast.raisedHands.isEmpty {
self.raisedHandsToast.wasHidden()
}
})
callHeader.isHidden = false
}
private func dismissCall(shouldHangUp: Bool = true) {
if shouldHangUp {
callService.callUIAdapter.localHangupCall(call)
}
didHangupCall()
}
private func didHangupCall() {
guard !hasDismissed else {
return
}
hasDismissed = true
guard self.isViewLoaded else {
// This can happen if the call is canceled before it's ever shown (ie a
// ring that's not answered).
AppEnvironment.shared.windowManagerRef.endCall(viewController: self)
return
}
bottomSheetStateManager.submitState(.callControls)
self.raisedHandsToast.raisedHands.removeAll()
self.callLinkApprovalViewModel.requests.removeAll()
guard
let splitViewSnapshot = SignalApp.shared.snapshotSplitViewController(afterScreenUpdates: false),
view.superview?.insertSubview(splitViewSnapshot, belowSubview: view) != nil
else {
// This can happen if we're in the background when the call is dismissed (say, from CallKit).
AppEnvironment.shared.windowManagerRef.endCall(viewController: self)
return
}
splitViewSnapshot.autoPinEdgesToSuperviewEdges()
bottomSheet.cancelAnimationAndUpdateConstraints()
bottomSheet.dismiss(animated: true) { [self] in
dismissSelf(splitViewSnapshot: splitViewSnapshot)
}
}
private func dismissSelf(splitViewSnapshot: UIView) {
UIView.animate(withDuration: 0.2, animations: {
self.view.alpha = 0
}) { _ in
splitViewSnapshot.removeFromSuperview()
AppEnvironment.shared.windowManagerRef.endCall(viewController: self)
}
}
override var preferredStatusBarStyle: UIStatusBarStyle {
return .lightContent
}
override var prefersHomeIndicatorAutoHidden: Bool {
return true
}
private var hasAtLeastTwoOthers: Bool {
switch ringRtcCall.localDeviceState.joinState {
case .notJoined, .joining, .pending:
return false
case .joined:
return ringRtcCall.remoteDeviceStates.count >= 2
}
}
/// The view controller to present new view controllers from.
private var presenter: UIViewController {
presentedViewController ?? self
}
private func presentApprovalRequestDetails(approvalRequest: CallLinkApprovalRequest) {
let presenter = self.presenter
// Present request details on top of the bulk request sheet by checking
// one layer deeper than `presenter`.
let presentingViewController = presenter.presentedViewController ?? presenter
CallLinkApprovalRequestDetailsSheet(
approvalRequest: approvalRequest,
approvalViewModel: self.callLinkApprovalViewModel,
)
.present(from: presentingViewController, dismissalDelegate: self)
}
private func presentBulkApprovalSheet() {
CallLinkBulkApprovalSheet(viewModel: callLinkApprovalViewModel)
.present(from: presenter, dismissalDelegate: self)
}
// MARK: - Drawer timeout
@objc
private func didTouchRootView(sender: UIGestureRecognizer) {
switch self.bottomSheetStateManager.bottomSheetState {
case .callControlsAndOverflow, .hidden:
bottomSheetStateManager.submitState(.callControls)
case .callControls:
if bottomSheetMustBeVisible {
return
}
bottomSheetStateManager.submitState(.hidden)
case .callInfo:
bottomSheetStateManager.submitState(.callControls)
self.bottomSheet.minimizeHeight()
case .transitioning:
break
}
}
private var bottomSheetMustBeVisible: Bool {
return groupCall.isJustMe
}
private var sheetTimeoutTimer: Timer?
private func scheduleBottomSheetTimeoutIfNecessary() {
let shouldAutomaticallyDismissDrawer: Bool = {
switch self.bottomSheetStateManager.bottomSheetState {
case .callControlsAndOverflow, .hidden:
return false
case .callControls:
break
case .callInfo, .transitioning:
return false
}
if bottomSheetMustBeVisible {
return false
}
if isCallMinimized {
return false
}
let isPresentingOtherSheet = presentedViewController != nil && presentedViewController != bottomSheet
let otherSheetIsPresented = isPresentingOtherSheet || bottomSheet.presentedViewController != nil
if otherSheetIsPresented {
return false
}
return true
}()
guard shouldAutomaticallyDismissDrawer else {
cancelBottomSheetTimeout()
return
}
guard sheetTimeoutTimer == nil else { return }
sheetTimeoutTimer = .scheduledTimer(withTimeInterval: 5, repeats: false) { [weak self] _ in
self?.timeoutBottomSheet()
}
}
private func timeoutBottomSheet() {
self.sheetTimeoutTimer = nil
bottomSheetStateManager.submitState(.hidden)
}
private func cancelBottomSheetTimeout() {
sheetTimeoutTimer?.invalidate()
sheetTimeoutTimer = nil
}
private func showCallControlsIfTheyMustBeVisible() {
if bottomSheetMustBeVisible {
showCallControlsIfHidden()
}
}
private func showCallControlsIfHidden() {
switch self.bottomSheetStateManager.bottomSheetState {
case .callControlsAndOverflow, .callControls:
break
case .hidden:
bottomSheetStateManager.submitState(.callControls)
case .callInfo, .transitioning:
break
}
}
// MARK: - Ringing/Incoming Call Controls
private func createIncomingCallControlsIfNeeded() -> IncomingCallControls {
if let incomingCallControls {
return incomingCallControls
}
let incomingCallControls = IncomingCallControls(
isVideoCall: true,
didDeclineCall: { [unowned self] in self.dismissCall() },
didAcceptCall: { [unowned self] hasVideo in self.acceptRingingIncomingCall(hasVideo: hasVideo) },
)
self.view.addSubview(incomingCallControls)
incomingCallControls.autoPinWidthToSuperview()
incomingCallControls.autoPinEdge(toSuperviewEdge: .bottom)
self.incomingCallControls = incomingCallControls
return incomingCallControls
}
private func acceptRingingIncomingCall(hasVideo: Bool) {
// Explicitly unmute video in order to request permissions as needed.
// (Audio is unmuted as part of the call UI adapter.)
callService.updateIsLocalVideoMuted(isLocalVideoMuted: !hasVideo)
// When turning off video, default speakerphone to on.
if !hasVideo, !callService.audioService.hasExternalInputs {
callService.audioService.requestSpeakerphone(call: call, isEnabled: true)
}
callService.callUIAdapter.answerCall(call)
}
// MARK: Profile updates
@objc
private func otherUsersProfileChanged(notification: Notification) {
AssertIsOnMainThread()
guard
let changedAddress = notification.userInfo?[UserProfileNotifications.profileAddressKey] as? SignalServiceAddress,
changedAddress.isValid
else {
owsFailDebug("changedAddress was unexpectedly nil")
return
}
if let peekInfo = self.ringRtcCall.peekInfo {
let joinedAndPendingMembers = peekInfo.joinedMembers + peekInfo.pendingUsers
if
joinedAndPendingMembers.contains(where: { uuid in
changedAddress == SignalServiceAddress(Aci(fromUUID: uuid))
})
{
self.bottomSheet.updateMembers()
switch self.ringRtcCall.kind {
case .signalGroup:
break
case .callLink:
// Refresh profiles in call link admin approval UI.
self.callLinkApprovalViewModel.loadRequestsWithSneakyTransaction(for: peekInfo.pendingUsers)
}
}
}
}
}
// MARK: CallViewControllerWindowReference
extension GroupCallViewController: CallViewControllerWindowReference {
var localVideoViewReference: CallMemberView { localMemberView }
var remoteVideoViewReference: CallMemberView { speakerView }
var remoteVideoAddress: SignalServiceAddress {
guard let firstMember = ringRtcCall.remoteDeviceStates.sortedByAddedTime.first else {
return DependenciesBridge.shared.tsAccountManager.localIdentifiersWithMaybeSneakyTransaction!.aciAddress
}
return firstMember.address
}
var isJustMe: Bool {
groupCall.isJustMe
}
func minimizeIfNeeded() {
if !isCallMinimized {
didTapBackButton()
}
}
func returnFromPip(pipWindow: UIWindow) {
// The call "pip" uses our remote and local video views since only
// one `AVCaptureVideoPreviewLayer` per capture session is supported.
// We need to re-add them when we return to this view.
guard speakerView.superview != speakerPage, localMemberView.superview != view else {
return owsFailDebug("unexpectedly returned to call while we own the video views")
}
guard let splitViewSnapshot = SignalApp.shared.snapshotSplitViewController(afterScreenUpdates: false) else {
return owsFailDebug("failed to snapshot rootViewController")
}
guard let pipSnapshot = pipWindow.snapshotView(afterScreenUpdates: false) else {
return owsFailDebug("failed to snapshot pip")
}
isCallMinimized = false
showCallControlsIfHidden()
animateReturnFromPip(pipSnapshot: pipSnapshot, pipFrame: pipWindow.frame, splitViewSnapshot: splitViewSnapshot)
}
func willMoveToPip(pipWindow: UIWindow) {
flipCameraTooltipManager.dismissTooltip()
localMemberView.applyChangesToCallMemberViewAndVideoView { view in
if !isJustMe {
view.isHidden = true
} else {
view.frame = CGRect(origin: .zero, size: pipWindow.bounds.size)
}
}
}
private func animateReturnFromPip(pipSnapshot: UIView, pipFrame: CGRect, splitViewSnapshot: UIView) {
guard let window = view.window else { return owsFailDebug("missing window") }
view.superview?.insertSubview(splitViewSnapshot, belowSubview: view)
splitViewSnapshot.autoPinEdgesToSuperviewEdges()
let originalContentOffset = scrollView.contentOffset
view.frame = pipFrame
view.addSubview(pipSnapshot)
pipSnapshot.autoPinEdgesToSuperviewEdges()
view.layoutIfNeeded()
UIView.animate(withDuration: 0.2, animations: {
pipSnapshot.alpha = 0
self.view.frame = window.frame
self.updateCallUI()
self.videoGrid.reloadData()
self.scrollView.contentOffset = originalContentOffset
self.view.layoutIfNeeded()
}) { _ in
splitViewSnapshot.removeFromSuperview()
pipSnapshot.removeFromSuperview()
if self.hasUnresolvedSafetyNumberMismatch {
self.resolveSafetyNumberMismatch()
}
}
}
private func safetyNumberMismatchAddresses(untrustedThreshold: Date?) -> [SignalServiceAddress] {
SSKEnvironment.shared.databaseStorageRef.read { transaction in
let addressesToCheck: [SignalServiceAddress]
if
case .groupThread(let groupThreadCall) = groupCall.concreteType,
ringRtcCall.localDeviceState.joinState == .notJoined
{
// If we haven't joined the call yet, we want to alert for all members of the group
let groupThread = TSGroupThread.fetch(forGroupId: groupThreadCall.groupId, tx: transaction)
addressesToCheck = groupThread!.recipientAddresses(with: transaction)
} else {
// If we are in the call, we only care about safety numbers for the active call participants
addressesToCheck = ringRtcCall.remoteDeviceStates.map { $0.value.address }
}
let identityManager = DependenciesBridge.shared.identityManager
return addressesToCheck.filter { memberAddress in
identityManager.untrustedIdentityForSending(
to: memberAddress,
untrustedThreshold: untrustedThreshold,
tx: transaction,
) != nil
}
}
}
fileprivate func resolveSafetyNumberMismatch() {
let resendMediaKeysAndResetMismatch = { [unowned self] in
self.ringRtcCall.resendMediaKeys()
self.hasUnresolvedSafetyNumberMismatch = false
}
if !isCallMinimized, CurrentAppContext().isAppForegroundAndActive() {
presentSafetyNumberChangeSheetIfNecessary { [weak self] success in
guard let self else { return }
if success {
resendMediaKeysAndResetMismatch()
} else {
self.dismissCall()
}
}
} else {
let unresolvedAddresses = safetyNumberMismatchAddresses(untrustedThreshold: nil)
guard !unresolvedAddresses.isEmpty else {
// Spurious warning, maybe from delayed callbacks.
resendMediaKeysAndResetMismatch()
return
}
// If a problematic member was present at join, leaves, and then joins again,
// we'll still treat them as having been there "since join", but that's okay.
// It's not worth trying to track this more precisely.
let atLeastOneUnresolvedPresentAtJoin = unresolvedAddresses.contains { membersAtJoin?.contains($0) ?? false }
switch groupCall.concreteType {
case .groupThread(let call):
let databaseStorage = SSKEnvironment.shared.databaseStorageRef
let groupThread = databaseStorage.read { tx in
return TSGroupThread.fetch(forGroupId: call.groupId, tx: tx)
}
guard let groupThread else {
owsFail("Missing thread for active call.")
}
SSKEnvironment.shared.notificationPresenterRef.notifyForGroupCallSafetyNumberChange(
callTitle: groupThread.groupNameOrDefault,
threadUniqueId: groupThread.uniqueId,
roomId: nil,
presentAtJoin: atLeastOneUnresolvedPresentAtJoin,
)
case .callLink(let call):
SSKEnvironment.shared.notificationPresenterRef.notifyForGroupCallSafetyNumberChange(
callTitle: call.callLinkState.localizedName,
threadUniqueId: nil,
roomId: call.callLink.rootKey.deriveRoomId(),
presentAtJoin: atLeastOneUnresolvedPresentAtJoin,
)
}
}
}
fileprivate func presentSafetyNumberChangeSheetIfNecessary(untrustedThreshold: Date? = nil, completion: @escaping (Bool) -> Void) {
let localDeviceHasNotJoined = ringRtcCall.localDeviceState.joinState == .notJoined
let newUntrustedThreshold = Date()
let addressesToAlert = safetyNumberMismatchAddresses(untrustedThreshold: untrustedThreshold)
// There are no unverified addresses that we're currently concerned about. No need to show a sheet
guard !addressesToAlert.isEmpty else { return completion(true) }
if let existingSheet = (presentedViewController as? SafetyNumberConfirmationSheet) ?? (presentedViewController?.presentedViewController as? SafetyNumberConfirmationSheet) {
// The set of untrusted addresses may have changed.
// It's a bit clunky, but we'll just dismiss the existing sheet before putting up a new one.
existingSheet.dismiss(animated: false)
}
let continueCallString = OWSLocalizedString("GROUP_CALL_CONTINUE_BUTTON", comment: "Button to continue an ongoing group call")
let leaveCallString = OWSLocalizedString("GROUP_CALL_LEAVE_BUTTON", comment: "Button to leave a group call")
let cancelString = CommonStrings.cancelButton
let approveText: String
let denyText: String
if localDeviceHasNotJoined {
approveText = CallControls.joinButtonLabel(for: call)
denyText = cancelString
} else {
approveText = continueCallString
denyText = leaveCallString
}
let sheet = SafetyNumberConfirmationSheet(
addressesToConfirm: addressesToAlert,
confirmationText: approveText,
cancelText: denyText,
) { [weak self] didApprove in
if let self, didApprove {
self.presentSafetyNumberChangeSheetIfNecessary(untrustedThreshold: newUntrustedThreshold, completion: completion)
} else {
completion(false)
}
}
sheet.overrideUserInterfaceStyle = .dark
sheet.allowsDismissal = localDeviceHasNotJoined
presenter.present(sheet, animated: true, completion: nil)
}
}
// MARK: CallObserver
extension GroupCallViewController: GroupCallObserver {
func groupCallLocalDeviceStateChanged(_ call: GroupCall) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
// It would be nice to animate more device state changes, but some
// can cause unwanted animations, so only add them as tested.
let addOnsViewVisibilityWillChange = shouldHideAddOnsView != fullscreenLocalMemberAddOnsView.isHiddenInStackView
updateCallUI(shouldAnimateViewFrames: addOnsViewVisibilityWillChange)
let isCallLink: Bool = switch groupCall.concreteType {
case .groupThread:
false
case .callLink:
true
}
Logger.debug("\(ringRtcCall.localDeviceState.joinState)\t\(hasDismissed)")
switch ringRtcCall.localDeviceState.joinState {
case .joined:
if membersAtJoin == nil {
membersAtJoin = Set(ringRtcCall.remoteDeviceStates.lazy.map { $0.value.address })
}
if isCallLink {
callLinkLobbyToast.isHiddenInStackView = true
}
case .pending, .joining, .notJoined:
membersAtJoin = nil
if isCallLink, !hasDismissed {
callLinkLobbyToast.isHiddenInStackView = false
}
}
}
func groupCallRemoteDeviceStatesChanged(_ call: GroupCall) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
isAnyRemoteDeviceScreenSharing = ringRtcCall.remoteDeviceStates.values.first { $0.sharingScreen == true } != nil
showCallControlsIfTheyMustBeVisible()
updateCallUI()
scheduleBottomSheetTimeoutIfNecessary()
}
func groupCallPeekChanged(_ call: GroupCall) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
switch call.concreteType {
case .groupThread:
break
case .callLink:
let requests = call.ringRtcCall.peekInfo?.pendingUsers ?? []
self.callLinkApprovalViewModel.loadRequestsWithSneakyTransaction(for: requests)
}
updateCallUI()
}
func groupCallEnded(_ call: GroupCall, reason: CallEndReason) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
let title: String
let message: String?
let shouldDismissCallAfterDismissingActionSheet: Bool
switch reason {
case .deviceExplicitlyDisconnected:
dismissCall(shouldHangUp: false)
return
case .hasMaxDevices:
if let maxDevices = ringRtcCall.maxDevices {
let formatString = OWSLocalizedString(
"GROUP_CALL_HAS_MAX_DEVICES_%d",
tableName: "PluralAware",
comment: "An error displayed to the user when the group call ends because it has exceeded the max devices. Embeds {{max device count}}.",
)
title = String.localizedStringWithFormat(formatString, maxDevices)
message = nil
} else {
title = OWSLocalizedString(
"GROUP_CALL_HAS_MAX_DEVICES_UNKNOWN_COUNT",
comment: "An error displayed to the user when the group call ends because it has exceeded the max devices.",
)
message = nil
}
shouldDismissCallAfterDismissingActionSheet = true
case .removedFromCall:
title = OWSLocalizedString(
"GROUP_CALL_REMOVED",
comment: "The title of an alert when you've been removed from a group call.",
)
message = OWSLocalizedString(
"GROUP_CALL_REMOVED_MESSAGE",
comment: "The message of an alert when you've been removed from a group call.",
)
shouldDismissCallAfterDismissingActionSheet = true
case .deniedRequestToJoinCall:
title = OWSLocalizedString(
"GROUP_CALL_REQUEST_DENIED",
comment: "The title of an alert when tried to join a call using a link but the admin rejected your request.",
)
message = OWSLocalizedString(
"GROUP_CALL_REQUEST_DENIED_MESSAGE",
comment: "The message of an alert when tried to join a call using a link but the admin rejected your request.",
)
shouldDismissCallAfterDismissingActionSheet = true
case
.serverExplicitlyDisconnected,
.callManagerIsBusy,
.sfuClientFailedToJoin,
.failedToCreatePeerConnectionFactory,
.failedToNegotiateSrtpKeys,
.failedToCreatePeerConnection,
.failedToStartPeerConnection,
.failedToUpdatePeerConnection,
.failedToSetMaxSendBitrate,
.iceFailedWhileConnecting,
.iceFailedAfterConnected,
.serverChangedDemuxId:
Logger.warn("Group call ended with reason \(reason)")
title = OWSLocalizedString(
"GROUP_CALL_UNEXPECTEDLY_ENDED",
comment: "An error displayed to the user when the group call unexpectedly ends.",
)
message = nil
shouldDismissCallAfterDismissingActionSheet = false
case
.localHangup,
.remoteHangup,
.remoteHangupNeedPermission,
.remoteHangupAccepted,
.remoteHangupDeclined,
.remoteHangupBusy,
.remoteBusy,
.remoteGlare,
.remoteReCall,
.timeout,
.internalFailure,
.signalingFailure,
.connectionFailure,
.appDroppedCall:
Logger.error("Received Direct Call reason in a Group Call context")
return
}
if self.isReadyToHandleObserver {
showCallControlsIfTheyMustBeVisible()
updateCallUI()
}
let actionSheet = ActionSheetController(title: title, message: message)
actionSheet.addAction(ActionSheetAction(
title: CommonStrings.okButton,
style: .default,
handler: { [weak self] _ in
if shouldDismissCallAfterDismissingActionSheet {
self?.dismissCall()
}
},
))
presenter.presentActionSheet(actionSheet)
}
func groupCallReceivedReactions(_ call: GroupCall, reactions: [SignalRingRTC.Reaction]) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
let localAci = SSKEnvironment.shared.databaseStorageRef.read { tx in
return DependenciesBridge.shared.tsAccountManager.localIdentifiers(tx: tx)?.aci
}
guard let localAci else {
owsFailDebug("Local user is in call but doesn't have ACI!")
return
}
let mappedReactions = SSKEnvironment.shared.databaseStorageRef.read { tx in
return reactions.map { reaction in
let name: String
let aci: Aci
if
let remoteDeviceState = ringRtcCall.remoteDeviceStates[reaction.demuxId],
remoteDeviceState.aci != localAci
{
name = SSKEnvironment.shared.contactManagerRef.displayName(for: remoteDeviceState.address, tx: tx).resolvedValue()
aci = remoteDeviceState.aci
} else {
name = CommonStrings.you
aci = localAci
}
return Reaction(
emoji: reaction.value,
name: name,
aci: aci,
timestamp: Date.timeIntervalSinceReferenceDate,
)
}
}
self.reactionsSink.addReactions(reactions: mappedReactions)
}
func groupCallReceivedRaisedHands(_ call: GroupCall, raisedHands: [DemuxId]) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
self.raisedHandsToast.raisedHands = raisedHands
self.updateCallUI(shouldAnimateViewFrames: true)
}
func groupCallReceivedRemoteMute(_ call: GroupCall, muteSource: Aci) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
self.remoteMuteToast.displaySelfMuted(muteSource: muteSource)
callService.callUIAdapter.setIsMuted(call: self.call, isMuted: true)
self.updateCallUI(shouldAnimateViewFrames: true)
}
func groupCallObservedRemoteMute(_ call: GroupCall, muteSource: Aci, muteTarget: Aci) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
self.remoteMuteToast.displayOtherMuted(source: muteSource, target: muteTarget)
self.updateCallUI(shouldAnimateViewFrames: true)
}
func handleUntrustedIdentityError(_ call: GroupCall) {
AssertIsOnMainThread()
owsPrecondition(self.groupCall === call)
guard self.isReadyToHandleObserver else {
return
}
if !hasUnresolvedSafetyNumberMismatch {
hasUnresolvedSafetyNumberMismatch = true
resolveSafetyNumberMismatch()
}
}
}
// MARK: CallHeaderDelegate
extension GroupCallViewController: CallHeaderDelegate {
func didTapBackButton() {
if groupCall.hasJoinedOrIsWaitingForAdminApproval {
isCallMinimized = true
AppEnvironment.shared.windowManagerRef.leaveCallView()
// This ensures raised hands are removed
updateCallUI()
} else {
dismissCall()
}
}
func didTapMembersButton() {
switch self.bottomSheetStateManager.bottomSheetState {
case .callControls, .callControlsAndOverflow, .transitioning:
bottomSheetStateManager.submitState(.callInfo)
self.bottomSheet.maximizeHeight(animated: true)
case .hidden:
bottomSheetStateManager.submitState(.callInfo)
self.bottomSheet.maximizeHeight(animated: false)
case .callInfo:
bottomSheetStateManager.submitState(.callControls)
self.bottomSheet.minimizeHeight(animated: true)
}
}
}
// MARK: RaisedHandsToastDelegate
extension GroupCallViewController: RaisedHandsToastDelegate {
func didTapViewRaisedHands() {
self.didTapMembersButton()
}
func raisedHandsToastDidChangeHeight() {
self.updateCallUI(shouldAnimateViewFrames: true)
}
}
// MARK: GroupCallVideoOverflowDelegate
extension GroupCallViewController: GroupCallVideoOverflowDelegate {
var firstOverflowMemberIndex: Int {
switch self.page {
case .grid:
return videoGrid.maxItems
case .speaker:
return 1
}
}
}
// MARK: UIScrollViewDelegate
extension GroupCallViewController: UIScrollViewDelegate {
func scrollViewDidScroll(_ scrollView: UIScrollView) {
let isScrolledPastHalfway = scrollView.contentOffset.y > view.height / 2
self.page = isScrolledPastHalfway ? .speaker : .grid
if isAutoScrollingToScreenShare {
isAutoScrollingToScreenShare = scrollView.contentOffset.y != speakerView.frame.origin.y
}
updateSwipeToastView()
}
}
// MARK: CallControlsDelegate
extension GroupCallViewController: CallControlsDelegate {
func didPressRing() {
switch groupCall.concreteType {
case .groupThread(let groupThreadCall):
if groupThreadCall.ringRestrictions.isEmpty {
// Refresh the call header.
callHeader.groupCallLocalDeviceStateChanged(groupThreadCall)
} else if groupThreadCall.ringRestrictions.contains(.groupTooLarge) {
let toast = ToastController(text: OWSLocalizedString("GROUP_CALL_TOO_LARGE_TO_RING", comment: "Text displayed when trying to turn on ringing when calling a large group."))
toast.presentToastView(from: .top, of: view, inset: view.safeAreaInsets.top + 8)
}
case .callLink:
owsFail("Can't ring a call link")
}
}
func didPressJoin() {
if call.isFull {
let text: String
if let maxDevices = ringRtcCall.maxDevices {
let formatString = OWSLocalizedString(
"GROUP_CALL_HAS_MAX_DEVICES_%d",
tableName: "PluralAware",
comment: "An error displayed to the user when the group call ends because it has exceeded the max devices. Embeds {{max device count}}.",
)
text = String.localizedStringWithFormat(formatString, maxDevices)
} else {
text = OWSLocalizedString(
"GROUP_CALL_HAS_MAX_DEVICES_UNKNOWN_COUNT",
comment: "An error displayed to the user when the group call ends because it has exceeded the max devices.",
)
}
let toastController = ToastController(text: text)
// Leave the toast up longer than usual because this message is pretty long.
toastController.presentToastView(
from: .top,
of: view,
inset: view.safeAreaInsets.top + 8,
dismissAfter: .seconds(8),
)
return
}
presentSafetyNumberChangeSheetIfNecessary { [weak self] success in
guard let self else { return }
guard success else { return }
self.callService.joinGroupCallIfNecessary(self.call, groupCall: self.groupCall)
}
}
func didPressHangup() {
}
func didPressMore() {
if self.callControlsOverflowView.isHidden {
bottomSheetStateManager.submitState(.callControlsAndOverflow)
} else {
bottomSheetStateManager.submitState(.callControls)
}
}
}
// MARK: CallMemberErrorPresenter
extension GroupCallViewController: CallMemberErrorPresenter {
func presentErrorSheet(title: String, message: String) {
let actionSheet = ActionSheetController(title: title, message: message)
actionSheet.overrideUserInterfaceStyle = .dark
actionSheet.addAction(ActionSheetAction(title: CommonStrings.okButton))
presentActionSheet(actionSheet)
}
}
// MARK: AnimatableLocalMemberViewDelegate
extension GroupCallViewController: AnimatableLocalMemberViewDelegate {
var enclosingBounds: CGRect {
return self.view.bounds
}
var remoteDeviceCount: Int {
return ringRtcCall.remoteDeviceStates.count
}
func animatableLocalMemberViewDidCompleteExpandAnimation(_ localMemberView: CallMemberView) {
self.expandedPipFrame = localMemberView.frame
self.isPipAnimationInProgress = false
performRetroactiveUiUpdateIfNecessary()
}
func animatableLocalMemberViewDidCompleteShrinkAnimation(_ localMemberView: CallMemberView) {
self.expandedPipFrame = nil
self.isPipAnimationInProgress = false
performRetroactiveUiUpdateIfNecessary()
}
private func performRetroactiveUiUpdateIfNecessary() {
if self.shouldRelayoutAfterPipAnimationCompletes {
if let postAnimationUpdateMemberViewFramesSize {
updateMemberViewFrames(size: postAnimationUpdateMemberViewFramesSize)
self.postAnimationUpdateMemberViewFramesSize = nil
}
self.shouldRelayoutAfterPipAnimationCompletes = false
}
}
func animatableLocalMemberViewWillBeginAnimation(_ localMemberView: CallMemberView) {
self.isPipAnimationInProgress = true
self.flipCameraTooltipManager.dismissTooltip()
}
}
// MARK: - CallControlsOverflowPresenter
extension GroupCallViewController: CallControlsOverflowPresenter {
func callControlsOverflowWillAppear() {
self.cancelBottomSheetTimeout()
}
func callControlsOverflowDidDisappear() {
self.scheduleBottomSheetTimeoutIfNecessary()
}
func willSendReaction() {
bottomSheetStateManager.submitState(.callControls)
}
func didTapRaiseOrLowerHand() {
bottomSheetStateManager.submitState(.callControls)
}
}
// MARK: - SheetPanDelegate
extension GroupCallViewController: SheetPanDelegate {
func sheetPanDidBegin() {
bottomSheetStateManager.submitState(.transitioning)
self.callControlsConfirmationToastManager.forceDismissToast()
}
func sheetPanDidEnd() {
self.setBottomSheetStateAfterTransition()
}
func sheetPanDecelerationDidBegin() {
bottomSheetStateManager.submitState(.transitioning)
}
func sheetPanDecelerationDidEnd() {
self.setBottomSheetStateAfterTransition()
}
private func setBottomSheetStateAfterTransition() {
if bottomSheet.isPresentingCallInfo() {
bottomSheetStateManager.submitState(.callInfo)
} else if bottomSheet.isPresentingCallControls() {
bottomSheetStateManager.submitState(.callControls)
} else if bottomSheet.isCrossFading() {
bottomSheetStateManager.submitState(.transitioning)
}
}
}
// MARK: - CallDrawerDelegate
extension GroupCallViewController: CallDrawerDelegate {
func didPresentViewController(_ viewController: UIViewController) {
self.scheduleBottomSheetTimeoutIfNecessary()
}
func didTapDone() {
bottomSheetStateManager.submitState(.callControls)
self.bottomSheet.minimizeHeight()
}
}
// MARK: - Bottom Sheet State Management
enum BottomSheetState {
/// "Overflow" refers to the "..." menu that shows reactions & "Raise Hand".
case callControlsAndOverflow
case callControls
case callInfo
case transitioning
case hidden
}
/// TODO: It may make sense to pull sheet timeout logic into this class.
class GroupCallBottomSheetStateManager {
private weak var delegate: GroupCallBottomSheetStateDelegate?
private(set) var bottomSheetState: BottomSheetState = .callControls {
didSet {
guard bottomSheetState != oldValue else { return }
delegate?.bottomSheetStateDidChange(oldState: oldValue)
}
}
fileprivate init(delegate: GroupCallBottomSheetStateDelegate) {
self.delegate = delegate
}
func submitState(_ state: BottomSheetState) {
if let delegate, !delegate.areStateChangesSuspended {
bottomSheetState = state
}
}
}
private protocol GroupCallBottomSheetStateDelegate: AnyObject {
var areStateChangesSuspended: Bool { get }
func bottomSheetStateDidChange(oldState: BottomSheetState)
}
extension GroupCallViewController: GroupCallBottomSheetStateDelegate {
var areStateChangesSuspended: Bool {
self.callControlsOverflowView.isAnimating
}
func bottomSheetStateDidChange(oldState: BottomSheetState) {
updateCallUI(bottomSheetChangedStateFrom: oldState)
scheduleBottomSheetTimeoutIfNecessary()
}
}
extension GroupCallViewController: SheetDismissalDelegate {
func didDismissPresentedSheet() {
scheduleBottomSheetTimeoutIfNecessary()
}
}