mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-15 21:45:19 +00:00
985 lines
44 KiB
Swift
985 lines
44 KiB
Swift
import Foundation
|
||
import UIKit
|
||
import Display
|
||
import ComponentFlow
|
||
import SwiftSignalKit
|
||
import Postbox
|
||
import TelegramCore
|
||
import TelegramPresentationData
|
||
import PresentationDataUtils
|
||
import ViewControllerComponent
|
||
import AccountContext
|
||
import SolidRoundedButtonComponent
|
||
import MultilineTextComponent
|
||
import BundleIconComponent
|
||
import SolidRoundedButtonComponent
|
||
import Markdown
|
||
import InAppPurchaseManager
|
||
import ConfettiEffect
|
||
import TextFormat
|
||
import UniversalMediaPlayer
|
||
|
||
private final class PremiumGiftScreenContentComponent: CombinedComponent {
|
||
typealias EnvironmentType = (ViewControllerComponentContainer.Environment, ScrollChildEnvironment)
|
||
|
||
let context: AccountContext
|
||
let peer: EnginePeer?
|
||
let products: [PremiumGiftProduct]?
|
||
let selectedProductId: String?
|
||
|
||
let present: (ViewController) -> Void
|
||
let selectProduct: (String) -> Void
|
||
let buy: () -> Void
|
||
|
||
init(context: AccountContext, peer: EnginePeer?, products: [PremiumGiftProduct]?, selectedProductId: String?, present: @escaping (ViewController) -> Void, selectProduct: @escaping (String) -> Void, buy: @escaping () -> Void) {
|
||
self.context = context
|
||
self.peer = peer
|
||
self.products = products
|
||
self.selectedProductId = selectedProductId
|
||
self.present = present
|
||
self.selectProduct = selectProduct
|
||
self.buy = buy
|
||
}
|
||
|
||
static func ==(lhs: PremiumGiftScreenContentComponent, rhs: PremiumGiftScreenContentComponent) -> Bool {
|
||
if lhs.context !== rhs.context {
|
||
return false
|
||
}
|
||
if lhs.peer != rhs.peer {
|
||
return false
|
||
}
|
||
if lhs.products != rhs.products {
|
||
return false
|
||
}
|
||
if lhs.selectedProductId != rhs.selectedProductId {
|
||
return false
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
final class State: ComponentState {
|
||
private let context: AccountContext
|
||
|
||
private var disposable: Disposable?
|
||
private(set) var configuration = PremiumIntroConfiguration.defaultValue
|
||
private(set) var promoConfiguration: PremiumPromoConfiguration?
|
||
|
||
private var stickersDisposable: Disposable?
|
||
private var preloadDisposableSet = DisposableSet()
|
||
|
||
var price: String?
|
||
|
||
init(context: AccountContext) {
|
||
self.context = context
|
||
|
||
super.init()
|
||
|
||
self.disposable = (context.engine.data.subscribe(
|
||
TelegramEngine.EngineData.Item.Configuration.App(),
|
||
TelegramEngine.EngineData.Item.Configuration.PremiumPromo()
|
||
)
|
||
|> deliverOnMainQueue).start(next: { [weak self] appConfiguration, promoConfiguration in
|
||
if let strongSelf = self {
|
||
strongSelf.configuration = PremiumIntroConfiguration.with(appConfiguration: appConfiguration)
|
||
strongSelf.promoConfiguration = promoConfiguration
|
||
strongSelf.updated(transition: .immediate)
|
||
|
||
// if let identifier = source.identifier {
|
||
// var jsonString: String = "{"
|
||
// jsonString += "\"source\": \"\(identifier)\","
|
||
//
|
||
// jsonString += "\"data\": {\"premium_promo_order\":["
|
||
// var isFirst = true
|
||
// for perk in strongSelf.configuration.perks {
|
||
// if !isFirst {
|
||
// jsonString += ","
|
||
// }
|
||
// isFirst = false
|
||
// jsonString += "\"\(perk.identifier)\""
|
||
// }
|
||
// jsonString += "]}}"
|
||
//
|
||
// if let data = jsonString.data(using: .utf8), let json = JSON(data: data) {
|
||
// addAppLogEvent(postbox: strongSelf.context.account.postbox, type: "premium.promo_screen_show", data: json)
|
||
// }
|
||
// }
|
||
|
||
for (_, video) in promoConfiguration.videos {
|
||
strongSelf.preloadDisposableSet.add(preloadVideoResource(postbox: context.account.postbox, userLocation: .other, userContentType: .video, resourceReference: .standalone(resource: video.resource), duration: 3.0).start())
|
||
}
|
||
}
|
||
})
|
||
|
||
let _ = updatePremiumPromoConfigurationOnce(account: context.account).start()
|
||
|
||
let stickersKey: PostboxViewKey = .orderedItemList(id: Namespaces.OrderedItemList.CloudPremiumStickers)
|
||
self.stickersDisposable = (self.context.account.postbox.combinedView(keys: [stickersKey])
|
||
|> deliverOnMainQueue).start(next: { [weak self] views in
|
||
guard let strongSelf = self else {
|
||
return
|
||
}
|
||
if let view = views.views[stickersKey] as? OrderedItemListView {
|
||
for item in view.items {
|
||
if let mediaItem = item.contents.get(RecentMediaItem.self) {
|
||
let file = mediaItem.media
|
||
strongSelf.preloadDisposableSet.add(freeMediaFileResourceInteractiveFetched(account: context.account, userLocation: .other, fileReference: .standalone(media: file), resource: file.resource).start())
|
||
if let effect = file.videoThumbnails.first {
|
||
strongSelf.preloadDisposableSet.add(freeMediaFileResourceInteractiveFetched(account: context.account, userLocation: .other, fileReference: .standalone(media: file), resource: effect.resource).start())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
deinit {
|
||
self.disposable?.dispose()
|
||
self.preloadDisposableSet.dispose()
|
||
self.stickersDisposable?.dispose()
|
||
}
|
||
}
|
||
|
||
func makeState() -> State {
|
||
return State(context: self.context)
|
||
}
|
||
|
||
static var body: Body {
|
||
let overscroll = Child(Rectangle.self)
|
||
let fade = Child(RoundedRectangle.self)
|
||
let text = Child(MultilineTextComponent.self)
|
||
let optionsSection = Child(SectionGroupComponent.self)
|
||
let perksSection = Child(SectionGroupComponent.self)
|
||
|
||
return { context in
|
||
let sideInset: CGFloat = 16.0
|
||
|
||
let component = context.component
|
||
|
||
let scrollEnvironment = context.environment[ScrollChildEnvironment.self].value
|
||
let environment = context.environment[ViewControllerComponentContainer.Environment.self].value
|
||
|
||
let theme = environment.theme
|
||
let strings = environment.strings
|
||
|
||
let availableWidth = context.availableSize.width
|
||
let sideInsets = sideInset * 2.0 + environment.safeInsets.left + environment.safeInsets.right
|
||
var size = CGSize(width: context.availableSize.width, height: 0.0)
|
||
|
||
let overscroll = overscroll.update(
|
||
component: Rectangle(color: theme.list.plainBackgroundColor),
|
||
availableSize: CGSize(width: context.availableSize.width, height: 1000),
|
||
transition: context.transition
|
||
)
|
||
context.add(overscroll
|
||
.position(CGPoint(x: overscroll.size.width / 2.0, y: -overscroll.size.height / 2.0))
|
||
)
|
||
|
||
let fade = fade.update(
|
||
component: RoundedRectangle(
|
||
colors: [
|
||
theme.list.plainBackgroundColor,
|
||
theme.list.blocksBackgroundColor
|
||
],
|
||
cornerRadius: 0.0,
|
||
gradientDirection: .vertical
|
||
),
|
||
availableSize: CGSize(width: availableWidth, height: 300),
|
||
transition: context.transition
|
||
)
|
||
context.add(fade
|
||
.position(CGPoint(x: fade.size.width / 2.0, y: fade.size.height / 2.0))
|
||
)
|
||
|
||
size.height += 183.0 + 10.0 + environment.navigationHeight - 56.0
|
||
|
||
let textColor = theme.list.itemPrimaryTextColor
|
||
let titleColor = theme.list.itemPrimaryTextColor
|
||
let subtitleColor = theme.list.itemSecondaryTextColor
|
||
let arrowColor = theme.list.disclosureArrowColor
|
||
|
||
let textFont = Font.regular(15.0)
|
||
let boldTextFont = Font.semibold(15.0)
|
||
|
||
let markdownAttributes = MarkdownAttributes(body: MarkdownAttributeSet(font: textFont, textColor: textColor), bold: MarkdownAttributeSet(font: boldTextFont, textColor: textColor), link: MarkdownAttributeSet(font: textFont, textColor: textColor), linkAttribute: { _ in
|
||
return nil
|
||
})
|
||
let text = text.update(
|
||
component: MultilineTextComponent(
|
||
text: .markdown(
|
||
text: strings.Premium_Gift_Description(component.peer?.compactDisplayTitle ?? "").string,
|
||
attributes: markdownAttributes
|
||
),
|
||
horizontalAlignment: .center,
|
||
maximumNumberOfLines: 0,
|
||
lineSpacing: 0.2
|
||
),
|
||
environment: {},
|
||
availableSize: CGSize(width: availableWidth - sideInsets, height: 240.0),
|
||
transition: context.transition
|
||
)
|
||
context.add(text
|
||
.position(CGPoint(x: size.width / 2.0, y: size.height + text.size.height / 2.0))
|
||
)
|
||
size.height += text.size.height
|
||
size.height += 21.0
|
||
|
||
var items: [SectionGroupComponent.Item] = []
|
||
|
||
var i = 0
|
||
if let products = component.products {
|
||
let gradientColors: [UIColor] = [
|
||
UIColor(rgb: 0x8e77ff),
|
||
UIColor(rgb: 0x9a6fff),
|
||
UIColor(rgb: 0xb36eee)
|
||
]
|
||
|
||
let shortestOptionPrice: (Int64, NSDecimalNumber)
|
||
if let product = products.last {
|
||
shortestOptionPrice = (Int64(Float(product.storeProduct.priceCurrencyAndAmount.amount) / Float(product.months)), product.storeProduct.priceValue.dividing(by: NSDecimalNumber(value: product.months)))
|
||
} else {
|
||
shortestOptionPrice = (1, NSDecimalNumber(decimal: 1))
|
||
}
|
||
|
||
for product in products {
|
||
let giftTitle: String
|
||
if product.months == 12 {
|
||
giftTitle = strings.Premium_Gift_Years(1)
|
||
} else {
|
||
giftTitle = strings.Premium_Gift_Months(product.months)
|
||
}
|
||
|
||
let discountValue = Int((1.0 - Float(product.storeProduct.priceCurrencyAndAmount.amount) / Float(product.months) / Float(shortestOptionPrice.0)) * 100.0)
|
||
let discount: String
|
||
if discountValue > 0 {
|
||
discount = "-\(discountValue)%"
|
||
} else {
|
||
discount = ""
|
||
}
|
||
|
||
let defaultPrice = product.storeProduct.defaultPrice(shortestOptionPrice.1, monthsCount: Int(product.months))
|
||
|
||
var subtitle = ""
|
||
var pricePerMonth = product.storeProduct.pricePerMonth(Int(product.months))
|
||
pricePerMonth = environment.strings.Premium_PricePerMonth(pricePerMonth).string
|
||
|
||
if discountValue > 0 {
|
||
subtitle = "**\(defaultPrice)** \(product.price)"
|
||
}
|
||
|
||
items.append(SectionGroupComponent.Item(
|
||
AnyComponentWithIdentity(
|
||
id: product.id,
|
||
component: AnyComponent(
|
||
PremiumOptionComponent(
|
||
title: giftTitle,
|
||
subtitle: subtitle,
|
||
labelPrice: pricePerMonth,
|
||
discount: discount,
|
||
selected: product.id == component.selectedProductId,
|
||
primaryTextColor: textColor,
|
||
secondaryTextColor: subtitleColor,
|
||
accentColor: gradientColors[i],
|
||
checkForegroundColor: environment.theme.list.itemCheckColors.foregroundColor,
|
||
checkBorderColor: environment.theme.list.itemCheckColors.strokeColor
|
||
)
|
||
)
|
||
),
|
||
action: {
|
||
component.selectProduct(product.id)
|
||
})
|
||
)
|
||
i += 1
|
||
}
|
||
}
|
||
|
||
let optionsSection = optionsSection.update(
|
||
component: SectionGroupComponent(
|
||
items: items,
|
||
backgroundColor: environment.theme.list.itemBlocksBackgroundColor,
|
||
selectionColor: environment.theme.list.itemHighlightedBackgroundColor,
|
||
separatorColor: environment.theme.list.itemBlocksSeparatorColor
|
||
),
|
||
environment: {},
|
||
availableSize: CGSize(width: availableWidth - sideInsets, height: .greatestFiniteMagnitude),
|
||
transition: context.transition
|
||
)
|
||
context.add(optionsSection
|
||
.position(CGPoint(x: availableWidth / 2.0, y: size.height + optionsSection.size.height / 2.0))
|
||
.clipsToBounds(true)
|
||
.cornerRadius(10.0)
|
||
)
|
||
size.height += optionsSection.size.height
|
||
size.height += 23.0
|
||
|
||
let state = context.state
|
||
let accountContext = context.component.context
|
||
let present = context.component.present
|
||
let buy = context.component.buy
|
||
|
||
let price = context.component.products?.first(where: { $0.id == context.component.selectedProductId })?.price
|
||
state.price = price
|
||
|
||
let gradientColors: [UIColor] = [
|
||
UIColor(rgb: 0xF27C30),
|
||
UIColor(rgb: 0xE36850),
|
||
UIColor(rgb: 0xda5d63),
|
||
UIColor(rgb: 0xD15078),
|
||
UIColor(rgb: 0xC14998),
|
||
UIColor(rgb: 0xB24CB5),
|
||
UIColor(rgb: 0xA34ED0),
|
||
UIColor(rgb: 0x9054E9),
|
||
UIColor(rgb: 0x7561EB),
|
||
UIColor(rgb: 0x5A6EEE),
|
||
UIColor(rgb: 0x548DFF),
|
||
UIColor(rgb: 0x54A3FF),
|
||
UIColor(rgb: 0x54bdff)
|
||
]
|
||
|
||
i = 0
|
||
var perksItems: [SectionGroupComponent.Item] = []
|
||
for perk in state.configuration.perks {
|
||
let iconBackgroundColors = gradientColors[i]
|
||
perksItems.append(SectionGroupComponent.Item(
|
||
AnyComponentWithIdentity(
|
||
id: perk.identifier,
|
||
component: AnyComponent(
|
||
PerkComponent(
|
||
iconName: perk.iconName,
|
||
iconBackgroundColors: [
|
||
iconBackgroundColors
|
||
],
|
||
title: perk.title(strings: strings),
|
||
titleColor: titleColor,
|
||
subtitle: perk.subtitle(strings: strings),
|
||
subtitleColor: subtitleColor,
|
||
arrowColor: arrowColor
|
||
)
|
||
)
|
||
),
|
||
action: { [weak state] in
|
||
var demoSubject: PremiumDemoScreen.Subject
|
||
switch perk {
|
||
case .doubleLimits:
|
||
demoSubject = .doubleLimits
|
||
case .moreUpload:
|
||
demoSubject = .moreUpload
|
||
case .fasterDownload:
|
||
demoSubject = .fasterDownload
|
||
case .voiceToText:
|
||
demoSubject = .voiceToText
|
||
case .noAds:
|
||
demoSubject = .noAds
|
||
case .uniqueReactions:
|
||
demoSubject = .uniqueReactions
|
||
case .premiumStickers:
|
||
demoSubject = .premiumStickers
|
||
case .advancedChatManagement:
|
||
demoSubject = .advancedChatManagement
|
||
case .profileBadge:
|
||
demoSubject = .profileBadge
|
||
case .animatedUserpics:
|
||
demoSubject = .animatedUserpics
|
||
case .appIcons:
|
||
demoSubject = .appIcons
|
||
case .animatedEmoji:
|
||
demoSubject = .animatedEmoji
|
||
case .emojiStatus:
|
||
demoSubject = .emojiStatus
|
||
}
|
||
|
||
var dismissImpl: (() -> Void)?
|
||
let controller = PremiumLimitsListScreen(context: accountContext, subject: demoSubject, source: .gift(state?.price), order: state?.configuration.perks, buttonText: strings.Premium_Gift_GiftSubscription(state?.price ?? "–").string, isPremium: false)
|
||
controller.action = {
|
||
dismissImpl?()
|
||
buy()
|
||
}
|
||
controller.disposed = {
|
||
// updateIsFocused(false)
|
||
}
|
||
present(controller)
|
||
dismissImpl = { [weak controller] in
|
||
controller?.dismiss(animated: true, completion: nil)
|
||
}
|
||
|
||
// let controller = PremiumDemoScreen(
|
||
// context: accountContext,
|
||
// subject: demoSubject,
|
||
// source: .gift(state?.price),
|
||
// order: state?.configuration.perks,
|
||
// action: {
|
||
// buy()
|
||
// }
|
||
// )
|
||
// controller.disposed = {
|
||
//// updateIsFocused(false)
|
||
// }
|
||
// present(controller)
|
||
//// updateIsFocused(true)
|
||
|
||
addAppLogEvent(postbox: accountContext.account.postbox, type: "premium.promo_screen_tap", data: ["item": perk.identifier])
|
||
}
|
||
))
|
||
i += 1
|
||
}
|
||
|
||
let perksSection = perksSection.update(
|
||
component: SectionGroupComponent(
|
||
items: perksItems,
|
||
backgroundColor: environment.theme.list.itemBlocksBackgroundColor,
|
||
selectionColor: environment.theme.list.itemHighlightedBackgroundColor,
|
||
separatorColor: environment.theme.list.itemBlocksSeparatorColor
|
||
),
|
||
environment: {},
|
||
availableSize: CGSize(width: availableWidth - sideInsets, height: .greatestFiniteMagnitude),
|
||
transition: context.transition
|
||
)
|
||
context.add(perksSection
|
||
.position(CGPoint(x: availableWidth / 2.0, y: size.height + perksSection.size.height / 2.0))
|
||
.clipsToBounds(true)
|
||
.cornerRadius(10.0)
|
||
)
|
||
|
||
size.height += perksSection.size.height
|
||
|
||
size.height += 10.0
|
||
size.height += scrollEnvironment.insets.bottom
|
||
|
||
return size
|
||
}
|
||
}
|
||
}
|
||
|
||
private struct PremiumGiftProduct: Equatable {
|
||
let giftOption: CachedPremiumGiftOption
|
||
let storeProduct: InAppPurchaseManager.Product
|
||
|
||
var id: String {
|
||
return self.storeProduct.id
|
||
}
|
||
|
||
var months: Int32 {
|
||
return self.giftOption.months
|
||
}
|
||
|
||
var price: String {
|
||
return self.storeProduct.price
|
||
}
|
||
|
||
var pricePerMonth: String {
|
||
return self.storeProduct.pricePerMonth(Int(self.months))
|
||
}
|
||
}
|
||
|
||
private final class PremiumGiftScreenComponent: CombinedComponent {
|
||
typealias EnvironmentType = ViewControllerComponentContainer.Environment
|
||
|
||
let context: AccountContext
|
||
let peerId: PeerId
|
||
let options: [CachedPremiumGiftOption]
|
||
let updateInProgress: (Bool) -> Void
|
||
let present: (ViewController) -> Void
|
||
let push: (ViewController) -> Void
|
||
let completion: (Int32) -> Void
|
||
|
||
init(context: AccountContext, peerId: PeerId, options: [CachedPremiumGiftOption], updateInProgress: @escaping (Bool) -> Void, present: @escaping (ViewController) -> Void, push: @escaping (ViewController) -> Void, completion: @escaping (Int32) -> Void) {
|
||
self.context = context
|
||
self.peerId = peerId
|
||
self.options = options
|
||
self.updateInProgress = updateInProgress
|
||
self.present = present
|
||
self.push = push
|
||
self.completion = completion
|
||
}
|
||
|
||
static func ==(lhs: PremiumGiftScreenComponent, rhs: PremiumGiftScreenComponent) -> Bool {
|
||
if lhs.context !== rhs.context {
|
||
return false
|
||
}
|
||
if lhs.peerId != rhs.peerId {
|
||
return false
|
||
}
|
||
if lhs.options != rhs.options {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
final class State: ComponentState {
|
||
private let context: AccountContext
|
||
private let peerId: PeerId
|
||
private let options: [CachedPremiumGiftOption]
|
||
private let updateInProgress: (Bool) -> Void
|
||
private let present: (ViewController) -> Void
|
||
private let completion: (Int32) -> Void
|
||
|
||
var topContentOffset: CGFloat?
|
||
var bottomContentOffset: CGFloat?
|
||
|
||
var hasIdleAnimations = true
|
||
|
||
var inProgress = false
|
||
|
||
var peer: EnginePeer?
|
||
var products: [PremiumGiftProduct]?
|
||
var selectedProductId: String?
|
||
|
||
private var disposable: Disposable?
|
||
private var paymentDisposable = MetaDisposable()
|
||
private var activationDisposable = MetaDisposable()
|
||
|
||
init(context: AccountContext, peerId: PeerId, options: [CachedPremiumGiftOption], updateInProgress: @escaping (Bool) -> Void, present: @escaping (ViewController) -> Void, completion: @escaping (Int32) -> Void) {
|
||
self.context = context
|
||
self.peerId = peerId
|
||
self.options = options
|
||
self.updateInProgress = updateInProgress
|
||
self.present = present
|
||
self.completion = completion
|
||
|
||
super.init()
|
||
|
||
let availableProducts: Signal<[InAppPurchaseManager.Product], NoError>
|
||
if let inAppPurchaseManager = context.inAppPurchaseManager {
|
||
availableProducts = inAppPurchaseManager.availableProducts
|
||
} else {
|
||
availableProducts = .single([])
|
||
}
|
||
|
||
self.disposable = combineLatest(
|
||
queue: Queue.mainQueue(),
|
||
availableProducts,
|
||
context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId))
|
||
).start(next: { [weak self] products, peer in
|
||
if let strongSelf = self {
|
||
var gifts: [PremiumGiftProduct] = []
|
||
for option in strongSelf.options {
|
||
if let product = products.first(where: { $0.id == option.storeProductId }), !product.isSubscription {
|
||
gifts.append(PremiumGiftProduct(giftOption: option, storeProduct: product))
|
||
}
|
||
}
|
||
|
||
strongSelf.products = gifts
|
||
if strongSelf.selectedProductId == nil {
|
||
strongSelf.selectedProductId = strongSelf.products?.first?.id
|
||
}
|
||
strongSelf.peer = peer
|
||
strongSelf.updated(transition: .immediate)
|
||
}
|
||
})
|
||
}
|
||
|
||
deinit {
|
||
self.disposable?.dispose()
|
||
self.paymentDisposable.dispose()
|
||
self.activationDisposable.dispose()
|
||
}
|
||
|
||
func selectProduct(id: String) {
|
||
self.selectedProductId = id
|
||
self.updated(transition: .immediate)
|
||
}
|
||
|
||
func buy() {
|
||
guard let inAppPurchaseManager = self.context.inAppPurchaseManager, !self.inProgress else {
|
||
return
|
||
}
|
||
|
||
guard let product = self.products?.first(where: { $0.id == self.selectedProductId }) else {
|
||
return
|
||
}
|
||
let (currency, amount) = product.storeProduct.priceCurrencyAndAmount
|
||
let duration = product.months
|
||
|
||
// addAppLogEvent(postbox: self.context.account.postbox, type: "premium.promo_screen_accept")
|
||
|
||
self.inProgress = true
|
||
self.updateInProgress(true)
|
||
self.updated(transition: .immediate)
|
||
|
||
let _ = (self.context.engine.payments.canPurchasePremium(purpose: .gift(peerId: self.peerId, currency: currency, amount: amount))
|
||
|> deliverOnMainQueue).start(next: { [weak self] available in
|
||
if let strongSelf = self {
|
||
if available {
|
||
strongSelf.paymentDisposable.set((inAppPurchaseManager.buyProduct(product.storeProduct, targetPeerId: strongSelf.peerId)
|
||
|> deliverOnMainQueue).start(next: { [weak self] status in
|
||
if let strongSelf = self, case .purchased = status {
|
||
Queue.mainQueue().after(2.0) {
|
||
let _ = updatePremiumPromoConfigurationOnce(account: strongSelf.context.account).start()
|
||
strongSelf.inProgress = false
|
||
strongSelf.updateInProgress(false)
|
||
|
||
strongSelf.updated(transition: .easeInOut(duration: 0.25))
|
||
strongSelf.completion(duration)
|
||
}
|
||
}
|
||
}, error: { [weak self] error in
|
||
if let strongSelf = self {
|
||
strongSelf.inProgress = false
|
||
strongSelf.updateInProgress(false)
|
||
strongSelf.updated(transition: .immediate)
|
||
|
||
let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
|
||
var errorText: String?
|
||
switch error {
|
||
case .generic:
|
||
errorText = presentationData.strings.Premium_Purchase_ErrorUnknown
|
||
case .network:
|
||
errorText = presentationData.strings.Premium_Purchase_ErrorNetwork
|
||
case .notAllowed:
|
||
errorText = presentationData.strings.Premium_Purchase_ErrorNotAllowed
|
||
case .cantMakePayments:
|
||
errorText = presentationData.strings.Premium_Purchase_ErrorCantMakePayments
|
||
case .assignFailed:
|
||
errorText = presentationData.strings.Premium_Purchase_ErrorUnknown
|
||
case .cancelled:
|
||
break
|
||
}
|
||
|
||
if let errorText = errorText {
|
||
// addAppLogEvent(postbox: strongSelf.context.account.postbox, type: "premium.promo_screen_fail")
|
||
|
||
let alertController = textAlertController(context: strongSelf.context, title: nil, text: errorText, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})])
|
||
strongSelf.present(alertController)
|
||
}
|
||
}
|
||
}))
|
||
} else {
|
||
strongSelf.inProgress = false
|
||
strongSelf.updateInProgress(false)
|
||
strongSelf.updated(transition: .immediate)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
func updateIsFocused(_ isFocused: Bool) {
|
||
self.hasIdleAnimations = !isFocused
|
||
self.updated(transition: .immediate)
|
||
}
|
||
}
|
||
|
||
func makeState() -> State {
|
||
return State(context: self.context, peerId: self.peerId, options: self.options, updateInProgress: self.updateInProgress, present: self.present, completion: self.completion)
|
||
}
|
||
|
||
static var body: Body {
|
||
let background = Child(Rectangle.self)
|
||
let scrollContent = Child(ScrollComponent<EnvironmentType>.self)
|
||
let star = Child(GiftAvatarComponent.self)
|
||
let topPanel = Child(BlurredRectangle.self)
|
||
let topSeparator = Child(Rectangle.self)
|
||
let title = Child(MultilineTextComponent.self)
|
||
let bottomPanel = Child(BlurredRectangle.self)
|
||
let bottomSeparator = Child(Rectangle.self)
|
||
let button = Child(SolidRoundedButtonComponent.self)
|
||
|
||
return { context in
|
||
let environment = context.environment[EnvironmentType.self].value
|
||
let state = context.state
|
||
|
||
let background = background.update(component: Rectangle(color: environment.theme.list.blocksBackgroundColor), environment: {}, availableSize: context.availableSize, transition: context.transition)
|
||
|
||
var starIsVisible = true
|
||
if let topContentOffset = state.topContentOffset, topContentOffset >= 123.0 {
|
||
starIsVisible = false
|
||
}
|
||
|
||
let topPanel = topPanel.update(
|
||
component: BlurredRectangle(
|
||
color: environment.theme.rootController.navigationBar.blurredBackgroundColor
|
||
),
|
||
availableSize: CGSize(width: context.availableSize.width, height: environment.navigationHeight),
|
||
transition: context.transition
|
||
)
|
||
|
||
let topSeparator = topSeparator.update(
|
||
component: Rectangle(
|
||
color: environment.theme.rootController.navigationBar.separatorColor
|
||
),
|
||
availableSize: CGSize(width: context.availableSize.width, height: UIScreenPixel),
|
||
transition: context.transition
|
||
)
|
||
|
||
let title = title.update(
|
||
component: MultilineTextComponent(
|
||
text: .plain(NSAttributedString(string: environment.strings.Premium_Gift_Title, font: Font.bold(28.0), textColor: environment.theme.rootController.navigationBar.primaryTextColor)),
|
||
horizontalAlignment: .center,
|
||
truncationType: .end,
|
||
maximumNumberOfLines: 1
|
||
),
|
||
availableSize: context.availableSize,
|
||
transition: context.transition
|
||
)
|
||
|
||
let bottomPanelPadding: CGFloat = 12.0
|
||
let bottomInset: CGFloat = environment.safeInsets.bottom > 0.0 ? environment.safeInsets.bottom + 5.0 : bottomPanelPadding
|
||
let bottomPanelHeight: CGFloat = bottomPanelPadding + 50.0 + bottomInset
|
||
|
||
let topInset: CGFloat = environment.navigationHeight - 56.0
|
||
|
||
context.add(background
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height / 2.0))
|
||
)
|
||
|
||
let scrollContent = scrollContent.update(
|
||
component: ScrollComponent<EnvironmentType>(
|
||
content: AnyComponent(PremiumGiftScreenContentComponent(
|
||
context: context.component.context,
|
||
peer: state.peer,
|
||
products: state.products,
|
||
selectedProductId: state.selectedProductId,
|
||
present: context.component.present,
|
||
selectProduct: { [weak state] productId in
|
||
state?.selectProduct(id: productId)
|
||
}, buy: { [weak state] in
|
||
state?.buy()
|
||
}
|
||
)),
|
||
contentInsets: UIEdgeInsets(top: environment.navigationHeight, left: 0.0, bottom: bottomPanelHeight, right: 0.0),
|
||
contentOffsetUpdated: { [weak state] topContentOffset, bottomContentOffset in
|
||
state?.topContentOffset = topContentOffset
|
||
state?.bottomContentOffset = bottomContentOffset
|
||
Queue.mainQueue().justDispatch {
|
||
state?.updated(transition: .immediate)
|
||
}
|
||
},
|
||
contentOffsetWillCommit: { targetContentOffset in
|
||
if targetContentOffset.pointee.y < 100.0 {
|
||
targetContentOffset.pointee = CGPoint(x: 0.0, y: 0.0)
|
||
} else if targetContentOffset.pointee.y < 123.0 {
|
||
targetContentOffset.pointee = CGPoint(x: 0.0, y: 123.0)
|
||
}
|
||
}
|
||
),
|
||
environment: { environment },
|
||
availableSize: context.availableSize,
|
||
transition: context.transition
|
||
)
|
||
|
||
context.add(scrollContent
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height / 2.0))
|
||
)
|
||
|
||
let topPanelAlpha: CGFloat
|
||
let titleOffset: CGFloat
|
||
let titleScale: CGFloat
|
||
let titleOffsetDelta = (topInset + 160.0) - (environment.statusBarHeight + (environment.navigationHeight - environment.statusBarHeight) / 2.0)
|
||
let titleAlpha: CGFloat
|
||
|
||
if let topContentOffset = state.topContentOffset {
|
||
topPanelAlpha = min(20.0, max(0.0, topContentOffset - 95.0)) / 20.0
|
||
let topContentOffset = topContentOffset + max(0.0, min(1.0, topContentOffset / titleOffsetDelta)) * 10.0
|
||
titleOffset = topContentOffset
|
||
let fraction = max(0.0, min(1.0, titleOffset / titleOffsetDelta))
|
||
titleScale = 1.0 - fraction * 0.36
|
||
titleAlpha = 1.0
|
||
} else {
|
||
topPanelAlpha = 0.0
|
||
titleScale = 1.0
|
||
titleOffset = 0.0
|
||
titleAlpha = 1.0
|
||
}
|
||
|
||
let star = star.update(
|
||
component: GiftAvatarComponent(
|
||
context: context.component.context,
|
||
peer: context.state.peer,
|
||
isVisible: starIsVisible,
|
||
hasIdleAnimations: state.hasIdleAnimations
|
||
),
|
||
availableSize: CGSize(width: min(390.0, context.availableSize.width), height: 220.0),
|
||
transition: context.transition
|
||
)
|
||
|
||
context.add(star
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: topInset + star.size.height / 2.0 - 30.0 - titleOffset * titleScale))
|
||
.scale(titleScale)
|
||
)
|
||
|
||
context.add(topPanel
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: topPanel.size.height / 2.0))
|
||
.opacity(topPanelAlpha)
|
||
)
|
||
context.add(topSeparator
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: topPanel.size.height))
|
||
.opacity(topPanelAlpha)
|
||
)
|
||
|
||
context.add(title
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: max(topInset + 160.0 - titleOffset, environment.statusBarHeight + (environment.navigationHeight - environment.statusBarHeight) / 2.0)))
|
||
.scale(titleScale)
|
||
.opacity(titleAlpha)
|
||
)
|
||
|
||
let price: String?
|
||
if let products = state.products, let selectedProductId = state.selectedProductId, let product = products.first(where: { $0.id == selectedProductId }) {
|
||
price = product.price
|
||
} else {
|
||
price = nil
|
||
}
|
||
|
||
let sideInset: CGFloat = 16.0
|
||
let button = button.update(
|
||
component: SolidRoundedButtonComponent(
|
||
title: environment.strings.Premium_Gift_GiftSubscription(price ?? "—").string,
|
||
theme: SolidRoundedButtonComponent.Theme(
|
||
backgroundColor: UIColor(rgb: 0x8878ff),
|
||
backgroundColors: [
|
||
UIColor(rgb: 0x0077ff),
|
||
UIColor(rgb: 0x6b93ff),
|
||
UIColor(rgb: 0x8878ff),
|
||
UIColor(rgb: 0xe46ace)
|
||
],
|
||
foregroundColor: .white
|
||
),
|
||
height: 50.0,
|
||
cornerRadius: 11.0,
|
||
gloss: true,
|
||
isLoading: state.inProgress,
|
||
action: {
|
||
state.buy()
|
||
}
|
||
),
|
||
availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0 - environment.safeInsets.left - environment.safeInsets.right, height: 50.0),
|
||
transition: context.transition)
|
||
|
||
let bottomPanel = bottomPanel.update(
|
||
component: BlurredRectangle(
|
||
color: environment.theme.rootController.tabBar.backgroundColor
|
||
),
|
||
availableSize: CGSize(width: context.availableSize.width, height: bottomPanelPadding + button.size.height + bottomInset),
|
||
transition: context.transition
|
||
)
|
||
|
||
let bottomSeparator = bottomSeparator.update(
|
||
component: Rectangle(
|
||
color: environment.theme.rootController.tabBar.separatorColor
|
||
),
|
||
availableSize: CGSize(width: context.availableSize.width, height: UIScreenPixel),
|
||
transition: context.transition
|
||
)
|
||
|
||
let bottomPanelAlpha: CGFloat
|
||
if let bottomContentOffset = state.bottomContentOffset {
|
||
bottomPanelAlpha = min(16.0, bottomContentOffset) / 16.0
|
||
} else {
|
||
bottomPanelAlpha = 1.0
|
||
}
|
||
|
||
context.add(bottomPanel
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height - bottomPanel.size.height / 2.0))
|
||
.opacity(bottomPanelAlpha)
|
||
)
|
||
context.add(bottomSeparator
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height - bottomPanel.size.height))
|
||
.opacity(bottomPanelAlpha)
|
||
)
|
||
context.add(button
|
||
.position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height - bottomPanel.size.height + bottomPanelPadding + button.size.height / 2.0))
|
||
)
|
||
|
||
return context.availableSize
|
||
}
|
||
}
|
||
}
|
||
|
||
public final class PremiumGiftScreen: ViewControllerComponentContainer {
|
||
fileprivate let context: AccountContext
|
||
|
||
private var didSetReady = false
|
||
private let _ready = Promise<Bool>()
|
||
public override var ready: Promise<Bool> {
|
||
return self._ready
|
||
}
|
||
|
||
public weak var sourceView: UIView?
|
||
public weak var containerView: UIView?
|
||
public var animationColor: UIColor?
|
||
|
||
public init(context: AccountContext, peerId: PeerId, options: [CachedPremiumGiftOption]) {
|
||
self.context = context
|
||
|
||
var updateInProgressImpl: ((Bool) -> Void)?
|
||
var pushImpl: ((ViewController) -> Void)?
|
||
// var presentImpl: ((ViewController) -> Void)?
|
||
var completionImpl: ((Int32) -> Void)?
|
||
super.init(context: context, component: PremiumGiftScreenComponent(
|
||
context: context,
|
||
peerId: peerId,
|
||
options: options,
|
||
updateInProgress: { inProgress in
|
||
updateInProgressImpl?(inProgress)
|
||
},
|
||
present: { c in
|
||
pushImpl?(c)
|
||
},
|
||
push: { c in
|
||
pushImpl?(c)
|
||
},
|
||
completion: { duration in
|
||
completionImpl?(duration)
|
||
}
|
||
), navigationBarAppearance: .transparent)
|
||
|
||
let presentationData = context.sharedContext.currentPresentationData.with { $0 }
|
||
|
||
let cancelItem = UIBarButtonItem(title: presentationData.strings.Common_Cancel, style: .plain, target: self, action: #selector(self.cancelPressed))
|
||
self.navigationItem.setLeftBarButton(cancelItem, animated: false)
|
||
self.navigationPresentation = .modal
|
||
|
||
updateInProgressImpl = { [weak self] inProgress in
|
||
if let strongSelf = self {
|
||
strongSelf.navigationItem.leftBarButtonItem?.isEnabled = !inProgress
|
||
strongSelf.view.disablesInteractiveTransitionGestureRecognizer = inProgress
|
||
strongSelf.view.disablesInteractiveModalDismiss = inProgress
|
||
}
|
||
}
|
||
|
||
pushImpl = { [weak self] c in
|
||
self?.push(c)
|
||
}
|
||
|
||
completionImpl = { [weak self] duration in
|
||
if let strongSelf = self, let navigationController = strongSelf.navigationController as? NavigationController {
|
||
var controllers = navigationController.viewControllers
|
||
controllers = controllers.filter { !($0 is PeerInfoScreen) && !($0 is PremiumGiftScreen) }
|
||
var foundController = false
|
||
for controller in controllers.reversed() {
|
||
if let chatController = controller as? ChatController, case .peer(id: peerId) = chatController.chatLocation {
|
||
chatController.hintPlayNextOutgoingGift()
|
||
foundController = true
|
||
break
|
||
}
|
||
}
|
||
if !foundController {
|
||
let chatController = context.sharedContext.makeChatController(context: context, chatLocation: .peer(id: peerId), subject: nil, botStart: nil, mode: .standard(previewing: false))
|
||
chatController.hintPlayNextOutgoingGift()
|
||
controllers.append(chatController)
|
||
}
|
||
navigationController.setViewControllers(controllers, animated: true)
|
||
}
|
||
}
|
||
}
|
||
|
||
required public init(coder aDecoder: NSCoder) {
|
||
fatalError("init(coder:) has not been implemented")
|
||
}
|
||
|
||
@objc private func cancelPressed() {
|
||
self.dismiss()
|
||
}
|
||
|
||
public override func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
|
||
super.containerLayoutUpdated(layout, transition: transition)
|
||
|
||
if !self.didSetReady {
|
||
self.didSetReady = true
|
||
if let view = self.node.hostView.findTaggedView(tag: GiftAvatarComponent.View.Tag()) as? GiftAvatarComponent.View {
|
||
self._ready.set(view.ready)
|
||
} else {
|
||
self._ready.set(.single(true))
|
||
}
|
||
}
|
||
}
|
||
}
|