react-native-firework-sdk 2.1.0 → 2.2.0

package/ios/{Utils/AppLanguage/UIViewController+FWSwizzle.swift → FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/Extensions/UIKit/UIViewController+AppLanguage.swift}

@@ -1,5 +1,5 @@
 //
-//  UIViewController+FWSwizzle.swift
+//  UIViewController+AppLanguage.swift
 //
 //  Created by linjie jiang on 2023/2/21.
 //
@@ -8,12 +8,18 @@ import UIKit
 import FireworkVideo
 
 extension UIViewController {
-    static func swizzleMethodsForViewController() {
-        FWSwizzleUtil.swizzleSelector(
+    static func swizzleViewControllerMethodsForAppLanguage() {
+        Swizzle.swizzleSelector(
             cls: self,
             originalSelector: #selector(UIViewController.present(_:animated:completion:)),
             customSelector: #selector(UIViewController.fw_present(_:animated:completion:))
         )
+
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIViewController.viewDidLoad),
+            customSelector: #selector(UIViewController.fw_viewDidLoad)
+        )
     }
 
     @objc func fw_present(
@@ -23,10 +29,18 @@ extension UIViewController {
     ) {
         let iOSSDKBundle = Bundle(for: FireworkVideoSDK.self)
         let viewControllerToPresentBundle = Bundle(for: type(of: viewControllerToPresent))
-        if FWAppLanguageManager.shared.shouldHorizontalFlip,
+        if AppLanguageManager.shared.shouldHorizontalFlip,
            viewControllerToPresentBundle == iOSSDKBundle {
-            viewControllerToPresent.view.fwrtl_viewType = FWRTLViewTypeFlip
+            viewControllerToPresent.view.viewType = .flip
         }
         fw_present(viewControllerToPresent, animated: flag, completion: completion)
     }
+
+    @objc func fw_viewDidLoad() {
+        fw_viewDidLoad()
+        if self is StoryBlockViewController
+            || self is VideoFeedViewController {
+            self.view.viewType = .flip
+        }
+    }
 }

package/ios/{Utils/AppLanguage/UIWindow+FWSwizzle.swift → FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/Extensions/UIKit/UIWindow+AppLanguage.swift}

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

package/ios/{Utils/AppLanguage/FWLanguageUtil.swift → FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/LanguageUtil.swift}

@@ -1,13 +1,13 @@
 //
-//  FWLanguageUtil.swift
+//  LanguageUtil.swift
 //  
 //  Created by linjie jiang on 2023/2/9.
 //
 
 import Foundation
 
-public class FWLanguageUtil {
-    public static func getLanguageCode(_ language: String) -> String? {
+class LanguageUtil {
+   static func getLanguageCode(_ language: String) -> String? {
         guard language.count > 0 else {
             return nil
         }
@@ -25,7 +25,7 @@ public class FWLanguageUtil {
         return languageCode.lowercased()
     }
 
-    public static func isValidLanguage(_ language: String?) -> Bool {
+    static func isValidLanguage(_ language: String?) -> Bool {
         guard let language = language else {
             return false
         }

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/LayoutFlip/Extensions/Foundation/NSObject+LayoutFlip.swift

@@ -0,0 +1,42 @@
+//
+//  NSObject+LayoutFlip.swift
+//
+//  Created by linjie jiang on 4/25/23.
+//
+
+import Foundation
+
+typealias ReloadClosure = () -> Void
+
+extension NSObject {
+    private struct AssociatedKeys {
+        static var reloadClosures = "reloadBlocks"
+    }
+
+    private var reloadClosures: [String: ReloadClosure] {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.reloadClosures) as? [String: ReloadClosure]
+            return result ?? [:]
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.reloadClosures,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    func performReload() {
+        for (_, closure) in reloadClosures {
+            closure()
+        }
+    }
+
+    func addReloadClosure(key: String, reloadClosure: @escaping ReloadClosure) {
+        reloadClosures[key] = reloadClosure
+        reloadClosure()
+    }
+}

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/LayoutFlip/Extensions/UIKit/CALayer+LayoutFlip.swift

@@ -0,0 +1,160 @@
+//
+//  CALayer+LayoutFlip.swift
+//
+//  Created by linjie jiang on 4/25/23.
+//
+
+import UIKit
+
+private var gHasEnabledHorizontalFlip = false
+
+extension CALayer {
+    private struct AssociatedKeys {
+        static var basicTransform = "basicTransform"
+        static var isRenderStartLayer = "isRenderStartLayer"
+        static var affineTransform = "affineTransform"
+    }
+
+    static func swizzleLayerMethodsForLayoutFlip() {
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(CALayer.setAffineTransform(_:)),
+            customSelector: #selector(CALayer.fw_setAffineTransform(_:)))
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(CALayer.affineTransform),
+            customSelector: #selector(CALayer.fw_affineTransform))
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(CALayer.add(_:forKey:)),
+            customSelector: #selector(CALayer.fw_add(_:forKey:)))
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(CALayer.render(in:)),
+            customSelector: #selector(CALayer.fw_render(in:)))
+    }
+
+    var basicTransform: CGAffineTransform {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.basicTransform) as? NSValue
+
+            return result?.cgAffineTransformValue ?? CGAffineTransformIdentity
+        }
+
+        set {
+            if objc_getAssociatedObject(self, &AssociatedKeys.basicTransform) == nil,
+               CGAffineTransformIsIdentity(newValue) {
+                return
+            }
+
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.basicTransform,
+                NSValue(cgAffineTransform: newValue),
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            self.setAffineTransform(self.affineTransform())
+        }
+    }
+
+    var isRenderStartLayer: Bool {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.isRenderStartLayer) as? Bool
+            return result ?? false
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.basicTransform,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    @objc func fw_setAffineTransform(_ affineTransform: CGAffineTransform) {
+        if !gHasEnabledHorizontalFlip && LayoutFlipManager.shared.enableHorizontalFlip {
+            gHasEnabledHorizontalFlip = true
+        }
+
+        if gHasEnabledHorizontalFlip {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.affineTransform,
+                NSValue(cgAffineTransform: affineTransform),
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            fw_setAffineTransform(CGAffineTransformConcat(basicTransform, affineTransform))
+        } else {
+            fw_setAffineTransform(affineTransform)
+        }
+    }
+
+    @objc func fw_affineTransform() -> CGAffineTransform {
+        if !gHasEnabledHorizontalFlip && LayoutFlipManager.shared.enableHorizontalFlip {
+            gHasEnabledHorizontalFlip = true
+        }
+
+        if gHasEnabledHorizontalFlip {
+            if let value = objc_getAssociatedObject(self, &AssociatedKeys.affineTransform) as? NSValue {
+                return value.cgAffineTransformValue
+            }
+            return fw_affineTransform()
+        } else {
+            return fw_affineTransform()
+        }
+    }
+
+    @objc func fw_add(_ anim: CAAnimation, forKey key: String?) {
+        if let basicAnim = anim as? CABasicAnimation,
+           let keyPath = basicAnim.keyPath,
+           keyPath.starts(with: "transform.scale"),
+           self.basicTransform.a == -1,
+           let fromValue = basicAnim.fromValue as? Double,
+           let toValue = basicAnim.toValue as? Double {
+            basicAnim.fromValue = fromValue * -1
+            basicAnim.toValue = toValue * -1
+        }
+
+        fw_add(anim, forKey: key)
+    }
+
+    @objc func fw_render(in ctx: CGContext) {
+        if !gHasEnabledHorizontalFlip && LayoutFlipManager.shared.enableHorizontalFlip {
+            gHasEnabledHorizontalFlip = true
+        }
+
+        if gHasEnabledHorizontalFlip {
+            var isRenderStartLayer = true
+            var allSuperLayerTransform = basicTransform
+            var layer = self
+            while let superlayer = layer.superlayer {
+                layer = superlayer
+                if layer.isRenderStartLayer {
+                    isRenderStartLayer = false
+                    break
+                }
+                allSuperLayerTransform = CGAffineTransformConcat(layer.basicTransform, allSuperLayerTransform)
+            }
+
+            if isRenderStartLayer {
+                self.isRenderStartLayer = true
+                if allSuperLayerTransform.a == -1 {
+                    ctx.saveGState()
+                    ctx.concatenate(CGAffineTransformMakeScale(-1, 1))
+                    ctx.translateBy(x: -self.bounds.size.width, y: 0)
+                }
+            }
+            fw_render(in: ctx)
+            if isRenderStartLayer {
+                self.isRenderStartLayer = false
+                if allSuperLayerTransform.a == -1 {
+                    ctx.restoreGState()
+                }
+            }
+        } else {
+            fw_render(in: ctx)
+        }
+    }
+}

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/LayoutFlip/Extensions/UIKit/UILabel+LayoutFlip.swift

@@ -0,0 +1,35 @@
+//
+//  UILabel+LayoutFlip.swift
+//
+//  Created by linjie jiang on 4/25/23.
+//
+
+import UIKit
+
+private let gNoUseClasses: [String] = [
+    "VUlUZXh0RmllbGRMYWJlbA==".decodeBase64String() // UITextFieldLabel
+]
+private let gSuperviewNoUseClasses: [String] = [
+    "VUlEYXRlUGlja2VyQ29udGVudFZpZXc=".decodeBase64String() // UIDatePickerContentView
+]
+
+extension UILabel {
+    func shouldUseCalculatedTextAlignment() -> Bool {
+        for className in gNoUseClasses {
+            if let cls = NSClassFromString(className),
+               self.isKind(of: cls) {
+                return false
+            }
+        }
+
+        for className in gSuperviewNoUseClasses {
+            if let cls = NSClassFromString(className),
+               let superview = superview,
+               superview.isKind(of: cls) {
+                return false
+            }
+        }
+
+        return true
+    }
+}

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/LayoutFlip/Extensions/UIKit/UIView+LayoutFlip.swift

@@ -0,0 +1,199 @@
+//
+//  UIView+LayoutFlip.swift
+//
+//  Created by linjie jiang on 4/25/23.
+//
+
+import UIKit
+import WebKit
+
+private let gNoFlipClasses: [Any] = [
+    UILabel.self,
+    UITextView.self,
+    UITextField.self,
+    WKWebView.self,
+    UIImageView.self,
+    UISearchBar.self,
+    "PUPhotosSectionHeaderContentView",
+    "UITableViewIndex",
+    "UIWebView",
+    "X1VJUmVtb3RlVmlldw==".decodeBase64String(), // _UIRemoteView
+    "VUlBdXRvY29ycmVjdFRleHRWaWV3".decodeBase64String() // UIAutocorrectTextView
+]
+
+enum LayoutFlipViewType: Int {
+    case auto
+    case inherit
+    case normal
+    case flip
+    case normalWithAllDescendants
+    case flipWithAllDescendants
+}
+
+extension UIView {
+    private struct AssociatedKeys {
+        static var viewType = "viewType"
+        static var calculatedViewType = "calculatedViewType"
+        static var lastType = "lastType"
+    }
+
+    static func swizzleViewMethodsForLayoutFlip() {
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIView.didMoveToSuperview),
+            customSelector: #selector(UIView.fw_didMoveToSuperview))
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIView.didMoveToWindow),
+            customSelector: #selector(UIView.fw_didMoveToWindow))
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIView.snapshotView(afterScreenUpdates:)),
+            customSelector: #selector(UIView.fw_snapshotView(afterScreenUpdates:)))
+    }
+
+    var viewType: LayoutFlipViewType {
+        get {
+            let rawValue = objc_getAssociatedObject(self, &AssociatedKeys.viewType) as? Int ?? 0
+            let type = LayoutFlipViewType(rawValue: rawValue) ?? .auto
+
+            return type
+        }
+
+        set {
+            if viewType == newValue {
+                return
+            }
+
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.viewType,
+                newValue.rawValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            renewLayerTransformForceRecursively(false)
+        }
+    }
+
+    private(set) var calculatedViewType: LayoutFlipViewType {
+        get {
+            let rawValue = objc_getAssociatedObject(self, &AssociatedKeys.calculatedViewType) as? Int ?? 0
+            var type = LayoutFlipViewType(rawValue: rawValue) ?? .auto
+            if type == .auto {
+                if self.window != nil {
+                    updateCalculatedViewType()
+                    let newRawValue = objc_getAssociatedObject(self, &AssociatedKeys.calculatedViewType) as? Int ?? 0
+                    type = LayoutFlipViewType(rawValue: newRawValue) ?? .auto
+                } else {
+                    type = .normal
+                }
+            }
+
+            return type
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.calculatedViewType,
+                newValue.rawValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    private var lastType: LayoutFlipViewType {
+        get {
+            let rawValue = objc_getAssociatedObject(self, &AssociatedKeys.lastType) as? Int ?? 0
+            let type = LayoutFlipViewType(rawValue: rawValue) ?? .auto
+
+            return type
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.lastType,
+                newValue.rawValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    @objc func fw_didMoveToSuperview() {
+        fw_didMoveToSuperview()
+        renewLayerTransformForceRecursively(false)
+    }
+
+    @objc func fw_didMoveToWindow() {
+        fw_didMoveToWindow()
+        renewLayerTransformForceRecursively(false)
+        LayoutFlipManager.shared.registerUIElement(self)
+    }
+
+    @objc func fw_snapshotView(afterScreenUpdates afterUpdates: Bool) -> UIView? {
+        let view = fw_snapshotView(afterScreenUpdates: afterUpdates)
+        view?.viewType = calculatedViewType
+        return view
+    }
+
+    func renewLayerTransformForceRecursively(_ forceRecursively: Bool) {
+        updateCalculatedViewType()
+        let updatedViewType = calculatedViewType
+        let superViewCalculatedViewType = superview?.calculatedViewType ?? .auto
+        let shouldFlipCurrentView = updatedViewType == .flip || updatedViewType == .flipWithAllDescendants
+        let shouldFlipSuperview = superViewCalculatedViewType == .flip
+                                  || superViewCalculatedViewType == .flipWithAllDescendants
+
+        let shouldSetFlipTransform = shouldFlipSuperview != shouldFlipCurrentView
+
+        if shouldSetFlipTransform && LayoutFlipManager.shared.enableHorizontalFlip {
+            layer.basicTransform = CGAffineTransformMakeScale(-1, 1)
+        } else {
+            layer.basicTransform = CGAffineTransformIdentity
+        }
+
+        if updatedViewType != lastType || forceRecursively {
+            for subView in subviews {
+                subView.renewLayerTransformForceRecursively(forceRecursively)
+            }
+        }
+
+        lastType = updatedViewType
+    }
+
+    private func automaticViewType() -> LayoutFlipViewType {
+        if self is UIWindow {
+            return .normal
+        }
+
+        for element in gNoFlipClasses {
+            if let cls = element as? AnyClass,
+               self.isKind(of: cls) {
+                return .normal
+
+            } else if let className = element as? String,
+                      let cls = NSClassFromString(className),
+                      self.isKind(of: cls) {
+                return .normal
+            }
+        }
+
+        return superview != nil ? .inherit : .normal
+    }
+
+    private func updateCalculatedViewType() {
+        var resultCalculatedViewType = viewType
+        if resultCalculatedViewType == .auto {
+            resultCalculatedViewType = automaticViewType()
+        }
+        let superViewCalculatedViewType = superview?.calculatedViewType ?? .auto
+        if superViewCalculatedViewType == .flipWithAllDescendants
+            || superViewCalculatedViewType == .normalWithAllDescendants
+            || resultCalculatedViewType == .inherit {
+            calculatedViewType = superViewCalculatedViewType
+        } else {
+            calculatedViewType = resultCalculatedViewType
+        }
+    }
+}

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/LayoutFlip/LayoutFlipManager.swift

@@ -0,0 +1,59 @@
+//
+//  LayoutFlipManager.swift
+//
+//  Created by linjie jiang on 4/25/23.
+//
+
+import UIKit
+
+class LayoutFlipManager {
+    static let shared = LayoutFlipManager()
+
+    static func swizzelMethods() {
+        DispatchQueue.once {
+            UIView.swizzleViewMethodsForLayoutFlip()
+            CALayer.swizzleLayerMethodsForLayoutFlip()
+        }
+    }
+
+    var enableHorizontalFlip: Bool = false {
+        didSet {
+            if enableHorizontalFlip == oldValue {
+                return
+            }
+
+            var rootViews: Set<UIView> = Set()
+            for element in registeredUIElements.allObjects {
+                element.performReload()
+
+                if element.window != nil && element.window != element {
+                    continue
+                }
+                rootViews.insert(rootViewForView(element))
+            }
+
+            for rootView in rootViews {
+                rootView.renewLayerTransformForceRecursively(true)
+            }
+        }
+    }
+
+    private var registeredUIElements: NSHashTable<UIView> = NSHashTable.weakObjects()
+
+    func registerUIElement(_ element: UIView) {
+        self.registeredUIElements.add(element)
+    }
+
+    private func rootViewForView(_ view: UIView) -> UIView {
+        if let window = view.window {
+            return window
+        }
+
+        var rootView: UIView = view
+        while let superview = rootView.superview {
+            rootView = superview
+        }
+
+        return rootView
+    }
+}

package/ios/{Utils/Extensions/DispatchQueue+FWOnce.swift → FireworkVideoUI/FireworkVideoUI/Sources/Utils/Extensions/Foundation/DispatchQueue+Once.swift}

@@ -1,16 +1,16 @@
 //
-//  DispatchQueue+FWOnce.swift
+//  DispatchQueue+Once.swift
 //
 //  Created by Jeff Zheng on 2022/3/1.
 //
 
 import Foundation
 
-extension DispatchQueue {
+public extension DispatchQueue {
     private static var _onceContainer = [String]()
 
     /// Execute a block only once.
-    public class func once(
+    class func once(
         file: String = #file, function: String = #function, line: Int = #line, block: () -> Void
     ) {
         let token = file + ":" + function + ":" + String(line)
@@ -18,7 +18,7 @@ extension DispatchQueue {
     }
 
     /// Execute a block only once.
-    public class func once(token: String, block: () -> Void) {
+    class func once(token: String, block: () -> Void) {
         objc_sync_enter(self)
         defer { objc_sync_exit(self) }
 

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/Utils/Extensions/Foundation/String+Base64.swift

@@ -0,0 +1,18 @@
+//
+//  String+Base64.swift
+//
+//  Created by linjie jiang on 4/25/23.
+//
+
+import Foundation
+
+extension String {
+    func decodeBase64String() -> String {
+        if let decodedData = Data(base64Encoded: self),
+           let decodedString = String(data: decodedData, encoding: .utf8) {
+            return decodedString
+        }
+
+        return ""
+    }
+}

package/ios/{Utils/Extensions/UIView+FWUIHierarchy.swift → FireworkVideoUI/FireworkVideoUI/Sources/Utils/Extensions/UIKit/UIView+UIHierarchy.swift}

@@ -1,6 +1,5 @@
 //
-//  View+ParentViewController.swift
-//  react-native-firework-sdk
+//  UIView+UIHierarchy.swift
 //
 //  Created by Jeff Zheng on 2021/12/22.
 //
@@ -8,8 +7,8 @@
 import UIKit
 import FireworkVideo
 
-extension UIView {
-    var fwParentViewController: UIViewController? {
+public extension UIView {
+    var parentViewController: UIViewController? {
         var parentResponder: UIResponder? = self
         while parentResponder != nil {
             parentResponder = parentResponder!.next
@@ -25,7 +24,7 @@ extension UIView {
         guard self.window != nil else {
             return false
         }
-        guard let parentVC = self.fwParentViewController else {
+        guard let parentVC = self.parentViewController else {
             return false
         }
         let iOSSDKBundle = Bundle(for: FireworkVideoSDK.self)

package/ios/{Utils/FWSwizzleUtil.swift → FireworkVideoUI/FireworkVideoUI/Sources/Utils/Swizzle.swift}

@@ -1,12 +1,12 @@
 //
-//  FWSwizzleUtil.swift
+//  Swizzle.swift
 //  
 //  Created by linjie jiang on 2023/2/7.
 //
 
 import Foundation
 
-public class FWSwizzleUtil {
+public class Swizzle {
     public static func swizzleSelector(cls: AnyClass, originalSelector: Selector, customSelector: Selector) {
         guard let originalMethod = class_getInstanceMethod(cls, originalSelector) else { return }
         guard let customMethod = class_getInstanceMethod(cls, customSelector) else { return }