@rentlydev/rently-tuya 0.1.0

package/ios/tuya/Tuya.swift

@@ -0,0 +1,570 @@
+import Foundation
+import SwiftUI
+import ThingSmartCameraBase
+import ThingSmartDeviceKit
+import ThingSmartCameraKit
+// ThingSmartDeviceDelegate - For firmware upgrade
+
+class Tuya: NSObject, ObservableObject {
+    
+    static let shared = Tuya()
+    
+    private override init() {}
+    
+    var device: ThingSmartDevice!
+    var dpManager: ThingSmartCameraDPManager?
+    var cameraType: ThingSmartCameraType?
+    var messages: ThingSmartCameraMessage?
+    
+    @Published var isConnected: Bool = false
+    @Published var isPreviewing: Bool = false
+    @Published var isMicOn: Bool = false
+    @Published var isMuted: Bool = true
+    @Published var isHD: Bool = true
+    @Published var isScreenshotSuccess = false
+    @Published var isRecording = false
+    @Published var isRecordingSuccess = false
+    @Published var isRecordingFailure = false
+
+    @Published var isAosu: Bool = false
+    @Published var is8s: Bool = false
+
+    // Settings
+    @Published var isWaterMarkEnabled: Bool = false
+    @Published var isFlipEnabled: Bool = false
+    @Published var isAntiDismantlingAlarmEnabled: Bool = false
+    @Published var nightVisionLevel: String = ThingSmartCameraNightvision.auto.rawValue
+    @Published var isMotionDetectionEnabled: Bool = false
+    @Published var motionSensitivityLevel: String = ThingSmartCameraMotion.medium.rawValue
+    @Published var isPIRDetectionEnabled: Bool = false
+    @Published var pirSensitivityLevel: Int = 3
+    @Published var basicPIRSensitivityLevel: String = ThingSmartCameraPIR.stateMedium.rawValue
+    @Published var sdCardStatus: Int = 1
+    @Published var isSDCardStorageEnabled: Bool = false
+    @Published var sdCardRecordingType: String = ThingSmartCameraRecordMode.event.rawValue
+    @Published var remainingBattery: Int? = nil
+    @Published var powerMode: String? = nil
+    @Published var chimeType: String = "0"
+    @Published var totalCapacity = 0.0
+    @Published var remainingCapacity = 0.0
+    @Published var used = 0.0
+    @Published var firwareVersion: String? = nil
+    
+    // Playback
+    @Published var recordDays: [Int]? = nil
+    @Published var playbackVideoList: [[AnyHashable : Any]]? = nil
+    @Published var selectedItem: [AnyHashable: Any]? = nil
+    @Published var isPlaybacking: Bool = false
+    @Published var isPaused: Bool = false
+    @Published var isPlaybackMuted: Bool = true
+    
+    // Loaders
+    @Published var previewLoader: Bool = true
+    @Published var dashboardLoader: Bool = false
+    @Published var playbackLoader: Bool = false
+    @Published var datePickerLoader: Bool = false
+    @Published var messagesLoader: Bool = false
+    @Published var settingsLoader: Bool = false
+    
+    // Smart Home Values
+    var lastMoveoutAt: String? = nil
+    var resetRequired: Bool? = nil
+    var isResident: Bool = true
+    var displayRemoveDoorbellButton: Bool? = nil
+    var tuyaProductName: String? = nil
+    var tuyaProductID: String? = nil
+    var uuid: String? = nil
+    var serialNumber: String? = nil
+    var id: String? = nil
+    var flavour: String = "smarthome"
+    
+    // Default Settings values
+    var isDefaultSettingsUpdated: Bool = false
+    var motionDetection: Bool = false
+    var continuousRecording: Bool = false
+    var eventRecording: Bool = false
+    var setSensitivityLow: Bool = false
+    
+    // Login and Set Device
+    func loginAndSetDevice(
+        deviceId: String,
+        propertyUid: String,
+        propertyPassword: String,
+        countryCode: String,
+        homeId: String,
+        completion: @escaping (Bool, String?, Error?) -> Void
+    ) {
+        guard !deviceId.isEmpty, !propertyUid.isEmpty, !propertyPassword.isEmpty, !homeId.isEmpty else {
+            print("Tuya: Missing required parameters.")
+            completion(false, "invalid_params", nil)
+            return
+        }
+        
+        ThingSmartUser.sharedInstance().loginOrRegister(
+            withCountryCode: countryCode,
+            uid: propertyUid,
+            password: propertyPassword,
+            createHome: false
+        ) { result in
+            
+            print("Tuya: Successfully logged in user.")
+            guard let homeIdLong = Int64(homeId) else {
+                print("Tuya: Failed to convert homeId to Int64.")
+                completion(false, "invalid_homeId", nil)
+                return
+            }
+            
+            self.syncDevice(
+                deviceId: deviceId,
+                homeId: homeIdLong,
+                completion: completion
+            )
+        } failure: { error in
+            print("Tuya: Login failed. Error: \(String(describing: error?.localizedDescription ?? "An Unknown error occured in login"))")
+            completion(false, error?.localizedDescription, error)
+        }
+    }
+    
+    // Sync Device Info
+    private func syncDevice(
+        deviceId: String,
+        homeId: Int64,
+        completion: @escaping (Bool, String?, Error?) -> Void
+    ) {
+        ThingSmartDevice.syncDeviceInfo(withDevId: deviceId, homeId: homeId) {
+            
+            print("Tuya: Device sync successful.")
+            self.device = ThingSmartDevice(deviceId: deviceId)
+            self.dpManager = ThingSmartCameraDPManager(deviceId: deviceId)
+            self.dpManager?.addObserver(SettingsManager.shared)
+            self.messages = ThingSmartCameraMessage(deviceId: deviceId, timeZone: TimeZone.current)
+
+            // Wake device - Battery powered devices will go to sleep state after some time, so connection may not happen.
+            if self.device != nil {
+                self.device.awake {
+                    print("Tuya: Device wake success")
+                } failure: { error in
+                    print("Tuya: Wake device failure \(String(describing: error?.localizedDescription))")
+                }
+            }
+            
+            completion(true, nil, nil)
+        } failure: { error in
+            print("Tuya: Device sync failed. Error: \(String(describing: error?.localizedDescription ?? "Unknown error"))")
+            completion(false, error?.localizedDescription, error)
+        }
+    }
+    
+    // Connect camera
+    func connect() {
+        guard let device = self.device else {
+            print("Tuya: Device not initialized")
+            self.updateStatus(isConnected: false, previewLoader: false)
+            return
+        }
+        
+        guard let p2pType = device.deviceModel.skills["p2pType"] else {
+            print("Tuya: Missing p2pType")
+            self.updateStatus(isConnected: false, previewLoader: false)
+            return
+        }
+        
+        previewLoader = true
+        
+        device.awake {
+            print("Tuya: Device wake success")
+        } failure: { error in
+            print("Tuya: Wake device failure \(String(describing: error?.localizedDescription))")
+        }
+        
+        let request = ThingSmartRequest()
+        request.request(withApiName: "tuya.m.ipc.config.get", postData: ["devId": device.devId], version: "2.0") { result in
+            guard let configData = result else {
+                print("Tuya: Config data missing")
+                self.updateStatus(isConnected: false, previewLoader: false)
+                return
+            }
+            
+            self.configureCamera(
+                p2pType: p2pType,
+                configData: configData
+            )
+        } failure: { error in
+            print("Tuya: API error: \(String(describing: error?.localizedDescription))")
+            self.updateStatus(isConnected: false, previewLoader: false)
+        }
+    }
+    
+    // Configure the camera
+    private func configureCamera(p2pType: Any, configData: Any) {
+        guard let config = ThingSmartCameraFactory.ipcConfig(
+            withUid: ThingSmartUser.sharedInstance().uid,
+            localKey: device.deviceModel.localKey,
+            configData: configData as? [AnyHashable: Any]
+        ) else {
+            print("Tuya: Camera config creation failed")
+            self.updateStatus(isConnected: false, previewLoader: false)
+            return
+        }
+        
+        self.cameraType = ThingSmartCameraFactory.camera(
+            withP2PType: p2pType,
+            config: config,
+            delegate: CameraManager.shared
+        )
+        
+        guard let cameraType = cameraType else {
+            print("Tuya: CameraType initialization failed")
+            self.updateStatus(isConnected: false, previewLoader: false)
+            return
+        }
+        
+        print("Tuya: Connecting Doorbell...")
+        cameraType.connect?(with: .auto)
+    }
+    
+    func configureSettings() {
+        let dpKeys: [(ThingSmartCameraDPKey, (AnyObject) -> Void)] = [
+            (ThingSmartCameraDPKey.basicFlipDPName, { value in
+                self.isFlipEnabled = value.thingsdk_toBool()
+                print("Tuya: Flip setting updated. Flip is now \(self.isFlipEnabled ? "enabled" : "disabled").")
+            }),
+            (ThingSmartCameraDPKey.basicOSDDPName, { value in
+                self.isWaterMarkEnabled = value.thingsdk_toBool()
+                print("Tuya: Watermark setting updated. Watermark (OSD) is now \(self.isWaterMarkEnabled ? "enabled" : "disabled").")
+            }),
+            (ThingSmartCameraDPKey.init(rawValue: "231"), { value in
+                self.isAntiDismantlingAlarmEnabled = value.thingsdk_toBool()
+                print("Tuya: Anti Dismantling Alarm setting updated. Anti Dismantling Alarm is now \(self.isAntiDismantlingAlarmEnabled ? "enabled" : "disabled").")
+            }),
+            (ThingSmartCameraDPKey.basicNightvisionDPName, { value in
+                self.nightVisionLevel = value.thingsdk_toString()
+                print("Tuya: Night vision mode updated to \(self.nightVisionLevel).")
+            }),
+            // 8s and Aosu Motion Detection
+            (ThingSmartCameraDPKey.motionDetectDPName, { value in
+                self.isMotionDetectionEnabled = value.thingsdk_toBool()
+                print("Tuya: Motion detection updated. Motion Detection is now \(self.isMotionDetectionEnabled ? "enabled" : "disabled").")
+            }),
+            // 8s Motion Sensitivity
+            (ThingSmartCameraDPKey.motionSensitivityDPName, { value in
+                self.motionSensitivityLevel = value.thingsdk_toString()
+                print("Tuya: Motion sensitivity level updated to \(self.motionSensitivityLevel).")
+            }),
+            // Aosu Motion Sensitivity
+            (ThingSmartCameraDPKey.basicPIRDPName, { value in
+                self.basicPIRSensitivityLevel = value.thingsdk_toString()
+                print("Tuya: Aosu Motion sensitivity level updated to \(self.basicPIRSensitivityLevel).")
+            }),
+            // 15s motion detection
+            (ThingSmartCameraDPKey.init(rawValue: "240"), { value in
+                self.isPIRDetectionEnabled = value.thingsdk_toBool()
+                print("Tuya: PIR detection updated. PIR Detection is now \(self.isPIRDetectionEnabled ? "enabled" : "disabled").")
+            }),
+            // 15s motion sensitivity
+            (ThingSmartCameraDPKey.init(rawValue: "241"), { value in
+                self.pirSensitivityLevel = value.thingsdk_toInt()
+                print("Tuya: PIR sensitivity level updated to \(self.pirSensitivityLevel).")
+            }),
+            (ThingSmartCameraDPKey.sdCardStatusDPName, { value in
+                self.sdCardStatus = value.thingsdk_toInt()
+                print("Tuya: SD card status updated to \(self.sdCardStatus).")
+            }),
+            (ThingSmartCameraDPKey.sdCardRecordDPName, { value in
+                self.isSDCardStorageEnabled = value.thingsdk_toBool()
+                print("Tuya: SD card storage updated. Storage is now \(self.isSDCardStorageEnabled ? "enabled" : "disabled").")
+            }),
+            (ThingSmartCameraDPKey.recordModeDPName, { value in
+                self.sdCardRecordingType = value.thingsdk_toString()
+                print("Tuya: SD card recording mode updated to \(self.sdCardRecordingType).")
+            }),
+            (ThingSmartCameraDPKey.wirelessPowerModeDPName, { value in
+                self.powerMode = value.thingsdk_toString()
+                print("Tuya: Power mode updated to \(String(describing: self.powerMode)).")
+            }),
+            (ThingSmartCameraDPKey.wirelessElectricityDPName, { value in
+                self.remainingBattery = value.thingsdk_toInt()
+                print("Tuya: Battery percentage updated to \(self.remainingBattery ?? 0)%.")
+            }),
+            (ThingSmartCameraDPKey.init(rawValue: "165"), { value in
+                self.chimeType = value.thingsdk_toString()
+                print("Tuya: Chime type updated to \(self.chimeType).")
+            })
+            // (ThingSmartCameraDPKey.basicIndicatorDPName, { value in
+            //     let indicatorON = value.thingsdk_toBool()
+            //}),
+            // (ThingSmartCameraDPKey.basicPrivateDPName, { value in
+            //     let privateOn = value.thingsdk_toBool()
+            //}),
+            // (ThingSmartCameraDPKey.decibelDetectDPName, { value in
+            //     let decibelDetectOn = value.thingsdk_toBool()
+            //}),
+            //(ThingSmartCameraDPKey.decibelSensitivityDPName, { value in
+            //    let decibelSensitivity = value.thingsdk_toString()
+            //}),
+            //(ThingSmartCameraDPKey.wirelessBatteryLockDPName, { value in
+            //    let batteryLockOn = value.thingsdk_toBool()
+            //})
+        ]
+        let dispatchGroup = DispatchGroup()
+        for (dpKey, action) in dpKeys {
+            dispatchGroup.enter()
+            if let value = SettingsManager.shared.getDPValue(dpKey: dpKey) as AnyObject? {
+                action(value)
+            } else {
+                print("Tuya: Settings - Unsupported DP key or invalid value detected for '\(dpKey)'.")
+            }
+            dispatchGroup.leave()
+        }
+        dispatchGroup.notify(queue: .main) {
+                self.isAosu = SettingsManager.shared.isAosu()
+                self.is8s = SettingsManager.shared.is8s()
+                print("Tuya: Settings isAosu and is8s falg set successfully.")
+        }
+    }
+    
+    private func withCameraType<T>(execute: (ThingSmartCameraType) -> T?) -> T? {
+        guard let cameraType = self.cameraType else {
+            print("Tuya: Camera type is not initialized. Updating status to disconnected.")
+            self.updateStatus(isConnected: false, isPreviewing: false, previewLoader: false)
+            return nil
+        }
+        return execute(cameraType)
+    }
+    
+    // Disconnect camera
+    func disconnect() {
+
+        if !self.isConnected {
+            AppUtility.dismissRootViewController()
+        }
+        
+        withCameraType { cameraType in
+            self.updateStatus(previewLoader: true, settingsLoader: true)
+            let result = cameraType.disConnect()
+            print("Tuya: Disconnect triggered. Result: \(result)")
+            
+            if AppUtility.shouldClose {
+                print("Tuya: Closing the Tuya Module.")
+                AppUtility.dismissRootViewController()
+            }
+            
+            // TODO:: Check why disconnect not triggering the callback instead of handling the states.
+            self.updateStatus(
+                isConnected: false,
+                isPreviewing: false,
+                isPlaybacking: false,
+                isMicOn: false,
+                previewLoader: false,
+                dashboardLoader: false,
+                playbackLoader: false,
+                settingsLoader: false
+            )
+        }
+    }
+    
+    // Camera Voice control functions
+    func startTalk() {
+        withCameraType { cameraType in
+            self.updateStatus(dashboardLoader: true)
+            let result = cameraType.startAudioTalk()
+            print("Tuya: Start audio talk triggered. Result: \(result)")
+        }
+    }
+    
+    func stopTalk() {
+        withCameraType { cameraType in
+            self.updateStatus(dashboardLoader: true)
+            let result = cameraType.stopAudioTalk()
+            print("Tuya: Stop audio talk triggered. Result: \(result)")
+        }
+    }
+    
+    func enableMute(
+        enable: Bool,
+        type: ThingSmartCameraPlayMode
+    ) {
+        withCameraType { cameraType in
+            let result = cameraType.enableMute(enable, for: type)
+            print("Tuya: Mute action triggered to \(enable ? "enabled" : "disabled"). Result: \(result)")
+            if result == -20005 {
+                print("Tuya: Mute/unmute not allowed during recording.")
+            }
+        }
+    }
+    
+    // Change resolution
+    func changeResolution(
+        resolution: ThingSmartCameraDefinition
+    ) {
+        withCameraType { cameraType in
+            let result = cameraType.setDefinition(resolution)
+            print("Tuya: Resolution change triggered to \(resolution). Result: \(result)")
+        }
+    }
+    
+    // Start and stop preview
+    func startPreview() {
+        withCameraType { cameraType in
+            if isConnected {
+                self.updateStatus(previewLoader: true)
+                let result = cameraType.startPreview()
+                print("Tuya: Start Preview triggered. Result: \(result)")
+            } else {
+                self.updateStatus(isConnected: false, isPreviewing: false, previewLoader: false)
+                print("Tuya: Cannot start preview. Camera is not connected.")
+            }
+        }
+    }
+    
+    func stopPreview() {
+        withCameraType { cameraType in
+            let result = cameraType.stopPreview()
+            print("Tuya: Stop Preview triggered. Result: \(result)")
+        }
+    }
+    
+    // Screenshot and video recording
+    func screenshot() {
+        withCameraType { cameraType in
+            let result = cameraType.snapShoot()
+            
+            if result == nil {
+                print("Tuya: Screenshot failed.")
+            } else {
+                self.isScreenshotSuccess = true
+                print("Tuya: Screenshot captured successfully.")
+            }
+        }
+    }
+    
+    func startRecording() {
+        withCameraType { cameraType in
+            let result = cameraType.startRecord()
+            print("Tuya: Start video recording triggered. Result: \(result)")
+        }
+    }
+    
+    func stopRecording() {
+        withCameraType { cameraType in
+            let result = cameraType.stopRecord()
+            print("Tuya: Stop video recording triggered. Result: \(result)")
+            if result == -30011 || result == -30012 {
+                self.isRecordingFailure = true
+                self.isRecording = false
+                print("Tuya: Recording forcefully stopped due to an error. Marking as failure.")
+            }
+        }
+    }
+    
+    // Playback
+    func getVideoList(
+        year: UInt,
+        month: UInt,
+        day: UInt
+    ) {
+        withCameraType { cameraType in
+            self.updateStatus(playbackLoader: true)
+            print("Tuya: Querying video list. Parameters - Year: \(year), Month: \(month), Day: \(day)")
+            self.cameraType?.queryRecordTimeSlice(
+                withYear: year,
+                month: month,
+                day: day
+            )
+        }
+    }
+    
+    func getAvailableDays(
+        year: UInt,
+        month: UInt
+    ) {
+        withCameraType { cameraType in
+            self.updateStatus(datePickerLoader: true)
+            print("Tuya: Querying available days. Parameters - Year: \(year), Month: \(month)")
+            cameraType.queryRecordDays(
+                withYear: year,
+                month: month
+            )
+        }
+    }
+    
+    func startPlayback(
+        playTime: Int,
+        startTime: Int,
+        stopTime: Int
+    ) {
+        withCameraType { cameraType in
+            self.updateStatus(playbackLoader: true)
+            cameraType.enterPlayback()
+            let result = cameraType.startPlayback(
+                playTime,
+                startTime: startTime,
+                stopTime: stopTime
+            )
+            print("Tuya: Start playback triggered. Result: \(result)")
+        }
+    }
+    
+    func stopPlayback() {
+        withCameraType { cameraType in
+            let result = cameraType.stopPlayback()
+            print("Tuya: Stop playback triggered. Result: \(result)")
+        }
+    }
+    
+    func resumePlayback() {
+        withCameraType { cameraType in
+            self.updateStatus(playbackLoader: true)
+            let result = cameraType.resumePlayback()
+            print("Tuya: Resume playback triggered. Result: \(result)")
+        }
+    }
+    
+    func pausePlayback() {
+        withCameraType { cameraType in
+            self.updateStatus(playbackLoader: true)
+            let result = cameraType.pausePlayback()
+            print("Tuya: Pause playback triggered. Result: \(result)")
+        }
+    }
+    
+    private func updateStatus(
+        isConnected: Bool? = nil,
+        isPreviewing: Bool? = nil,
+        isPlaybacking: Bool? = nil,
+        isMicOn: Bool? = nil,
+        previewLoader: Bool? = nil,
+        dashboardLoader: Bool? = nil,
+        playbackLoader: Bool? = nil,
+        datePickerLoader: Bool? = nil,
+        settingsLoader: Bool? = nil
+    ) {
+        if let isConnected = isConnected {
+            Tuya.shared.isConnected = isConnected
+        }
+        if let isPreviewing = isPreviewing {
+            Tuya.shared.isPreviewing = isPreviewing
+        }
+        if let isPlaybacking = isPlaybacking {
+            Tuya.shared.isPlaybacking = isPlaybacking
+        }
+        if let isMicOn = isMicOn {
+            Tuya.shared.isMicOn = isMicOn
+        }
+        if let previewLoader = previewLoader {
+            Tuya.shared.previewLoader = previewLoader
+        }
+        if let dashboardLoader = dashboardLoader {
+            Tuya.shared.dashboardLoader = dashboardLoader
+        }
+        if let playbackLoader = playbackLoader {
+            Tuya.shared.playbackLoader = playbackLoader
+        }
+        if let datePickerLoader = datePickerLoader {
+            Tuya.shared.datePickerLoader = datePickerLoader
+        }
+        if let settingsLoader = settingsLoader {
+            Tuya.shared.settingsLoader = settingsLoader
+        }
+    }
+}

