react-native-firework-sdk 2.0.0 → 2.2.0-beta.1

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/Extensions/UIKit/UITextView+AppLanguage.swift

@@ -0,0 +1,97 @@
+//
+//  UITextView+AppLanguage.swift
+//
+//  Created by linjie jiang on 2023/2/23.
+//
+
+import UIKit
+
+extension UITextView {
+    private struct AssociatedKeys {
+        static var hasCalculatedTextAlignment = "hasCalculatedTextAlignmentKey"
+    }
+
+    private var hasCalculatedTextAlignment: Bool {
+        get {
+            let result = objc_getAssociatedObject(self, &AssociatedKeys.hasCalculatedTextAlignment) as? Bool
+            return result ?? false
+        }
+
+        set {
+            objc_setAssociatedObject(
+                self,
+                &AssociatedKeys.hasCalculatedTextAlignment,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    static func swizzleTextViewMethodsForAppLanguage() {
+        Swizzle.swizzleSelector(cls: self,
+                                    originalSelector: #selector(setter: UITextView.textAlignment),
+                                    customSelector: #selector(UITextView.fw_setTextViewTextAlignment(_:)))
+        Swizzle.swizzleSelector(cls: self,
+                                    originalSelector: #selector(UITextView.didMoveToWindow),
+                                    customSelector: #selector(UITextView.fw_textViewDidMoveToWindow))
+        Swizzle.swizzleSelector(cls: self,
+                                      originalSelector: #selector(UITextView.removeFromSuperview),
+                                    customSelector: #selector(UITextView.fw_textViewRemoveFromSuperview))
+    }
+
+    @objc func fw_setTextViewTextAlignment(_ textAlignment: NSTextAlignment) {
+        addReloadClosure(key: "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.hasCalculatedTextAlignment,
+           self.isIOSSDKView {
+            self.textAlignment = self.textAlignment
+        }
+    }
+
+    @objc func fw_textViewRemoveFromSuperview() {
+        fw_textViewRemoveFromSuperview()
+        self.hasCalculatedTextAlignment = false
+    }
+
+    private func calculatedTextAlignment(_ textAlignment: NSTextAlignment) -> NSTextAlignment {
+        if shouldCalculateTextAlignment(),
+           let layoutDirection = AppLanguageManager.shared.appLanguageLayoutDirection {
+            self.hasCalculatedTextAlignment = 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 AppLanguageManager.shared.shouldHorizontalFlip,
+           self.isIOSSDKView,
+           let layoutDirection = AppLanguageManager.shared.appLanguageLayoutDirection,
+           layoutDirection != .unsupported {
+            return true
+        }
+
+        return false
+    }
+}

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

@@ -0,0 +1,38 @@
+//
+//  UIView+AppLanguage.swift
+//
+//  Created by linjie jiang on 2023/3/11.
+//
+
+import UIKit
+import FireworkVideo
+
+extension UIView {
+    static func swizzleViewMethodsForAppLanguage() {
+        Swizzle.swizzleSelector(
+            cls: self,
+            originalSelector: #selector(UIView.init(frame:)),
+            customSelector: #selector(UIView.fw_init(frame:))
+        )
+        Swizzle.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.viewType = .normal
+        }
+        return view
+    }
+
+    @objc func fw_viewAwakeFromNib() {
+        self.fw_viewAwakeFromNib()
+        if self is FireworkPlayerView, AppLanguageManager.shared.shouldHorizontalFlip {
+            self.viewType = .normal
+        }
+    }
+}

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/Extensions/UIKit/UIViewController+AppLanguage.swift

@@ -0,0 +1,46 @@
+//
+//  UIViewController+AppLanguage.swift
+//
+//  Created by linjie jiang on 2023/2/21.
+//
+
+import UIKit
+import FireworkVideo
+
+extension UIViewController {
+    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(
+        _ viewControllerToPresent: UIViewController,
+        animated flag: Bool,
+        completion: (() -> Void)? = nil
+    ) {
+        let iOSSDKBundle = Bundle(for: FireworkVideoSDK.self)
+        let viewControllerToPresentBundle = Bundle(for: type(of: viewControllerToPresent))
+        if AppLanguageManager.shared.shouldHorizontalFlip,
+           viewControllerToPresentBundle == iOSSDKBundle {
+            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/FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/Extensions/UIKit/UIWindow+AppLanguage.swift

@@ -0,0 +1,26 @@
+//
+//  UIWindow+AppLanguage.swift
+//
+//  Created by linjie jiang on 2023/2/24.
+//
+
+import UIKit
+import FireworkVideo
+
+extension UIWindow {
+    static func swizzleWindowMethodsForAppLanguage() {
+        Swizzle.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 AppLanguageManager.shared.shouldHorizontalFlip,
+           let viewController = rootViewController,
+           Bundle(for: type(of: viewController)) == iOSSDKBundle {
+            viewController.view.viewType = .flip
+        }
+    }
+}

package/ios/FireworkVideoUI/FireworkVideoUI/Sources/AppLanguage/LanguageUtil.swift

@@ -0,0 +1,43 @@
+//
+//  LanguageUtil.swift
+//  
+//  Created by linjie jiang on 2023/2/9.
+//
+
+import Foundation
+
+class LanguageUtil {
+   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()
+    }
+
+    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/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
+        }
+    }
+}