874 lines
36 KiB
Swift
874 lines
36 KiB
Swift
//
|
||
// MP_AppLovinManager.swift
|
||
// relax.offline.mp3.music
|
||
//
|
||
// Created by Mr.Zhou on 2024/9/18.
|
||
//
|
||
|
||
import UIKit
|
||
import AppLovinSDK
|
||
///AppLovin管理器
|
||
class MP_AppLovinManager: NSObject {
|
||
static let shared = MP_AppLovinManager()
|
||
///广告总开关
|
||
private var openAdStatus:Bool = MP_ADSimpleManager.shared.openAdStatus
|
||
///内部使用广告开光
|
||
private var internalAdStatus:Bool = MP_ADSimpleManager.shared.internalAdStatus
|
||
//AppLovin的SDk密钥
|
||
private var SDKKey:String {
|
||
return "1z4AGzagANHydAtmbNQmAcrt1O5_HtPpt4iNTNW5Bb0RQhaXVByUEQTq5cMcR0l9NnfDtuobQqhSQE0kfEWwAC"
|
||
}
|
||
///广告过期时间(50分钟)
|
||
private let expirationTime:TimeInterval = 3000
|
||
|
||
//检测广告是否过期
|
||
private func wasAdexpirationTime(_ date:Date?) -> Bool {
|
||
guard let loadTime = date else { return false }
|
||
// Check if ad was loaded more than four hours ago.
|
||
return Date().timeIntervalSince(loadTime) < expirationTime
|
||
}
|
||
//MARK: - 插页广告总设置
|
||
///插页广告总开关
|
||
private var interstitialSwitch:Bool = false{
|
||
didSet{
|
||
DispatchQueue.main.async {
|
||
[weak self] in
|
||
MPSideA_MediaCenterManager.shared.isAdLate = self?.interstitialSwitch
|
||
}
|
||
}
|
||
}
|
||
///插页广告显示时间
|
||
var interstitialDate:Date?
|
||
///插页广告间隔秒数(默认40秒)
|
||
private var interstitialDuration:TimeInterval{
|
||
get{
|
||
if let times = UserDefaults.standard.object(forKey: "InterstitialDuration") as? TimeInterval {
|
||
return times
|
||
}else {
|
||
return 40
|
||
}
|
||
}
|
||
}
|
||
///中介间隔秒数
|
||
private var intermediaryDuration:TimeInterval{
|
||
get{
|
||
if let times = UserDefaults.standard.object(forKey: "IntermediaryDuration") as? TimeInterval {
|
||
return times
|
||
}else {
|
||
return 40
|
||
}
|
||
}
|
||
}
|
||
///设置插页总开关
|
||
func setInterstitialSwitch(_ status:Bool) {
|
||
interstitialSwitch = status
|
||
}
|
||
///获得插页开关的状态
|
||
func getInterstitialSwitch() -> Bool {
|
||
return interstitialSwitch
|
||
}
|
||
///开屏中介记录时间值
|
||
private var intermediaryOpenShowTime:Date?
|
||
///插页中介记录时间值
|
||
private var intermediaryInterstitialShowTime:Date?
|
||
///检索与插页广告之间的中介间隔时长是否达标
|
||
private func retrieveIntermediaryInterstitial() -> Bool {
|
||
//判断插页中介记录时间值是否存在
|
||
guard let date = intermediaryInterstitialShowTime else {return true}
|
||
return Date().timeIntervalSince(date) > intermediaryDuration
|
||
}
|
||
///检索与开屏广告之间的中介间隔时长是否达标
|
||
private func retrieveIntermediaryOpen() -> Bool {
|
||
//判断插页中介记录时间值是否存在
|
||
guard let date = intermediaryOpenShowTime else {return true}
|
||
return Date().timeIntervalSince(date) > intermediaryDuration
|
||
}
|
||
///是否达到插页间隔时长（达到即可继续展示插页广告）
|
||
private func isShowInterstitialADAvailable(_ date:Date) -> Bool {
|
||
return Date().timeIntervalSince(date) > interstitialDuration
|
||
}
|
||
override init() {
|
||
super.init()
|
||
reloadAppLovinIDs()
|
||
//对开屏广告完成处理闭包
|
||
completeOpenAdBlock = {
|
||
[weak self] in
|
||
guard let self = self, interstitialSwitch == true else {return}
|
||
//销毁现在的开屏广告实例
|
||
appOpenAd = nil
|
||
isShowingOpenAd = false
|
||
loadOpenAdTime = nil
|
||
//关闭插页广告开关
|
||
interstitialSwitch = false
|
||
//更新开屏广告中介间隔时间
|
||
intermediaryOpenShowTime = Date()
|
||
//重新加载后续的开屏广告
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 4) {
|
||
[weak self] in
|
||
self?.loadOpenAd{ status in
|
||
if status == true {
|
||
print("新的开屏广告加载成功")
|
||
}else {
|
||
print("开屏广告加载失败了")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//搜索插页广告完成处理闭包
|
||
completeSearchInterstitialAdBlock = {
|
||
[weak self] in
|
||
guard let self = self, interstitialSwitch == true else {return}
|
||
//销毁现在的搜索插页广告实例
|
||
searchInterstitialAd = nil
|
||
isShowingSearchInterstitialAd = false
|
||
loadSearchInterstitialAdTime = nil
|
||
//关闭插页广告开关
|
||
interstitialSwitch = false
|
||
//更新插页广告中介间隔时长
|
||
intermediaryInterstitialShowTime = Date()
|
||
//重新加载后续的搜索插页广告
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
|
||
[weak self] in
|
||
self?.loadSearchInterstitialAd { status in
|
||
if status {
|
||
print("成功加载搜索插页广告")
|
||
}else {
|
||
print("搜索插页广告加载失败")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//播放插页广告完成处理闭包
|
||
completePlayInterstitialAdBlock = {
|
||
[weak self] in
|
||
guard let self = self, interstitialSwitch == true else {return}
|
||
//销毁现在的播放插页广告实例
|
||
playInterstitialAd = nil
|
||
isShowingPlayInterstitialAd = false
|
||
loadPlayInterstitialAdTime = nil
|
||
//关闭插页广告开关
|
||
interstitialSwitch = false
|
||
//更新插页广告中介间隔时长
|
||
intermediaryInterstitialShowTime = Date()
|
||
//重新加载后续的播放插页广告
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
|
||
[weak self] in
|
||
self?.loadPlayInterstitialAd { status in
|
||
if status {
|
||
print("成功加载播放插页广告")
|
||
}else {
|
||
print("播放插页广告加载失败")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//曲库插页广告完成处理闭包
|
||
completeLibraryInterstitialAdBlock = {
|
||
[weak self] in
|
||
guard let self = self, interstitialSwitch == true else {return}
|
||
//销毁现在的曲库插页广告实例
|
||
libraryInterstitialAd = nil
|
||
isShowingLibraryInterstitialAd = false
|
||
loadLibraryInterstitialAdTime = nil
|
||
//关闭插页广告开关
|
||
interstitialSwitch = false
|
||
//更新插页广告中介间隔时长
|
||
intermediaryInterstitialShowTime = Date()
|
||
//重新加载后续的曲库插页广告
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
|
||
[weak self] in
|
||
self?.loadLibraryInterstitialAd { status in
|
||
if status {
|
||
print("成功加载曲库插页广告")
|
||
}else {
|
||
print("曲库插页广告加载失败")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
///初始化
|
||
func startConfig() {
|
||
//AppLovin初始化配置
|
||
let initConfig = ALSdkInitializationConfiguration(sdkKey: SDKKey) { builder in
|
||
builder.mediationProvider = ALMediationProviderMAX
|
||
}
|
||
// //设置全部静音
|
||
// ALSdk.shared().settings.isMuted = true
|
||
ALSdk.shared().settings.userIdentifier = app_UUID
|
||
//AppLovin初始化
|
||
ALSdk.shared().initialize(with: initConfig)
|
||
}
|
||
///更新广告ID
|
||
func reloadAppLovinIDs() {
|
||
//更新要用到的广告信息
|
||
if let data = UserDefaults.standard.object(forKey: "Max_OpenICEIDs") as? Data, let array = jsonforCoreAdModel(data) {
|
||
print("成功提取ID")
|
||
OpenIDs = array.sorted(by: {$0.level > $1.level})
|
||
}
|
||
if let data = UserDefaults.standard.object(forKey: "Max_SearchINSERTIDs") as? Data, let array = jsonforCoreAdModel(data) {
|
||
SearchINSERTIDs = array.sorted(by: {$0.level > $1.level})
|
||
}
|
||
if let data = UserDefaults.standard.object(forKey: "Max_PlayerINSERTIDs") as? Data, let array = jsonforCoreAdModel(data) {
|
||
PlayerINSERTIDs = array.sorted(by: {$0.level > $1.level})
|
||
}
|
||
if let data = UserDefaults.standard.object(forKey: "Max_LibraryNATIVEIDs") as? Data, let array = jsonforCoreAdModel(data) {
|
||
LibraryINSERTIDs = array.sorted(by: {$0.level > $1.level})
|
||
}
|
||
}
|
||
///加载广告
|
||
func loadMoreAds(){
|
||
loadPlayInterstitialAd{status in
|
||
if status {
|
||
print("成功加载播放插页广告")
|
||
}else {
|
||
print("播放插页广告加载失败")
|
||
}
|
||
}
|
||
loadSearchInterstitialAd { status in
|
||
if status {
|
||
print("成功加载搜索插页广告")
|
||
}else {
|
||
print("搜索插页广告加载失败")
|
||
}
|
||
}
|
||
loadLibraryInterstitialAd { status in
|
||
if status {
|
||
print("成功加载曲库插页广告")
|
||
}else {
|
||
print("曲库插页广告加载失败")
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
//MARK: - 开屏广告
|
||
///开屏广告ID组
|
||
private var OpenIDs:[MPPositive_AdItemModel] = []
|
||
///开屏广告
|
||
var appOpenAd:MAInterstitialAd?
|
||
///是否正在加载开屏广告
|
||
private var isLoadingOpenAd:Bool = false
|
||
///是否正在展示开屏广告
|
||
var isShowingOpenAd:Bool = false
|
||
//开屏广告加载时间
|
||
private var loadOpenAdTime:Date?
|
||
//开屏广告回调传值闭包
|
||
private var loadStatuOpenAdBlock:((Bool) -> Void)?
|
||
//开屏广告加载完成处理闭包
|
||
var completeOpenAdBlock:(() -> Void)?
|
||
//当前加载的ID数组Level阶级（从0开始，越低等级越高）
|
||
private var openLevel:Int = 0
|
||
//开屏广告时间间隔(默认10秒)
|
||
private var openAppDuration:TimeInterval{
|
||
get{
|
||
if let times = UserDefaults.standard.object(forKey: "OpenAppDuration") as? TimeInterval {
|
||
return times
|
||
}else {
|
||
return 10
|
||
}
|
||
}
|
||
}
|
||
//设置开屏广告时间间隔
|
||
func setOpenAppDuration(_ duration:TimeInterval) {
|
||
UserDefaults.standard.set(duration, forKey: "OpenAppDuration")
|
||
}
|
||
//获取开屏广告时间间隔
|
||
func getOpenAppDuration() -> TimeInterval {
|
||
return self.openAppDuration
|
||
}
|
||
///加载开屏广告
|
||
func loadOpenAd(_ level:Int = 0, completion: @escaping (Bool) -> Void) {
|
||
guard openAdStatus, internalAdStatus else {return}
|
||
// 检测当前是否有广告或者有广告正在加载
|
||
if isLoadingOpenAd || isOpenAdAvailable() {
|
||
// 有广告或有广告在加载
|
||
completion(false)
|
||
return
|
||
}
|
||
//检索是否超过了对应的id组的阶级数量
|
||
guard OpenIDs.isEmpty == false else {
|
||
//冷启动无数据
|
||
MP_AnalyticsManager.shared.max_lunch_showFailureAction("No IDs")
|
||
//重新获取数据
|
||
reloadAppLovinIDs()
|
||
completion(false)
|
||
return
|
||
}
|
||
guard level < (OpenIDs.count) else {
|
||
print("开屏广告组已经全部加载失败，停止继续加载")
|
||
MP_AnalyticsManager.shared.max_lunch_loadFailureAction("No Ads Fill")
|
||
completion(false)
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
|
||
[weak self] in
|
||
self?.loadOpenAd( completion: { status in
|
||
if status {
|
||
print("重新加载启动广告成功")
|
||
}else {
|
||
print("重新加载启动广告失败")
|
||
}
|
||
})
|
||
}
|
||
return
|
||
}
|
||
let item = OpenIDs[level]
|
||
openLevel = level
|
||
//重置闭包导向
|
||
loadStatuOpenAdBlock = completion
|
||
//根据ID生成广告
|
||
appOpenAd = MAInterstitialAd(adUnitIdentifier: item.identifier)
|
||
appOpenAd?.delegate = self
|
||
//加载开屏广告
|
||
appOpenAd?.load()
|
||
}
|
||
///展示加载广告
|
||
func showOpenAdIfAvailable(_ completion:((_ T:MAInterstitialAd) -> Void)?) {
|
||
guard openAdStatus, internalAdStatus else {return}
|
||
// 如果应用插页广告或者开屏广告已经正在展示，则不再展示该广告。
|
||
guard !interstitialSwitch, !isShowingOpenAd, retrieveIntermediaryInterstitial() else { return }
|
||
// 如果应用开屏广告尚不可用但应该显示，则加载新广告。
|
||
if !isOpenAdAvailable() {
|
||
loadOpenAd{ [weak self] success in
|
||
guard let self = self else { return }
|
||
if success {
|
||
self.showOpenAdIfAvailable(completion)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
MP_AnalyticsManager.shared.max_lunch_chanceAction()
|
||
if let ad = appOpenAd, ad.isReady {
|
||
//传递加载完成事件
|
||
if let block = completion {
|
||
block(ad)
|
||
}else {
|
||
isShowingOpenAd = true
|
||
interstitialSwitch = true
|
||
DispatchQueue.main.async {
|
||
[weak self] in
|
||
guard let self = self else {return}
|
||
//可以展示
|
||
ad.show()
|
||
}
|
||
}
|
||
}else {
|
||
print("开屏广告展示失败")
|
||
MP_AnalyticsManager.shared.max_lunch_showFailureAction("Ad loading failed")
|
||
}
|
||
}
|
||
///查询是否有开屏广告
|
||
func isOpenAdAvailable() -> Bool {
|
||
return (appOpenAd != nil) && wasAdexpirationTime(loadOpenAdTime)
|
||
}
|
||
//MARK: - 搜索
|
||
///搜索插页广告ID
|
||
private var SearchINSERTIDs:[MPPositive_AdItemModel] = []
|
||
///搜索插页广告
|
||
private var searchInterstitialAd:MAInterstitialAd?
|
||
///是否正在加载搜索插页广告
|
||
private var isLoadingSearchInterstitialAd:Bool = false
|
||
///是否正在展示搜索插页广告
|
||
var isShowingSearchInterstitialAd:Bool = false
|
||
///搜索插页加载时间
|
||
private var loadSearchInterstitialAdTime:Date?
|
||
///搜索广告处理闭包
|
||
var completeSearchInterstitialAdBlock:(() -> Void)?
|
||
//开屏广告回调传值闭包
|
||
private var loadStatuSearchAdBlock:((Bool) -> Void)?
|
||
//当前加载的ID数组Level阶级（从0开始，越低等级越高）
|
||
private var searchLevel:Int = 0
|
||
//异步加载搜索插页广告
|
||
func loadSearchInterstitialAd(_ level:Int = 0, completion: @escaping (Bool) -> Void) {
|
||
guard openAdStatus, internalAdStatus else {return}
|
||
if isLoadingSearchInterstitialAd || isSearchInterstitialAdAvailable() {
|
||
// 有广告或有广告在加载
|
||
completion(false)
|
||
return
|
||
}
|
||
guard SearchINSERTIDs.isEmpty == false else {
|
||
MP_AnalyticsManager.shared.max_search_showFailureAction("No IDs")
|
||
//重新获取数据
|
||
reloadAppLovinIDs()
|
||
completion(false)
|
||
return
|
||
}
|
||
guard level < (SearchINSERTIDs.count) else {
|
||
print("搜索插页广告组已经全部加载失败，停止继续加载")
|
||
MP_AnalyticsManager.shared.max_search_loadFailureAction("No Ads Fill")
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
|
||
[weak self] in
|
||
self?.loadSearchInterstitialAd { status in
|
||
if status {
|
||
print("重新加载搜索插页广告")
|
||
}else {
|
||
print("加载搜索插页广告失败")
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
isLoadingSearchInterstitialAd = true
|
||
searchLevel = level
|
||
//重置闭包导向
|
||
loadStatuSearchAdBlock = completion
|
||
let item = SearchINSERTIDs[level]
|
||
//根据ID生成广告
|
||
searchInterstitialAd = MAInterstitialAd(adUnitIdentifier: item.identifier)
|
||
searchInterstitialAd?.delegate = self
|
||
//加载开屏广告
|
||
searchInterstitialAd?.load()
|
||
}
|
||
///搜索插页广告展示
|
||
func showSearchInterstitialAdIfAvailable(_ completion:((MAInterstitialAd) -> Void)?) {
|
||
guard openAdStatus, internalAdStatus else {return}
|
||
// 如果应用插页广告或者开屏广告已经正在展示，则不再展示该广告。
|
||
guard !interstitialSwitch, !isShowingSearchInterstitialAd, retrieveIntermediaryOpen() else { return }
|
||
//检索是否存在插页间隔时间
|
||
if let date = interstitialDate {
|
||
if isShowInterstitialADAvailable(date) == false {
|
||
//未超过插页间隔时长
|
||
print("距上一次展示插页广告时长未超过要求，此次插页广告展示滞后")
|
||
return
|
||
}
|
||
}
|
||
// 如果搜索广告尚不可用但应该显示，则加载新广告。
|
||
if !isSearchInterstitialAdAvailable() {
|
||
loadSearchInterstitialAd { [weak self] success in
|
||
guard let self = self else { return }
|
||
if success {
|
||
self.showSearchInterstitialAdIfAvailable(completion)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
MP_AnalyticsManager.shared.max_search_chanceAction()
|
||
//当搜索插页广告确定有值后展示
|
||
if let ad = searchInterstitialAd, ad.isReady {
|
||
//传递加载完成事件
|
||
if let block = completion {
|
||
block(ad)
|
||
}else {
|
||
isShowingSearchInterstitialAd = true
|
||
interstitialSwitch = true
|
||
DispatchQueue.main.async {
|
||
[weak self] in
|
||
guard let self = self else {return}
|
||
//可以展示
|
||
ad.show()
|
||
}
|
||
}
|
||
}else {
|
||
MP_AnalyticsManager.shared.max_search_showFailureAction("Ad loading failed")
|
||
}
|
||
}
|
||
//查询是否有搜索插页广告
|
||
func isSearchInterstitialAdAvailable() -> Bool {
|
||
return searchInterstitialAd != nil && wasAdexpirationTime(loadSearchInterstitialAdTime)
|
||
}
|
||
//MARK: - 播放/切割插页广告位
|
||
///播放插页广告ID
|
||
private var PlayerINSERTIDs:[MPPositive_AdItemModel] = []
|
||
///播放插页广告
|
||
var playInterstitialAd:MAInterstitialAd?
|
||
///是否正在加载播放插页广告
|
||
private var isLoadingPlayInterstitialAd:Bool = false
|
||
///是否正在展示播放插页广告
|
||
var isShowingPlayInterstitialAd:Bool = false
|
||
///播放插页加载时间
|
||
private var loadPlayInterstitialAdTime:Date?
|
||
///播放广告处理闭包
|
||
var completePlayInterstitialAdBlock:(() -> Void)?
|
||
//开屏广告回调传值闭包
|
||
private var loadStatuPlayAdBlock:((Bool) -> Void)?
|
||
//当前加载的ID数组Level阶级（从0开始，越低等级越高）
|
||
private var playLevel:Int = 0
|
||
//异步加载播放插页广告
|
||
func loadPlayInterstitialAd(_ level:Int = 0, completion: @escaping (Bool) -> Void) {
|
||
guard openAdStatus, internalAdStatus else {
|
||
completion(false)
|
||
return
|
||
}
|
||
// 检测当前是否有广告或者有广告正在加载
|
||
if isLoadingPlayInterstitialAd || isPlayInterstitialAdAvailable() {
|
||
// 有广告或有广告在加载
|
||
completion(false)
|
||
return
|
||
}
|
||
guard PlayerINSERTIDs.isEmpty == false else {
|
||
MP_AnalyticsManager.shared.max_play_showFailureAction("No IDs")
|
||
//重新获取数据
|
||
reloadAppLovinIDs()
|
||
completion(false)
|
||
return
|
||
}
|
||
|
||
guard level < (PlayerINSERTIDs.count) else {
|
||
print("播放插页广告组已经全部加载失败，停止继续加载")
|
||
MP_AnalyticsManager.shared.max_play_loadFailureAction("No Ads Fill")
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
|
||
[weak self] in
|
||
self?.loadPlayInterstitialAd { status in
|
||
if status {
|
||
print("重新加载播放插页广告")
|
||
}else {
|
||
print("加载播放插页广告失败")
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
isLoadingPlayInterstitialAd = true
|
||
playLevel = level
|
||
//重置闭包导向
|
||
loadStatuPlayAdBlock = completion
|
||
let item = PlayerINSERTIDs[level]
|
||
//根据ID生成广告
|
||
playInterstitialAd = MAInterstitialAd(adUnitIdentifier: item.identifier)
|
||
playInterstitialAd?.delegate = self
|
||
//加载开屏广告
|
||
playInterstitialAd?.load()
|
||
}
|
||
///播放插页广告展示
|
||
func showPlayInterstitialAdIfAvailable(_ completion:((MAInterstitialAd?) -> Void)?) {
|
||
guard openAdStatus, internalAdStatus else {
|
||
completion?(nil)
|
||
return
|
||
}
|
||
guard MP_NetWorkManager.shared.netWorkStatu == .reachable else {
|
||
completion?(nil)
|
||
return
|
||
}
|
||
// 如果应用插页广告或者开屏广告已经正在展示，则不再展示该广告。
|
||
guard !interstitialSwitch, !isShowingPlayInterstitialAd, retrieveIntermediaryOpen() else {
|
||
completion?(nil)
|
||
return
|
||
}
|
||
//检索是否存在插页间隔时间
|
||
if let date = interstitialDate {
|
||
if isShowInterstitialADAvailable(date) == false {
|
||
//未超过插页间隔时长
|
||
print("距上一次展示插页广告时长未超过要求，此次插页广告展示滞后")
|
||
completion?(nil)
|
||
return
|
||
}
|
||
}
|
||
// 如果播放插页广告尚不可用但应该显示，则加载新广告。
|
||
if !isPlayInterstitialAdAvailable() {
|
||
loadPlayInterstitialAd{ [weak self] success in
|
||
guard let self = self else { return }
|
||
if success {
|
||
print("播放广告已加载")
|
||
}
|
||
}
|
||
completion?(nil)
|
||
return
|
||
}
|
||
MP_AnalyticsManager.shared.max_play_chanceACtion()
|
||
//当播放插页广告确定有值后展示
|
||
if let ad = playInterstitialAd, ad.isReady {
|
||
//传递加载完成事件
|
||
if let block = completion {
|
||
block(ad)
|
||
}else {
|
||
isShowingPlayInterstitialAd = true
|
||
interstitialSwitch = true
|
||
DispatchQueue.main.async {
|
||
[weak self] in
|
||
guard let self = self else {return}
|
||
//可以展示
|
||
ad.show()
|
||
}
|
||
}
|
||
}else {
|
||
MP_AnalyticsManager.shared.max_play_showFailureAction("Ad loading failed")
|
||
completion?(nil)
|
||
}
|
||
}
|
||
//查询是否有播放插页广告
|
||
func isPlayInterstitialAdAvailable() -> Bool {
|
||
return playInterstitialAd != nil && wasAdexpirationTime(loadPlayInterstitialAdTime)
|
||
}
|
||
//MARK: - 曲库/下载插页广告位
|
||
///曲库插页ID
|
||
private var LibraryINSERTIDs:[MPPositive_AdItemModel] = []
|
||
///曲库插页广告
|
||
private var libraryInterstitialAd:MAInterstitialAd?
|
||
///是否正在加载曲库插页广告
|
||
private var isLoadingLibraryInterstitialAd:Bool = false
|
||
///是否正在展示曲库插页广告
|
||
var isShowingLibraryInterstitialAd:Bool = false
|
||
///曲库插页加载时间
|
||
private var loadLibraryInterstitialAdTime:Date?
|
||
///曲库广告处理闭包
|
||
var completeLibraryInterstitialAdBlock:(() -> Void)?
|
||
//开屏广告回调传值闭包
|
||
private var loadStatuLibraryAdBlock:((Bool) -> Void)?
|
||
//当前加载的ID数组Level阶级（从0开始，越低等级越高）
|
||
private var libraryLevel:Int = 0
|
||
//异步加载曲库插页广告
|
||
func loadLibraryInterstitialAd(_ level:Int = 0, completion: @escaping (Bool) -> Void) {
|
||
guard openAdStatus, internalAdStatus else {
|
||
completion(false)
|
||
return
|
||
}
|
||
// 检测当前是否有广告或者有广告正在加载
|
||
if isLoadingLibraryInterstitialAd || isLibraryInterstitialAdAvailable() {
|
||
// 有广告或有广告在加载
|
||
completion(false)
|
||
return
|
||
}
|
||
guard LibraryINSERTIDs.isEmpty == false else {
|
||
MP_AnalyticsManager.shared.max_library_showFailureAction("No IDs")
|
||
//重新获取数据
|
||
reloadAppLovinIDs()
|
||
completion(false)
|
||
return
|
||
}
|
||
guard level < (LibraryINSERTIDs.count) else {
|
||
print("曲库插页广告组已经全部加载失败，停止继续加载")
|
||
MP_AnalyticsManager.shared.max_library_loadFailureAction("No Ads Fill")
|
||
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
|
||
[weak self] in
|
||
self?.loadLibraryInterstitialAd { status in
|
||
if status {
|
||
print("重新加载曲库插页广告")
|
||
}else {
|
||
print("加载曲库插页广告失败")
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
isLoadingLibraryInterstitialAd = true
|
||
libraryLevel = level
|
||
//重置闭包导向
|
||
loadStatuLibraryAdBlock = completion
|
||
let item = LibraryINSERTIDs[level]
|
||
//根据ID生成广告
|
||
libraryInterstitialAd = MAInterstitialAd(adUnitIdentifier: item.identifier)
|
||
libraryInterstitialAd?.delegate = self
|
||
//加载开屏广告
|
||
libraryInterstitialAd?.load()
|
||
}
|
||
///曲库插页广告展示
|
||
func showLibraryInterstitialAdIfAvailable(_ completion:((MAInterstitialAd) -> Void)?) {
|
||
// 如果应用插页广告或者开屏广告已经正在展示，则不再展示该广告。
|
||
guard !interstitialSwitch, !isShowingLibraryInterstitialAd, retrieveIntermediaryOpen() else { return }
|
||
//检索是否存在插页间隔时间
|
||
if let date = interstitialDate {
|
||
if isShowInterstitialADAvailable(date) == false {
|
||
//未超过插页间隔时长
|
||
print("距上一次展示插页广告时长未超过要求，此次插页广告展示滞后")
|
||
return
|
||
}
|
||
}
|
||
// 如果曲库广告尚不可用但应该显示，则加载新广告。
|
||
if !isLibraryInterstitialAdAvailable() {
|
||
loadLibraryInterstitialAd { [weak self] success in
|
||
guard let self = self else { return }
|
||
if success {
|
||
self.showLibraryInterstitialAdIfAvailable(completion)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
MP_AnalyticsManager.shared.max_library_chanceAction()
|
||
//当曲库插页广告确定有值后展示
|
||
if let ad = libraryInterstitialAd, ad.isReady {
|
||
//传递加载完成事件
|
||
if let block = completion {
|
||
block(ad)
|
||
}else {
|
||
isShowingPlayInterstitialAd = true
|
||
interstitialSwitch = true
|
||
DispatchQueue.main.async {
|
||
[weak self] in
|
||
guard let self = self else {return}
|
||
//可以展示
|
||
ad.show()
|
||
}
|
||
}
|
||
}else {
|
||
MP_AnalyticsManager.shared.max_library_showFailureAction("Ad loading failed")
|
||
}
|
||
}
|
||
//查询是否有曲库插页广告
|
||
func isLibraryInterstitialAdAvailable() -> Bool {
|
||
return libraryInterstitialAd != nil && wasAdexpirationTime(loadLibraryInterstitialAdTime)
|
||
}
|
||
}
|
||
//MARK: - 插页广告代理实现
|
||
extension MP_AppLovinManager: MAAdDelegate {
|
||
//广告加载成功
|
||
func didLoad(_ ad: MAAd) {
|
||
let adUnitIdentifier = ad.adUnitIdentifier
|
||
//判断广告位
|
||
if adUnitIdentifier == appOpenAd?.adUnitIdentifier {
|
||
//是开屏广告，调整加载状态
|
||
isLoadingOpenAd = false
|
||
//更新开屏广告加载时间
|
||
loadOpenAdTime = Date()
|
||
//实现开屏广告回调闭包
|
||
if let block = loadStatuOpenAdBlock {
|
||
block(true)
|
||
}
|
||
}else if adUnitIdentifier == searchInterstitialAd?.adUnitIdentifier {
|
||
//是搜索插页广告，调整加载状态
|
||
isLoadingSearchInterstitialAd = false
|
||
//更新搜索插页广告加载时间
|
||
loadSearchInterstitialAdTime = Date()
|
||
//实现搜索插页广告回调闭包
|
||
if let block = loadStatuSearchAdBlock {
|
||
block(true)
|
||
}
|
||
}else if adUnitIdentifier == playInterstitialAd?.adUnitIdentifier {
|
||
//是播放插页广告
|
||
isLoadingPlayInterstitialAd = false
|
||
//更新播放插页广告加载时间
|
||
loadPlayInterstitialAdTime = Date()
|
||
//实现播放插页广告回调闭包
|
||
if let block = loadStatuPlayAdBlock {
|
||
block(true)
|
||
}
|
||
}else if adUnitIdentifier == libraryInterstitialAd?.adUnitIdentifier {
|
||
//是曲库插页广告
|
||
isLoadingLibraryInterstitialAd = false
|
||
//更新曲库插页广告加载时间
|
||
loadLibraryInterstitialAdTime = Date()
|
||
//实现曲库插页广告回调
|
||
if let block = loadStatuLibraryAdBlock {
|
||
block(true)
|
||
}
|
||
}
|
||
}
|
||
//广告加载失败
|
||
func didFailToLoadAd(forAdUnitIdentifier adUnitIdentifier: String, withError error: MAError) {
|
||
//判断广告位
|
||
if adUnitIdentifier == appOpenAd?.adUnitIdentifier {
|
||
//是开屏广告，调整加载状态
|
||
isLoadingOpenAd = false
|
||
//开屏广告加载失败，销毁广告
|
||
appOpenAd = nil
|
||
MP_AnalyticsManager.shared.max_lunch_loadFailureAction(error.message)
|
||
if let block = loadStatuOpenAdBlock {
|
||
//重新加载广告
|
||
loadOpenAd(openLevel + 1, completion: block)
|
||
}
|
||
}else if adUnitIdentifier == searchInterstitialAd?.adUnitIdentifier {
|
||
//是搜索插页广告，调整加载状态
|
||
isLoadingSearchInterstitialAd = false
|
||
searchInterstitialAd = nil
|
||
MP_AnalyticsManager.shared.max_search_loadFailureAction(error.message)
|
||
if let block = loadStatuSearchAdBlock {
|
||
loadSearchInterstitialAd(searchLevel + 1, completion: block)
|
||
}
|
||
}else if adUnitIdentifier == playInterstitialAd?.adUnitIdentifier {
|
||
//是播放插页广告
|
||
isLoadingPlayInterstitialAd = false
|
||
playInterstitialAd = nil
|
||
MP_AnalyticsManager.shared.max_play_loadFailureAction(error.message)
|
||
if let block = loadStatuPlayAdBlock {
|
||
loadPlayInterstitialAd(playLevel + 1, completion: block)
|
||
}
|
||
}else if adUnitIdentifier == libraryInterstitialAd?.adUnitIdentifier {
|
||
//是曲库插页广告
|
||
isLoadingLibraryInterstitialAd = false
|
||
libraryInterstitialAd = nil
|
||
MP_AnalyticsManager.shared.max_library_loadFailureAction(error.message)
|
||
if let block = loadStatuLibraryAdBlock {
|
||
loadLibraryInterstitialAd(libraryLevel + 1, completion: block)
|
||
}
|
||
}
|
||
}
|
||
//广告展示
|
||
func didDisplay(_ ad: MAAd) {
|
||
let adUnitIdentifier = ad.adUnitIdentifier
|
||
//检索广告位
|
||
if adUnitIdentifier == appOpenAd?.adUnitIdentifier {
|
||
//开屏广告
|
||
print("当前展示的广告是开屏广告，广告ID--\(ad.adUnitIdentifier)")
|
||
//上传广告事件
|
||
}else if adUnitIdentifier == searchInterstitialAd?.adUnitIdentifier {
|
||
//搜索广告位
|
||
print("当前展示的广告是搜索插页广告，广告ID--\(ad.adUnitIdentifier)")
|
||
//上传广告事件
|
||
}else if adUnitIdentifier == playInterstitialAd?.adUnitIdentifier {
|
||
//播放广告位
|
||
print("当前展示的广告是播放插页广告，广告ID--\(ad.adUnitIdentifier)")
|
||
}else if adUnitIdentifier == libraryInterstitialAd?.adUnitIdentifier {
|
||
//曲库广告位
|
||
print("当前展示的广告是曲库插页广告，广告ID--\(ad.adUnitIdentifier)")
|
||
}
|
||
}
|
||
//广告关闭
|
||
func didHide(_ ad: MAAd) {
|
||
let adUnitIdentifier = ad.adUnitIdentifier
|
||
//更新插页广告展示时间
|
||
interstitialDate = Date()
|
||
if adUnitIdentifier == appOpenAd?.adUnitIdentifier {
|
||
print("当前消失的广告是开屏广告，广告ID--\(ad.adUnitIdentifier)")
|
||
if let block = completeOpenAdBlock {
|
||
block()
|
||
}
|
||
}else if adUnitIdentifier == searchInterstitialAd?.adUnitIdentifier {
|
||
//搜索广告位
|
||
print("当前消失的广告是搜索插页广告，广告ID--\(ad.adUnitIdentifier)")
|
||
if let block = completeSearchInterstitialAdBlock {
|
||
block()
|
||
}
|
||
}else if adUnitIdentifier == playInterstitialAd?.adUnitIdentifier {
|
||
//播放广告位
|
||
print("当前消失的广告是播放插页广告，广告ID--\(ad.adUnitIdentifier)")
|
||
if let block = completePlayInterstitialAdBlock {
|
||
block()
|
||
}
|
||
}else if adUnitIdentifier == libraryInterstitialAd?.adUnitIdentifier {
|
||
//曲库广告位
|
||
print("当前消失的广告是曲库插页广告，广告ID--\(ad.adUnitIdentifier)")
|
||
if let block = completeLibraryInterstitialAdBlock {
|
||
block()
|
||
}
|
||
}
|
||
}
|
||
//广告点击
|
||
func didClick(_ ad: MAAd) {
|
||
|
||
}
|
||
//广告展示失败
|
||
func didFail(toDisplay ad: MAAd, withError error: MAError) {
|
||
let adUnitIdentifier = ad.adUnitIdentifier
|
||
//更新插页广告展示时间
|
||
interstitialDate = Date()
|
||
if adUnitIdentifier == appOpenAd?.adUnitIdentifier {
|
||
print("开屏广告展示时出错，广告ID--\(ad.adUnitIdentifier)，具体错误原因:\(error.message)")
|
||
MP_AnalyticsManager.shared.max_lunch_showFailureAction(error.message)
|
||
if let block = completeOpenAdBlock {
|
||
block()
|
||
}
|
||
}else if adUnitIdentifier == searchInterstitialAd?.adUnitIdentifier {
|
||
//搜索广告位
|
||
print("搜索插页广告展示时出错，广告ID--\(ad.adUnitIdentifier)，具体错误原因:\(error.message)")
|
||
MP_AnalyticsManager.shared.max_search_showFailureAction(error.message)
|
||
if let block = completeSearchInterstitialAdBlock {
|
||
block()
|
||
}
|
||
}else if adUnitIdentifier == playInterstitialAd?.adUnitIdentifier {
|
||
//播放广告位
|
||
print("播放插页广告展示时出错，广告ID--\(ad.adUnitIdentifier)，具体错误原因:\(error.message)")
|
||
MP_AnalyticsManager.shared.max_play_showFailureAction(error.message)
|
||
if let block = completePlayInterstitialAdBlock {
|
||
block()
|
||
}
|
||
}else if adUnitIdentifier == libraryInterstitialAd?.adUnitIdentifier {
|
||
//曲库广告位
|
||
print("曲库插页广告展示时出错，广告ID--\(ad.adUnitIdentifier)，具体错误原因:\(error.message)")
|
||
MP_AnalyticsManager.shared.max_library_showFailureAction(error.message)
|
||
if let block = completeLibraryInterstitialAdBlock {
|
||
block()
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
}
|