FirebaseServicesManager 1.0.0

FirebaseServicesManager 1.0.0

×

由 DevCrew.IO 维护。

 
依赖项
FirebaseCore>= 0
FirebaseFirestore>= 0
FirebaseStorage>= 0
FirebaseDatabase>= 0
 

FirebaseServicesManager 1.0.0

  • 由
  • DevCrew.IO

FirebaseServicesManager

license

Firebase Services 是一个 Swift 包，它提供了一种方便的方式来与各种 Firebase 服务进行交互，包括 Firestore、Storage 和实时数据库。

安装

Swift 包管理器

Swift 包管理器 是一种自动化 Swift 代码分发工具，它与 swift 编译器集成。

dependencies: [
    .package(url: "https://github.com/DevCrew-io/firebase-utils-ios.git", .upToNextMajor(from: "1.0.0"))
]

手动

要在项目中手动使用FirebaseServices，请按照以下步骤操作：

  1. 通过将Firebase SDK集成到项目中使用CocoaPods或Swift Package Manager来安装它。

  2. 将FirebaseServices包添加到您的项目中。

    • 克隆或下载FirebaseServices存储库。
    • 将FirebaseServices.xcodeproj文件拖放到您的Xcode项目中。
    • 在项目目标的设置中，导航到“通用” -> “框架、库和嵌入式内容”。
    • 单击"+"按钮，选择“FirebaseServices.framework”，并选择“添加”。

  3. 在您需要使用FirebaseServices的地方导入它

import FirebaseServices

Firebase项目设置

  1. 转到Firebase控制台，使用您的Google账户登录，创建一个新的Firebase项目或选择一个现有项目，然后按照Firebase的说明完成Firebase配置。

注意：确保将GoogleService-Info.plist文件包含在每个项目目标的元数据中，并在应用运行时在应用程序包中存在。

初始化

要在AppDelegate.swift中初始化FirebaseServiceManager

import FirebaseServiceManager

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        FirebaseServices.manager.configure()


        return true
    }
}

用法

FirebaseServices包提供了以下服务

FirestoreService

该包中包含FirestoreService类，用于处理Firebase Firestore操作。以下是使用它的方法：

// Example usage of FirestoreService
// Adding a document to the specified collection
FirebaseServices.manager.firestore.add(documentAt: yourCollectionPath, dataDic: yourDataDictionary) { result in
    switch result {
    case .success(let addedDocument):
        // Handle success
        print("Document added: \(addedDocument ?? nil)")
    case .failure(let error):
        // Handle error
        print("Error adding document: \(error)")
    }
}

// Retrieving a list of documents based on the provided query
FirebaseServices.manager.firestore.getList(YourFirestoreDocument.self, firestore: yourQuery) { result in
    switch result {
    case .success(let documents):
        // Handle success
        print("Retrieved documents: \(documents)")
    case .failure(let error):
        // Handle error
        print("Error retrieving documents: \(error)")
    }
}

// Retrieving a specific document from Firestore
FirebaseServices.manager.firestore.getDocument(with: documentId, from: yourCollection, YourFirestoreDocument.self) { result in
    switch result {
    case .success(let document):
        // Handle success
        print("Retrieved document: \(document ?? nil)")
    case .failure(let error):
        // Handle error
        print("Error retrieving document: \(error)")
    }
}

// Observing changes to a collection based on the provided query
let observerHandle = FirebaseServices.manager.firestore.observeDocuments(query: yourQuery, YourFirestoreDocument.self) { result in
    switch result {
    case .success(let documents):
        // Handle success
        print("Observed documents: \(documents)")
    case .failure(let error):
        // Handle error
        print("Error observing documents: \(error)")
    }
}

// Removing an observer
FirebaseServices.manager.firestore.removeObserver(handle: observerHandle)

// Updating a document in Firestore
FirebaseServices.manager.firestore.update(with: documentId, documentIn: yourCollection, dataDic: updatedDataDictionary) { result in
    switch result {
    case .success(let updatedDocument):
        // Handle success
        print("Document updated: \(updatedDocument ?? nil)")
    case .failure(let error):
        // Handle error
        print("Error updating document: \(error)")
    }
}