package/ios/tuya/TuyaMessages.swift

@@ -0,0 +1,98 @@
+import ThingSmartCameraBase
+import ThingSmartDeviceKit
+import ThingSmartCameraKit
+
+class TuyaMessages: NSObject {
+    
+    static let shared = TuyaMessages()
+    
+    private override init() {}
+    
+    func getAvailableMessageDates(
+        year: Int,
+        month: Int,
+        success: @escaping ([Int]) -> Void,
+        failure: @escaping (Error?) -> Void
+    ) {
+        guard let messages = Tuya.shared.messages else {
+            print("Tuya: Messages is not initialized")
+            failure(nil)
+            return
+        }
+
+        Tuya.shared.datePickerLoader = true
+        
+        messages.messageDays(
+            forYear: year,
+            month: month,
+            success: { days in
+                Tuya.shared.datePickerLoader = false
+                print("Tuya: get message days \(String(describing: days))")
+                
+                if let days = days {
+                    let updatedDays = days.compactMap { Int($0) }
+                    success(updatedDays)
+                    print("Updated Available Message Days: \(updatedDays)")
+                } else {
+                    print("Tuya: No available days returned")
+                    success([])
+                }
+            },
+            failure: { error in
+                Tuya.shared.datePickerLoader = false
+                Airbrake.logMessage(title: "Error in get messageDays", message: error?.localizedDescription ?? "")
+                failure(error)
+            }
+        )
+    }
+    
+    func getMessages(
+        startDate: Date,
+        offset: Int,
+        completion: @escaping ([ThingSmartCameraMessageModel]?) -> Void
+    ) {
+        guard let messages = Tuya.shared.messages else {
+            print("Tuya: Messages is not initialized")
+            completion(nil)
+            return
+        }
+        
+        Tuya.shared.messagesLoader = true
+        
+        let selectedDateInSeconds = max(
+            Int(startDate.timeIntervalSince1970),
+            Tuya.shared.lastMoveoutAt.map { DateUtil.shared.convertToEpoch(isoDateString: $0) } ?? 0
+        )
+
+        // Calculate the endTime by adding 24 hours (86340 seconds)
+        let endTime = selectedDateInSeconds + 86340
+        
+        print("Tuya: Fetching messages for: \(selectedDateInSeconds) to \(endTime), offset: \(offset)")
+        
+        messages.getSchemes { result in
+            if let firstScheme = result?.first {
+                messages.messages(
+                    withMessageCodes: firstScheme.msgCodes,
+                    offset: offset,
+                    limit: 20,
+                    startTime: selectedDateInSeconds,
+                    endTime: endTime
+                ) { resultArray in
+                    completion(resultArray)
+                } failure: { error in
+                    Airbrake.logMessage(title: "Error in getMessages", message: error?.localizedDescription ?? "")
+                    Tuya.shared.messagesLoader = false
+                    completion(nil)
+                }
+            } else {
+                print("Tuya: No schemes available")
+                Tuya.shared.messagesLoader = false
+                completion(nil)
+            }
+        } failure: { error in
+            Airbrake.logMessage(title: "Error in getMessageScheme", message: error?.localizedDescription ?? "")
+            Tuya.shared.messagesLoader = false
+            completion(nil)
+        }
+    }
+}

package/ios/utils/Airbrake.swift

@@ -0,0 +1,31 @@
+import Foundation
+import Airbrake_iOS
+
+final class Airbrake {
+    
+    static func initialize(apiKey: String, projectID: String) {
+        ABNotifier.start(
+            withAPIKey: apiKey,
+            projectID: projectID,
+            environmentName: ABNotifierAutomaticEnvironment,
+            useSSL: true
+        )
+        print("Tuya: Airbrake initialized successfully.")
+    }
+    
+    static func logMessage(title: String, message: String, additionalInfo: [AnyHashable: Any]? = nil) {
+        print("Tuya: \(title) \(message) \(String(describing: additionalInfo))")
+        
+        let exception = NSException(
+            name: NSExceptionName(rawValue: title),
+            reason: message,
+            userInfo: nil
+        )
+
+        if let additionalInfo = additionalInfo {
+            ABNotifier.logException(exception, parameters: additionalInfo)
+        } else {
+            ABNotifier.logException(exception)
+        }
+    }
+}