react-native-firework-sdk 2.0.0 → 2.1.0

package/ios/Utils/AppLanguage/FWLanguageUtil.swift

@@ -0,0 +1,43 @@
+//
+//  FWLanguageUtil.swift
+//  
+//  Created by linjie jiang on 2023/2/9.
+//
+
+import Foundation
+
+public class FWLanguageUtil {
+    public static func getLanguageCode(_ language: String) -> String? {
+        guard language.count > 0 else {
+            return nil
+        }
+
+        var languageCode = ""
+        #if compiler(>=5.7)
+        if #available(iOS 16, *) {
+            languageCode = Locale(identifier: language).language.languageCode?.identifier ?? ""
+        } else {
+            languageCode = Locale(identifier: language).languageCode ?? ""
+        }
+        #else
+        languageCode = Locale(identifier: language).languageCode ?? ""
+        #endif
+        return languageCode.lowercased()
+    }
+
+    public static func isValidLanguage(_ language: String?) -> Bool {
+        guard let language = language else {
+            return false
+        }
+
+        guard language.count > 0 else {
+            return false
+        }
+
+        let languageWithUnderline = language.replacingOccurrences(of: "-", with: "_")
+
+        let availableIdentifiers = Locale.availableIdentifiers
+
+        return availableIdentifiers.contains(language) || availableIdentifiers.contains(languageWithUnderline)
+    }
+}

package/ios/Utils/AppLanguage/NumberFormatter+FWSwizzle.swift

@@ -0,0 +1,25 @@
+//
+//  NumberFormatter+FWSwizzle.swift
+//  
+//  Created by linjie jiang on 2023/2/20.
+//
+
+import Foundation
+
+public extension NumberFormatter {
+    static func swizzleMethodsForNumberFormatter() {
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(NumberFormatter.string(from:)),
+            customSelector: #selector(NumberFormatter.fw_string(from:)))
+    }
+
+    @objc func fw_string(from number: NSNumber) -> String? {
+        if let language = FWAppLanguageManager.shared.appLanguage,
+           self.numberStyle == .currency {
+            self.locale = Locale(identifier: language)
+        }
+
+        return fw_string(from: number)
+    }
+}

package/ios/Utils/AppLanguage/UIImageView+FWSwizzle.swift

@@ -0,0 +1,91 @@
+//
+//  UIImageView+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/2/22.
+//
+
+import UIKit
+import FireworkVideo
+
+private let FWImageNamesWithDirections: [String] = [
+    "shopping-cart",
+    "left-arrow",
+    "right-arrow",
+    "speaker-unmute",
+    "speaker-mute"
+]
+
+extension UIImageView {
+    static func swizzleMethodsForImageView() {
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIImageView.didMoveToWindow),
+            customSelector: #selector(UIImageView.fw_imageViewDidMoveToWindow))
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(setter: UIImageView.image),
+            customSelector: #selector(UIImageView.fw_setImage(_:))
+        )
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIImageView.awakeFromNib),
+            customSelector: #selector(UIImageView.fw_imageViewAwakeFromNib)
+        )
+    }
+
+    @objc func fw_imageViewDidMoveToWindow() {
+        fw_imageViewDidMoveToWindow()
+        updateViewType(self.image)
+    }
+
+    @objc func fw_setImage(_ image: UIImage?) {
+        fw_setImage(image)
+        updateViewType(image)
+    }
+
+    @objc func fw_imageViewAwakeFromNib() {
+        self.fw_imageViewAwakeFromNib()
+        updateViewType(self.image)
+    }
+
+    private func updateViewType(_ image: UIImage?) {
+        self.fwrtl_viewType = shouldFlipImage(image) ? FWRTLViewTypeFlip : FWRTLViewTypeAuto
+    }
+
+    private func shouldFlipImage(_ image: UIImage?) -> Bool {
+        guard let image = image else {
+            return false
+        }
+
+        if FWAppLanguageManager.shared.shouldHorizontalFlip, self.isIOSSDKView {
+            let iOSSDKBundle = Bundle(for: FireworkVideoSDK.self)
+
+            for imageName in FWImageNamesWithDirections {
+                let targetImage = UIImage(named: imageName, in: iOSSDKBundle, compatibleWith: nil)
+                if image.isEqual(targetImage) {
+                    return true
+                }
+
+                if let cgImage = image.cgImage,
+                   let targetCgImage = targetImage?.cgImage,
+                   cgImage == targetCgImage {
+                    return true
+                }
+
+                if let ciImage = image.ciImage,
+                   let targetCiImage = targetImage?.ciImage,
+                   ciImage == targetCiImage {
+                    return true
+                }
+            }
+        }
+
+        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+           image.flipsForRightToLeftLayoutDirection == true,
+           self.isIOSSDKView {
+            return true
+        }
+
+        return false
+    }
+}