// Deleting a document from Firestore
FirebaseServices.manager.firestore.delete(id: documentId, documentAt: yourCollectionPath) { result in
    switch result {
    case .success(let deleted):
        // Handle success
        print("Document deleted: \(deleted)")
    case .failure(let error):
        // Handle error
        print("Error deleting document: \(error)")
    }
}

同样，所有其他方法都可以根据您的需求使用。要查看包中通过导航到 FirestoreService 类提供的所有公开方法和操作，请进入 FirestoreService 类。

注意

创建 FirestoreQuery 时，使用 FSQuery.firestore 后跟您的数据库路径，例如

let firestoreQuery = FSQuery.firestore.collection("collectionPath")

存储服务

StorageService 类用于处理 Firebase Storage 操作。以下是您如何使用它的示例

// Example usage of StorageService
// Uploading a file to Firebase Storage
let data = ... // Your file data
let name = "example.jpg"
let folder = "images"
let metaData = StorageMetadata()
FirebaseServices.manager.storage.upload(file: data, with: name, in: folder, metaData: metaData, progressCompletion: { progress in
    // Handle progress updates
}, completion: { result in
    switch result {
    case .success(let urls):
        // Handle success
        print("File uploaded successfully. URLs: \(urls)")
    case .failure(let error):
        // Handle error
        print("Error uploading file: \(error)")
    }
})

// Downloading data from Firebase Storage
let path = "images/example.jpg"
FirebaseServices.manager.storage.downloadData(from: path, progressCompletion: { progress in
    // Handle progress updates
}, completion: { result in
    switch result {
    case .success(let data):
        // Handle success
        print("Downloaded data: \(data)")
    case .failure(let error):
        // Handle error
        print("Error downloading data: \(error)")
    }
})

// Deleting a file from Firebase Storage
FirebaseServices.manager.storage.delete(file: "example.jpg", colletion: "images") { result in
    switch result {
    case .success(let deleted):
        // Handle success
        if let deleted = deleted, deleted {
            print("File deleted successfully.")
        } else {
            print("File does not exist.")
        }
    case .failure(let error):
        // Handle error
        print("Error deleting file: \(error)")
    }
}

// Other available functions:

// - upload(file: Data, with name: String, in folder: String, metaData: StorageMetadata?, progressCompletion: @escaping (_ progress: Progress) -> (), completion: @escaping (_ result: Result<(String?, String?), Error>) -> ()) -> StorageUploadTask
// - update(file: Data, with name: String, in folder: String, progressCompletion: @escaping (_ progress: Progress) -> (), completion: @escaping (_ result: Result<(String?, String?), Error>) -> ()) -> StorageUploadTask
// - upload(file: URL, with name: String, in folder: String, metaData: StorageMetadata?, progressCompletion: @escaping (_ progress: Progress) -> (), completion: @escaping (_ result: Result<(String?, String?), Error>) -> ()) -> StorageUploadTask
// - update(file: URL, with name: String, in folder: String, progressCompletion: @escaping (_ progress: Progress) -> (), completion: @escaping (_ result: Result<(String?, String?), Error>) -> ()) -> StorageUploadTask
// - downloadData(from path: String, size: Int64 = Int64.max, progressCompletion: @escaping (_ progress: Progress) -> (), completion: @escaping (_ result: Result<Data?, Error>) -> Void) -> StorageDownloadTask
// - downloadFile(from path: String, to localURL: URL, progressCompletion: @escaping (_ progress: Progress) -> (), completion: @escaping (_ result: Result<URL?, Error>) -> Void) -> StorageDownloadTask
// - downloadURL(for path: String, completion: @escaping (_ result:  Result<URL?, Error>) -> Void)

数据库服务

DatabaseService 类包含在此包中，并用于处理 Firebase 实时数据库操作。以下是您如何使用它的示例

