545 lines
15 KiB
Swift
545 lines
15 KiB
Swift
import Foundation
|
||
|
||
// AggregatorBid 私有结构体
|
||
private struct AggregatorBid {
|
||
let config: AggregatorConfig
|
||
/**
|
||
* 是否进行自抬价。
|
||
* 在某个聚合show完成时，会向竞价队列头部加入一个此聚合当前 revenue * selfRaise 自抬价的bid
|
||
* 在设置为true时，同时设置[floor]为revenue，基于此值进行自抬价
|
||
*/
|
||
let useSelfRaise: Bool
|
||
/**
|
||
* 当前bid的固定底价，若为nil，则使用winners中最大的revenue, see [MabWinners.maxRevenue]
|
||
* 单位为美元 每次展示
|
||
*/
|
||
let floor: Double?
|
||
|
||
/**
|
||
* 本次参与竞价请求的原因
|
||
*/
|
||
let reason: RequestReason?
|
||
|
||
init(config: AggregatorConfig, useSelfRaise: Bool = false, floor: Double? = nil, reason: RequestReason? = nil) {
|
||
self.config = config
|
||
self.useSelfRaise = useSelfRaise
|
||
self.floor = floor
|
||
self.reason = reason
|
||
}
|
||
|
||
var raiseRate: Double {
|
||
return useSelfRaise ? config.selfRaiseRate ?? config.raiseRate : config.raiseRate
|
||
}
|
||
}
|
||
|
||
// 扩展属性
|
||
extension AggregatorConfig {
|
||
var deferRetryUntilShown: Bool {
|
||
return adPlatform == AdPlatform.adMob.name
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 储存已填充的广告
|
||
*/
|
||
private class MabWinners<T: MabBidder> {
|
||
private var winners: [String: T] = [:]
|
||
private let onEvict: ((T) -> Void)?
|
||
|
||
init(onEvict: ((T) -> Void)? = nil) {
|
||
self.onEvict = onEvict
|
||
}
|
||
|
||
/**
|
||
* 清除已过期的缓存
|
||
*/
|
||
func evictCache() {
|
||
let expiredKeys = winners.filter { (_, bidder) in
|
||
if bidder.isExpired != false {
|
||
onEvict?(bidder)
|
||
return true
|
||
}
|
||
return false
|
||
}.map { $0.key }
|
||
|
||
for key in expiredKeys {
|
||
winners.removeValue(forKey: key)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 添加一个已填充的广告
|
||
*/
|
||
func add(bidder: T) {
|
||
evictCache()
|
||
winners[bidder.aggregatorId] = bidder
|
||
}
|
||
|
||
/**
|
||
* 是否包含此聚合的已填充广告
|
||
*/
|
||
func contains(aggregatorId: String) -> Bool {
|
||
evictCache()
|
||
return winners[aggregatorId] != nil
|
||
}
|
||
|
||
/**
|
||
* 已填充广告内当前最高的填充价格，若无广告填充或全部过期则返回0
|
||
*/
|
||
func maxRevenue() -> Double {
|
||
evictCache()
|
||
if winners.isEmpty {
|
||
return 0.0
|
||
}
|
||
return winners.values.map { $0.revenue }.max() ?? 0.0
|
||
}
|
||
|
||
/**
|
||
* 查看当前最高填充价格的广告
|
||
*/
|
||
func peekMaxRevenue() -> T? {
|
||
evictCache()
|
||
return winners.values.max(by: {
|
||
if($0.revenue == $1.revenue) {
|
||
// 优先级数值越低（优先级越高）越排序靠后（升序排列）
|
||
return $0.config.priority > $1.config.priority
|
||
}
|
||
return $0.revenue < $1.revenue
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 移出当前最高填充价格的广告
|
||
*/
|
||
func pollMaxRevenue() -> T? {
|
||
evictCache()
|
||
guard let entry = peekMaxRevenue() else {
|
||
return nil
|
||
}
|
||
return winners.removeValue(forKey: entry.aggregatorId)
|
||
}
|
||
|
||
/**
|
||
* 是否存在已填充广告
|
||
*/
|
||
func isEmpty() -> Bool {
|
||
evictCache()
|
||
return winners.isEmpty
|
||
}
|
||
|
||
/**
|
||
* 清空所有填充广告
|
||
*/
|
||
func clear() {
|
||
winners.removeAll()
|
||
}
|
||
|
||
func buildStateLog() -> String {
|
||
var result = "winners["
|
||
for winner in winners {
|
||
result += "\(winner.key)(\(winner.value.revenue)),"
|
||
}
|
||
result += "]"
|
||
return result
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 对多次load敏感的聚合（如AdMob）进行load重试控制，确保在首次load后（无论失败或成功），后续load与重新load必须在一次广告show之后才能进行。
|
||
* 换句话说-> "每次广告show完，此聚合重新获得一次load机会（不能累加）"
|
||
*/
|
||
private class RetryGate {
|
||
// Swift没有AtomicInteger，所以使用一个类包装
|
||
private class AtomicInteger {
|
||
private var value: Int
|
||
|
||
init(_ initialValue: Int = 0) {
|
||
self.value = initialValue
|
||
}
|
||
|
||
func get() -> Int {
|
||
return value
|
||
}
|
||
|
||
func set(_ newValue: Int) {
|
||
value = newValue
|
||
}
|
||
|
||
func incrementAndGet() -> Int {
|
||
value += 1
|
||
return value
|
||
}
|
||
}
|
||
|
||
private var version = AtomicInteger() // 每次ad show成功时更新一个版本
|
||
private var lastUsed: [String: AtomicInteger] = [:]
|
||
|
||
func onAdShown() {
|
||
_ = version.incrementAndGet()
|
||
}
|
||
|
||
/**
|
||
* 对比重试版本与show版本，若不一致则代表有机会进行retry，若一致则代表需等待下次show完
|
||
*/
|
||
func canRetry(aggregatorId: String) -> Bool {
|
||
return getLastUsed(aggregatorId: aggregatorId).get() < version.get()
|
||
}
|
||
|
||
/**
|
||
* 标记本次重试版本
|
||
*/
|
||
func markRetryUsed(aggregatorId: String) {
|
||
getLastUsed(aggregatorId: aggregatorId).set(version.get())
|
||
}
|
||
|
||
private func getLastUsed(aggregatorId: String) -> AtomicInteger {
|
||
if let lastUsed = lastUsed[aggregatorId] {
|
||
return lastUsed
|
||
} else {
|
||
let atomicInteger = AtomicInteger(-1)
|
||
lastUsed[aggregatorId] = atomicInteger
|
||
return atomicInteger
|
||
}
|
||
}
|
||
}
|
||
|
||
private func selectAdUnitSpec(
|
||
aggregatorConfig: AggregatorConfig,
|
||
floor: Double,
|
||
selfRaise: Bool = false
|
||
) -> AdUnitSpec? {
|
||
let adUnitIds = aggregatorConfig.adUnitIds
|
||
if adUnitIds.isEmpty {
|
||
return nil
|
||
}
|
||
|
||
let targetFloor = floor * (selfRaise ? aggregatorConfig.selfRaiseRate ?? aggregatorConfig.raiseRate : aggregatorConfig.raiseRate)
|
||
|
||
let firstGtIndex = adUnitIds.firstIndex { $0.floor >= targetFloor }
|
||
|
||
if firstGtIndex == nil {
|
||
return adUnitIds.last
|
||
}
|
||
|
||
if firstGtIndex == 0 {
|
||
return adUnitIds.first
|
||
}
|
||
|
||
// 寻找最接近targetFloor的一个
|
||
let index = firstGtIndex!
|
||
let nearestIndex = (abs(targetFloor - adUnitIds[index].floor) <= abs(adUnitIds[index - 1].floor - targetFloor)) ? index : index - 1
|
||
|
||
let selection = adUnitIds[nearestIndex]
|
||
|
||
return selection
|
||
}
|
||
|
||
enum RequestReason: String {
|
||
case INIT = "init"
|
||
case FAIL = "fail"
|
||
case SHOW = "show"
|
||
case EXPIRATION = "exp"
|
||
|
||
var statsName: String {
|
||
return rawValue
|
||
}
|
||
}
|
||
|
||
protocol MabBidder {
|
||
var id: Int { get }
|
||
var config: AggregatorConfig { get }
|
||
var isExpired: Bool? { get }
|
||
var revenue: Double { get }
|
||
|
||
func load(reason: RequestReason?) -> Bool
|
||
func destroy()
|
||
}
|
||
|
||
extension MabBidder {
|
||
var aggregatorId: String {
|
||
return config.aggregatorId
|
||
}
|
||
}
|
||
|
||
// 静态方法转换为类函数
|
||
class MabBidderUtils {
|
||
static func adjustRevenue(ad: FusionAd, floor: Double) -> Double {
|
||
switch ad.adPlatform {
|
||
case .max:
|
||
return ad.revenue
|
||
case .ironSource:
|
||
return max(ad.revenue, floor)
|
||
case .adMob:
|
||
return max(ad.revenue, floor)
|
||
default:
|
||
return max(ad.revenue, floor)
|
||
}
|
||
}
|
||
}
|
||
|
||
class MabAuctioneer<T: MabBidder> {
|
||
enum RequestResult {
|
||
case success
|
||
case busy
|
||
case noAvailableSource
|
||
}
|
||
|
||
private let tag: String
|
||
private let faUnitId: String
|
||
private let priorityAggregators: [AggregatorConfig]
|
||
private var candidatesQueue: [AggregatorBid] = []
|
||
private let bidderFactory: (AggregatorConfig, AdUnitSpec) -> T?
|
||
|
||
private var bidding: T?
|
||
private var bidders: [String: T] = [:]
|
||
|
||
private let winners: MabWinners<T>
|
||
private let retryGate = RetryGate()
|
||
|
||
var hasWinner: Bool {
|
||
return !winners.isEmpty()
|
||
}
|
||
|
||
init(
|
||
engineId: Int,
|
||
faUnitId: String,
|
||
aggregatorConfigs: [AggregatorConfig],
|
||
bidderFactory: @escaping (AggregatorConfig, AdUnitSpec) -> T?
|
||
) {
|
||
self.tag = "MabAuctioneer@\(engineId)"
|
||
self.faUnitId = faUnitId
|
||
self.priorityAggregators = aggregatorConfigs.sorted(by: { $0.priority < $1.priority })
|
||
self.bidderFactory = bidderFactory
|
||
|
||
self.winners = MabWinners<T>()
|
||
}
|
||
|
||
private func logI(_ message: String) {
|
||
Logger.i(tag: tag, message: message)
|
||
}
|
||
|
||
private func logD(_ message: String) {
|
||
Logger.d(tag: tag, message: message)
|
||
}
|
||
|
||
private func logW(_ message: String) {
|
||
Logger.w(tag: tag, message: message)
|
||
}
|
||
|
||
private func logE(_ message: String) {
|
||
Logger.e(tag: tag, message: message)
|
||
}
|
||
|
||
private func logState() {
|
||
logI("mab state: \(buildStateLog())")
|
||
}
|
||
|
||
private func obtainBidder(
|
||
config: AggregatorConfig,
|
||
adUnitSpec: AdUnitSpec
|
||
) -> T? {
|
||
if let bidder = bidders[adUnitSpec.adUnitId] {
|
||
return bidder
|
||
} else {
|
||
if let newBidder = bidderFactory(config, adUnitSpec) {
|
||
bidders[adUnitSpec.adUnitId] = newBidder
|
||
return newBidder
|
||
}
|
||
return nil
|
||
}
|
||
}
|
||
|
||
func requestNext() -> RequestResult {
|
||
logI("requestNext")
|
||
let result = internalRequestNext()
|
||
logI("requestNext result \(result)")
|
||
logState()
|
||
return result
|
||
}
|
||
|
||
private func internalRequestNext() -> RequestResult {
|
||
if bidding != nil {
|
||
return .busy
|
||
}
|
||
|
||
while !candidatesQueue.isEmpty {
|
||
guard let bid = candidatesQueue.first else {
|
||
break
|
||
}
|
||
candidatesQueue.removeFirst()
|
||
|
||
if winners.contains(aggregatorId: bid.config.aggregatorId) {
|
||
// 若当前bid已存在填充，则忽略
|
||
continue
|
||
}
|
||
|
||
guard let adUnitSpec = selectAdUnitSpec(
|
||
aggregatorConfig: bid.config,
|
||
floor: bid.floor ?? winners.maxRevenue(),
|
||
selfRaise: bid.useSelfRaise
|
||
) else {
|
||
continue
|
||
}
|
||
|
||
logD("selected \(adUnitSpec.adUnitId) with \(adUnitSpec.floorEcpm)")
|
||
|
||
if let bidder = obtainBidder(config: bid.config, adUnitSpec: adUnitSpec) {
|
||
if bidder.load(reason: bid.reason) {
|
||
bidding = bidder
|
||
return .success
|
||
}
|
||
}
|
||
}
|
||
|
||
return .noAvailableSource
|
||
}
|
||
|
||
func refillCandidatesQueue(reason: RequestReason? = nil) {
|
||
logI("refilling candidates")
|
||
logState()
|
||
|
||
for aggregator in priorityAggregators {
|
||
fillCandidate(AggregatorBid(config: aggregator, useSelfRaise: false, reason: reason))
|
||
}
|
||
|
||
logI("candidates refilled")
|
||
logState()
|
||
}
|
||
|
||
private func fillCandidate(_ bid: AggregatorBid) {
|
||
let aggregator = bid.config
|
||
|
||
// 已填充并未过期的，忽略
|
||
if winners.contains(aggregatorId: aggregator.aggregatorId) {
|
||
logD("refilling - \(aggregator.aggregatorId) filled, skip")
|
||
return
|
||
}
|
||
|
||
// 正在填充中的，忽略
|
||
if let currentBidding = bidding, currentBidding.aggregatorId == aggregator.aggregatorId {
|
||
logW("refilling - \(aggregator.aggregatorId) is loading, skip")
|
||
return
|
||
}
|
||
|
||
// 如果未满足某个聚合show完一次才能重试一次的条件，忽略。
|
||
if aggregator.deferRetryUntilShown {
|
||
if !retryGate.canRetry(aggregatorId: aggregator.aggregatorId) {
|
||
logD("refilling - \(aggregator.aggregatorId) deferred until next shown")
|
||
return
|
||
}
|
||
retryGate.markRetryUsed(aggregatorId: aggregator.aggregatorId)
|
||
}
|
||
|
||
logD("refilling - \(aggregator.aggregatorId) added to queue")
|
||
candidatesQueue.append(bid)
|
||
}
|
||
|
||
private func onCacheEvict(_ bidder: T) {
|
||
// candidatesQueue.append(AggregatorBid(config: bidder.config, reason: .EXPIRATION))
|
||
}
|
||
|
||
func reset() {
|
||
logI("reset")
|
||
|
||
for bidder in bidders.values {
|
||
bidder.destroy()
|
||
}
|
||
|
||
bidding?.destroy()
|
||
bidding = nil
|
||
winners.clear()
|
||
bidders.removeAll()
|
||
candidatesQueue.removeAll()
|
||
refillCandidatesQueue()
|
||
}
|
||
|
||
func onShown(winner: T) {
|
||
logI("winner shown, \(winner)")
|
||
logState()
|
||
|
||
retryGate.onAdShown()
|
||
|
||
// 消耗完后，将待填充聚合队列清空，等待hidden后重新填补队列。
|
||
candidatesQueue.removeAll()
|
||
|
||
// 如果配置了自抬价字段，则进入自抬价逻辑
|
||
if winner.config.selfRaiseRate != nil {
|
||
// 当前show成功，加入自抬价意图，自抬价如果失败则重新请求一轮
|
||
candidatesQueue.append(
|
||
AggregatorBid(
|
||
config: winner.config,
|
||
useSelfRaise: true,
|
||
floor: winner.revenue,
|
||
reason: .SHOW
|
||
)
|
||
)
|
||
}
|
||
}
|
||
|
||
func onLoaded(bidderId: Int) {
|
||
logI("onLoaded \(bidderId)")
|
||
|
||
if let bidding = bidding, bidding.id == bidderId {
|
||
winners.add(bidder: bidding)
|
||
self.bidding = nil
|
||
} else {
|
||
logW("onLoaded bidderId mismatch \(String(describing: bidding?.id)) != \(bidderId)")
|
||
}
|
||
|
||
logState()
|
||
}
|
||
|
||
func onLoadFailed(bidderId: Int) {
|
||
logI("onLoadFailed \(bidderId)")
|
||
|
||
if let bidder = bidding, bidder.id == bidderId {
|
||
bidding = nil
|
||
} else {
|
||
logW("onLoadFailed bidderId mismatch \(String(describing: bidding?.id)) != \(bidderId)")
|
||
}
|
||
|
||
logState()
|
||
}
|
||
|
||
func pollMaxRevenue() -> T? {
|
||
return winners.pollMaxRevenue()
|
||
}
|
||
|
||
func peekMaxRevenue() -> T? {
|
||
return winners.peekMaxRevenue()
|
||
}
|
||
|
||
func evictCache() {
|
||
winners.evictCache()
|
||
}
|
||
|
||
private func buildStateLog() -> String {
|
||
var result = "faUnitId(\(faUnitId)), "
|
||
result += winners.buildStateLog()
|
||
result += ", "
|
||
result += "bidding["
|
||
|
||
if let bidding = bidding {
|
||
result += "\(bidding)"
|
||
} else {
|
||
result += "null"
|
||
}
|
||
|
||
result += "], "
|
||
result += "candidates["
|
||
|
||
for bid in candidatesQueue {
|
||
result += "\(bid.config.aggregatorId)("
|
||
result += "\(bid.raiseRate)"
|
||
if bid.useSelfRaise {
|
||
result += " self-raise"
|
||
}
|
||
result += "), "
|
||
}
|
||
|
||
result += "]"
|
||
|
||
return result
|
||
}
|
||
}
|