package/ios/Utils/AppLanguage/UILabel+FWSwizzle.swift

@@ -0,0 +1,98 @@
+//
+//  UILabel+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/2/22.
+//
+
+import UIKit
+
+extension UILabel {
+    private struct AssociatedKeys {
+        static var fwHasCalculatedTextAlignment = "fwHasCalculatedTextAlignmentKey"
+    }
+
+    private var fwHasCalculatedTextAlignment: Bool {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.fwHasCalculatedTextAlignment) as? Bool
+            return result ?? false
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.fwHasCalculatedTextAlignment,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    static func swizzleMethodsForLabel() {
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                    originalSelector: #selector(setter: UILabel.textAlignment),
+                                    customSelector: #selector(UILabel.fw_setLabelTextAlignment(_:)))
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                    originalSelector: #selector(UILabel.didMoveToWindow),
+                                    customSelector: #selector(UILabel.fw_labelDidMoveToWindow))
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                      originalSelector: #selector(UILabel.removeFromSuperview),
+                                    customSelector: #selector(UILabel.fw_labelRemoveFromSuperview))
+    }
+
+    @objc func fw_setLabelTextAlignment(_ textAlignment: NSTextAlignment) {
+        self.fwrtl_addReloadBlock(forKey: "alignment") { [weak self] in
+            guard let self = self else {
+                return
+            }
+
+            self.fw_setLabelTextAlignment(self.calculatedTextAlignment(textAlignment))
+        }
+    }
+
+    @objc func fw_labelDidMoveToWindow() {
+        fw_labelDidMoveToWindow()
+        if shouldCalculateTextAlignment(),
+           !self.fwHasCalculatedTextAlignment,
+           self.isIOSSDKView {
+            self.textAlignment = self.textAlignment
+        }
+    }
+
+    @objc func fw_labelRemoveFromSuperview() {
+        fw_labelRemoveFromSuperview()
+        self.fwHasCalculatedTextAlignment = false
+    }
+
+    private func calculatedTextAlignment(_ textAlignment: NSTextAlignment) -> NSTextAlignment {
+        if shouldCalculateTextAlignment(),
+           let layoutDirection = FWAppLanguageManager.shared.appLanguageLayoutDirection {
+            self.fwHasCalculatedTextAlignment = true
+            if layoutDirection == .rtl {
+                if textAlignment == .center {
+                    return textAlignment
+                } else if textAlignment == .right {
+                    return .left
+                } else {
+                    return .right
+                }
+            } else if layoutDirection == .ltr {
+                return .left
+            }
+        } else {
+            return textAlignment
+        }
+        return textAlignment
+    }
+
+    private func shouldCalculateTextAlignment() -> Bool {
+        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+           self.isIOSSDKView,
+           let layoutDirection = FWAppLanguageManager.shared.appLanguageLayoutDirection,
+           layoutDirection != .unsupported,
+           fwrtl_shouldUseCalculatedTextAlignment() {
+            return true
+        }
+
+        return false
+    }
+}

package/ios/Utils/AppLanguage/UITextField+FWSwizzle.swift

