fix

无故事王国

2024-06-20 f2e891eecfac25bf6aed38c8eadfdf05704b16b6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
//
//  SceneDelegate.swift
//  DolphinEnglishLearnStudent
//
//  Created by 无故事王国 on 2024/5/22.
//
 
import UIKit
import SVProgressHUD
 
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
 
                var window: UIWindow?
                var globalTimeval:Int?
                var timer:Timer?
                private var disposeBag = JQ_disposeBag
 
                func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
                                guard let windowScene = (scene as? UIWindowScene) else { return }
                                UserDefaults.standard.set(Date().timeIntervalSince1970, forKey: "scheduledTimer")
                                window = UIWindow(windowScene: windowScene)
                                window?.frame = windowScene.coordinateSpace.bounds
                                if #available(iOS 13.0, *) {
                                                window?.overrideUserInterfaceStyle = .light
                                }
 
                                SVProgressHUD.setMaximumDismissTimeInterval(1.5)
                                SVProgressHUD.setDefaultMaskType(.custom)
 
                                guard !LoginTokenModel.isOverdue() else {
                                                needLogin();return
                                }
                                loginSuccess()
 
                                if WXApi.isWXAppInstalled(){
                                                WeChatTools.sendAuthRequest()
                                }
                }
 
                func sceneDidDisconnect(_ scene: UIScene) {
                                // Called as the scene is being released by the system.
                                // This occurs shortly after the scene enters the background, or when its session is discarded.
                                // Release any resources associated with this scene that can be re-created the next time the scene connects.
                                // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead).
                }
 
                func sceneDidBecomeActive(_ scene: UIScene) {
                                // Called when the scene has moved from an inactive state to an active state.
                                // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
                }
 
                func sceneWillResignActive(_ scene: UIScene) {
                                // Called when the scene will move from an active state to an inactive state.
                                // This may occur due to temporary interruptions (ex. an incoming phone call).
                }
 
                func sceneWillEnterForeground(_ scene: UIScene) {
                                // Called as the scene transitions from the background to the foreground.
                                // Use this method to undo the changes made on entering the background.
                }
 
                func sceneDidEnterBackground(_ scene: UIScene) {
                                // Called as the scene transitions from the foreground to the background.
                                // Use this method to save data, release shared resources, and store enough scene-specific state information
                                // to restore the scene back to its current state.
                }
}
 
extension SceneDelegate{
                func loginSuccess(){
                                let tabBar = BaseTabBarVC()
                                let homeNav = BaseNav(rootViewController: HomeVC())
                                homeNav.tabBarItem = UITabBarItem(title: "首页", image: UIImage(named: "nav_home"), selectedImage: UIImage(named: "nav_home_s")!.withRenderingMode(.alwaysOriginal))
 
                                let marketNav = BaseNav(rootViewController: MarketVC())
                                marketNav.tabBarItem = UITabBarItem(title: "商城", image: UIImage(named: "nav_market"), selectedImage: UIImage(named: "nav_market_s")!.withRenderingMode(.alwaysOriginal))
 
                                let meNav = BaseNav(rootViewController: MeVC())
                                meNav.tabBarItem = UITabBarItem(title: "我的", image: UIImage(named: "nav_me"), selectedImage: UIImage(named: "nav_me_s")!.withRenderingMode(.alwaysOriginal))
 
 
                                tabBar.viewControllers = [homeNav,marketNav,meNav]
                                sceneDelegate?.window?.rootViewController = tabBar
                                sceneDelegate?.window?.makeKeyAndVisible()
                }
 
                func needLogin(){
                                sceneDelegate?.window?.rootViewController = BaseNav(rootViewController: LoginVC())
                                sceneDelegate?.window?.makeKeyAndVisible()
                                LoginTokenModel.clearToken()
 
                }
 
                func startTimer(){
                                guard let timeval = globalTimeval  else {return}
                                timer = Timer.scheduledTimer(withTimeInterval: 60, repeats: true) {[weak self] timer in
                                                guard let weakSelf = self else { return }
                                                if let v = UserDefaults.standard.object(forKey: "scheduledTimer") as? TimeInterval{
                                                                if Date().timeIntervalSince1970 - v > Double(timeval) * 60.0{
                                                Services.giveIntegral().subscribe(onNext: { _ in
 
                                                }).disposed(by: weakSelf.disposeBag)
                                                                                UserDefaults.standard.set(Date().timeIntervalSince1970, forKey: "scheduledTimer")
                                                                                UserDefaults.standard.synchronize()
                                                                }
                                                }
                                }
                                timer?.fire()
                                RunLoop.current.add(timer!, forMode: .common)
                }
}