// Example usage of DatabaseService

// Adding data to the database
FirebaseServices.manager.database.add(ref: yourDatabaseReference, dataDic: yourDataDictionary) { result in
    switch result {
    case .success(let addedData):
        // Handle success
        print("Data added: \(addedData ?? [:])")
    case .failure(let error):
        // Handle error
        print("Error adding data: \(error)")
    }
}

// Adding data using a custom object conforming to the `DatabaseNode` protocol
FirebaseServices.manager.database.add(ref: yourDatabaseReference, dataObject: yourCustomObject) { result in
    switch result {
    case .success(let addedObject):
        // Handle success
        if let addedObject = addedObject {
            print("Object added: \(addedObject)")
        } else {
            print("Object not added.")
        }
    case .failure(let error):
        // Handle error
        print("Error adding object: \(error)")
    }
}

// Updating data in the database
FirebaseServices.manager.database.update(ref: yourDatabaseReference, dataDic: updatedDataDictionary) { result in
    switch result {
    case .success(let updatedData):
        // Handle success
        print("Data updated: \(updatedData ?? [:])")
    case .failure(let error):
        // Handle error
        print("Error updating data: \(error)")
    }
}

// Updating data using a custom object conforming to the `DatabaseNode` protocol
FirebaseServices.manager.database.update(ref: yourDatabaseReference, dataObject: updatedCustomObject) { result in
    switch result {
    case .success(let updatedObject):
        // Handle success
        if let updatedObject = updatedObject {
            print("Object updated: \(updatedObject)")
        } else {
            print("Object not updated.")
        }
    case .failure(let error):
        // Handle error
        print("Error updating object: \(error)")
    }
}

// Retrieving a single object from the database
FirebaseServices.manager.database.getSingleObject(ref: yourDatabaseReference) { result in
    switch result {
    case .success(let object):
        // Handle success
        if let object = object {
            print("Retrieved object: \(object)")
        } else {
            print("Object not found.")
        }
    case .failure(let error):
        // Handle error
        print("Error retrieving object: \(error)")
    }
}

// Retrieving a list of objects from the database
FirebaseServices.manager.database.getList(ref: yourDatabaseReference) { result in
    switch result {
    case .success(let objects):
        // Handle success
        if let objects = objects {
            print("Retrieved objects: \(objects)")
        } else {
            print("No objects found.")
        }
    case .failure(let error):
        // Handle error
        print("Error retrieving objects: \(error)")
    }
}

// Observing changes in a list of objects in the database
let observerHandle = FirebaseServices.manager.database.observeList(ref: yourDatabaseReference) { result in
    switch result {
    case .success(let objects):
        // Handle success
        if let objects = objects {
            print("Observed objects: \(objects)")
        } else {
            print("No objects observed.")
        }
    case .failure(let error):
        // Handle error
        print("Error observing objects: \(error)")
    }
}

// Removing an observer
databaseService.removeObserver(ref: yourDatabaseReference, handle: observerHandle)

// Removing all registered observers
databaseService.removeAllObservers(ref: yourDatabaseReference)

同样，所有其他方法都可以根据您的需求使用。要查看包中通过导航到 DatabaseService 类提供的所有公开方法和操作，请进入 DatabaseService 类。

注意

创建 DatabaseReference 时，使用 DBRef.database 后跟您的数据库路径，例如

let databaseReference = DBRef.database.child("your path")

作者

DevCrew.IO

如果您对 FirebaseServicesManager 有任何疑问或评论，请随时联系我们，邮箱地址为 [email protected]。

联系我们

devcrew.io mycompany DevCrew-io

贡献

欢迎贡献！有关详细信息，请参阅 贡献者。

贡献

任何形式的贡献都受到欢迎！您可以通过在GitHub上的pull requests和issues来贡献。

展示您的支持

如果您觉得这个项目有帮助，请给它点个星。

版权 & 许可

代码版权所有2023 DevCrew I/O。代码以MIT许可发布。