@@ -0,0 +1,97 @@
+//
+//  UITextField+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/2/23.
+//
+
+import UIKit
+
+extension UITextField {
+    private struct AssociatedKeys {
+        static var fwHasCalculatedTextAlignment = "fwHasCalculatedTextAlignmentKey"
+    }
+
+    private var fwHasCalculatedTextAlignment: Bool {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.fwHasCalculatedTextAlignment) as? Bool
+            return result ?? false
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.fwHasCalculatedTextAlignment,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    static func swizzleMethodsForTextField() {
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                    originalSelector: #selector(setter: UITextField.textAlignment),
+                                    customSelector: #selector(UITextField.fw_setTextFieldTextAlignment(_:)))
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                    originalSelector: #selector(UITextField.didMoveToWindow),
+                                    customSelector: #selector(UITextField.fw_textFieldDidMoveToWindow))
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                      originalSelector: #selector(UITextField.removeFromSuperview),
+                                    customSelector: #selector(UITextField.fw_textFieldRemoveFromSuperview))
+    }
+
+    @objc func fw_setTextFieldTextAlignment(_ textAlignment: NSTextAlignment) {
+        self.fwrtl_addReloadBlock(forKey: "alignment") { [weak self] in
+            guard let self = self else {
+                return
+            }
+
+            self.fw_setTextFieldTextAlignment(self.calculatedTextAlignment(textAlignment))
+        }
+    }
+
+    @objc func fw_textFieldDidMoveToWindow() {
+        fw_textFieldDidMoveToWindow()
+        if shouldCalculateTextAlignment(),
+           !self.fwHasCalculatedTextAlignment,
+           self.isIOSSDKView {
+            self.textAlignment = self.textAlignment
+        }
+    }
+
+    @objc func fw_textFieldRemoveFromSuperview() {
+        fw_textFieldRemoveFromSuperview()
+        self.fwHasCalculatedTextAlignment = false
+    }
+
+    private func calculatedTextAlignment(_ textAlignment: NSTextAlignment) -> NSTextAlignment {
+        if shouldCalculateTextAlignment(),
+           let layoutDirection = FWAppLanguageManager.shared.appLanguageLayoutDirection {
+            self.fwHasCalculatedTextAlignment = true
+            if layoutDirection == .rtl {
+                if textAlignment == .center {
+                    return textAlignment
+                } else if textAlignment == .right {
+                    return .left
+                } else {
+                    return .right
+                }
+            } else if layoutDirection == .ltr {
+                return .left
+            }
+        } else {
+            return textAlignment
+        }
+        return textAlignment
+    }
+
+    private func shouldCalculateTextAlignment() -> Bool {
+        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+           self.isIOSSDKView,
+           let layoutDirection = FWAppLanguageManager.shared.appLanguageLayoutDirection,
+           layoutDirection != .unsupported {
+            return true
+        }
+
+        return false
+    }
+}

package/ios/Utils/AppLanguage/UITextView+FWSwizzle.swift

@@ -0,0 +1,97 @@
+//
+//  UITextView+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/2/23.
+//
+
+import UIKit
+
+extension UITextView {
+    private struct AssociatedKeys {
+        static var fwHasCalculatedTextAlignment = "fwHasCalculatedTextAlignmentKey"
+    }
+
+    private var fwHasCalculatedTextAlignment: Bool {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.fwHasCalculatedTextAlignment) as? Bool
+            return result ?? false
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.fwHasCalculatedTextAlignment,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    static func swizzleMethodsForTextView() {
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                    originalSelector: #selector(setter: UITextView.textAlignment),
+                                    customSelector: #selector(UITextView.fw_setTextViewTextAlignment(_:)))
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                    originalSelector: #selector(UITextView.didMoveToWindow),
+                                    customSelector: #selector(UITextView.fw_textViewDidMoveToWindow))
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                      originalSelector: #selector(UITextView.removeFromSuperview),
+                                    customSelector: #selector(UITextView.fw_textViewRemoveFromSuperview))
+    }
+
+    @objc func fw_setTextViewTextAlignment(_ textAlignment: NSTextAlignment) {
+        self.fwrtl_addReloadBlock(forKey: "alignment") { [weak self] in
+            guard let self = self else {
+                return
+            }
+
+            self.fw_setTextViewTextAlignment(self.calculatedTextAlignment(textAlignment))
+        }
+    }
+
+    @objc func fw_textViewDidMoveToWindow() {
+        fw_textViewDidMoveToWindow()
+        if shouldCalculateTextAlignment(),
+           !self.fwHasCalculatedTextAlignment,
+           self.isIOSSDKView {
+            self.textAlignment = self.textAlignment
+        }
+    }
+
+    @objc func fw_textViewRemoveFromSuperview() {
+        fw_textViewRemoveFromSuperview()
+        self.fwHasCalculatedTextAlignment = false
+    }
+
+    private func calculatedTextAlignment(_ textAlignment: NSTextAlignment) -> NSTextAlignment {
+        if shouldCalculateTextAlignment(),
+           let layoutDirection = FWAppLanguageManager.shared.appLanguageLayoutDirection {
+            self.fwHasCalculatedTextAlignment = true
+            if layoutDirection == .rtl {
+                if textAlignment == .center {
+                    return textAlignment
+                } else if textAlignment == .right {
+                    return .left
+                } else {
+                    return .right
+                }
+            } else if layoutDirection == .ltr {
+                return .left
+            }
+        } else {
+            return textAlignment
+        }
+        return textAlignment
+    }
+
+    private func shouldCalculateTextAlignment() -> Bool {
+        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+           self.isIOSSDKView,
+           let layoutDirection = FWAppLanguageManager.shared.appLanguageLayoutDirection,
+           layoutDirection != .unsupported {
+            return true
+        }
+
+        return false
+    }
+}

package/ios/Utils/AppLanguage/UIView+FWSwizzle.swift

@@ -0,0 +1,38 @@
+//
+//  UIView+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/3/11.
+//
+
+import UIKit
+import FireworkVideo
+
+extension UIView {
+    static func swizzleMethodsForView() {
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIView.init(frame:)),
+            customSelector: #selector(UIView.fw_init(frame:))
+        )
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIView.awakeFromNib),
+            customSelector: #selector(UIView.fw_viewAwakeFromNib)
+        )
+    }
+
+    @objc func fw_init(frame: CGRect) -> UIView {
+        let view = self.fw_init(frame: frame)
+        if view is FireworkPlayerView {
+            view.fwrtl_viewType = FWRTLViewTypeNormal
+        }
+        return view
+    }
+
+    @objc func fw_viewAwakeFromNib() {
+        self.fw_viewAwakeFromNib()
+        if self is FireworkPlayerView, FWAppLanguageManager.shared.shouldHorizontalFlip {
+            self.fwrtl_viewType = FWRTLViewTypeNormal
+        }
+    }
+}

package/ios/Utils/AppLanguage/UIViewController+FWSwizzle.swift

@@ -0,0 +1,32 @@
+//
+//  UIViewController+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/2/21.
+//
+
+import UIKit
+import FireworkVideo
+
+extension UIViewController {
+    static func swizzleMethodsForViewController() {
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIViewController.present(_:animated:completion:)),
+            customSelector: #selector(UIViewController.fw_present(_:animated:completion:))
+        )
+    }
+
+    @objc func fw_present(
+        _ viewControllerToPresent: UIViewController,
+        animated flag: Bool,
+        completion: (() -> Void)? = nil
+    ) {
+        let iOSSDKBundle = Bundle(for: FireworkVideoSDK.self)
+        let viewControllerToPresentBundle = Bundle(for: type(of: viewControllerToPresent))
+        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+           viewControllerToPresentBundle == iOSSDKBundle {
+            viewControllerToPresent.view.fwrtl_viewType = FWRTLViewTypeFlip
+        }
+        fw_present(viewControllerToPresent, animated: flag, completion: completion)
+    }
+}

package/ios/Utils/AppLanguage/UIWindow+FWSwizzle.swift

@@ -0,0 +1,26 @@
+//
+//  UIWindow+FWSwizzle.swift
+//
+//  Created by linjie jiang on 2023/2/24.
+//
+
+import UIKit
+import FireworkVideo
+
+extension UIWindow {
+    static func swizzleMethodsForWindow() {
+        FWSwizzleUtil.swizzleSelector(cls: self,
+                                      originalSelector: #selector(setter: UIWindow.rootViewController),
+                                      customSelector: #selector(UIWindow.fw_setRootViewController(_:)))
+    }
+
+    @objc func fw_setRootViewController(_ rootViewController: UIViewController?) {
+        fw_setRootViewController(rootViewController)
+        let iOSSDKBundle = Bundle(for: FireworkVideoSDK.self)
+        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+           let viewController = rootViewController,
+           Bundle(for: type(of: viewController)) == iOSSDKBundle {
+            viewController.view.fwrtl_viewType = FWRTLViewTypeFlip
+        }
+    }
+}

package/ios/Utils/AppLanguage/URLSession+FWSwizzle.swift

@@ -0,0 +1,69 @@
+//
+//  URLSession+FWSwizzle.swift
+//  
+//  Created by linjie jiang on 2023/2/20.
+//
+
+import Foundation
+
+private var FWHostList: [String] = [
+    "api.firework.tv",
+    "p2.fwpixel.com"
+]
+
+public extension URLSession {
+    static func swizzleMethodsForURLSession() {
+        // swiftlint:disable:next line_length
+        let orginalSelector1 = #selector(URLSession.dataTask(with:completionHandler:) as (URLSession) -> (URLRequest, @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask)
+        let customSelector1 = #selector(URLSession.fw_dataTask(with:completionHandler:))
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: orginalSelector1,
+            customSelector: customSelector1)
+        // swiftlint:disable:next line_length
+        let orginalSelector2 = #selector(URLSession.dataTask(with:) as (URLSession) -> (URLRequest) -> URLSessionDataTask)
+        let customSelector2 = #selector(URLSession.fw_dataTask(with:))
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: orginalSelector2,
+            customSelector: customSelector2)
+    }
+
+    @objc func fw_dataTask(
+        with request: URLRequest,
+        completionHandler: @escaping @Sendable (Data?, URLResponse?, Error?) -> Void
+    ) -> URLSessionDataTask {
+        return fw_dataTask(with: swizzleRequest(request), completionHandler: completionHandler)
+    }
+
+    @objc func fw_dataTask(with request: URLRequest) -> URLSessionDataTask {
+        return fw_dataTask(with: swizzleRequest(request))
+    }
+
+    private func swizzleRequest(_ request: URLRequest) -> URLRequest {
+        var host = ""
+        #if compiler(>=5.7)
+        if #available(iOS 16, *) {
+            host = request.url?.host() ?? ""
+        } else {
+            host = request.url?.host ?? ""
+        }
+        #else
+        host = request.url?.host ?? ""
+        #endif
+
+        if let language = FWAppLanguageManager.shared.appLanguage,
+           let languageCode = FWAppLanguageManager.shared.appLanguageCode,
+           FWHostList.contains(host) {
+            var mutableRequest = request
+            if language != languageCode {
+                mutableRequest.setValue("\(language),\(languageCode);q=0.9", forHTTPHeaderField: "Accept-Language")
+            } else {
+                mutableRequest.setValue("\(language);q=0.9", forHTTPHeaderField: "Accept-Language")
+            }
+            return mutableRequest
+        }
+
+        return request
+    }
+}

package/ios/Utils/{DispatchQueue+FWOnce.swift → Extensions/DispatchQueue+FWOnce.swift}

@@ -10,15 +10,15 @@ extension DispatchQueue {
     private static var _onceContainer = [String]()
 
     /// Execute a block only once.
-    public class func fw_once(
+    public class func once(
         file: String = #file, function: String = #function, line: Int = #line, block: () -> Void
     ) {
         let token = file + ":" + function + ":" + String(line)
-        fw_once(token: token, block: block)
+        once(token: token, block: block)
     }
 
     /// Execute a block only once.
-    public class func fw_once(token: String, block: () -> Void) {
+    public class func once(token: String, block: () -> Void) {
         objc_sync_enter(self)
         defer { objc_sync_exit(self) }
 

package/ios/Utils/{UINavigationController+FWSwizzle.swift → Extensions/Swizzle/UINavigationController+FWSwizzle.swift}

@@ -7,14 +7,12 @@
 import UIKit
 
 extension UINavigationController {
-    @objc public static func fw_swizzleMethods() {
-        DispatchQueue.fw_once {
-            FWSwizzleUtil.swizzleSelector(
-                cls: self,
-                orginalSelector: #selector(pushViewController(_:animated:)),
-                customSelector: #selector(fw_pushViewController(_:animated:))
-            )
-        }
+    static func swizzleMethodsForNavigationController() {
+        FWSwizzleUtil.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UINavigationController.pushViewController(_:animated:)),
+            customSelector: #selector(UINavigationController.fw_pushViewController(_:animated:))
+        )
     }
 
     @objc func fw_pushViewController(