SwiftBackupPrem

An advanced Xposed / LSPosed / LSPatch module for Swift Backup that unlocks Premium features, enables cloud backups for local accounts, and supports isolated personal Firebase backends.

• Features
  • Core Features
  • Cloud & Migration Capabilities
  • Companion App & Usability
• How it Works
• Compatibility & Prerequisites
• Installation & Activation
  • Method 1: Obtainium (Recommended)
  • Method 2: Manual Download
  • Rooted Activation (LSPosed / LibXposed)
  • Rootless Setup (LSPatch)
  • Android TV / Leanback Devices
• Choosing Your Cloud Workflow
• Local Account Cloud Features Guide
  • How It Works Under the Hood
  • Encryption Keys & Custom UID
• Custom Firebase Setup Guide
  • Why Use Your Own Firebase Instance?
  • Step 1: Create a Firebase Project
  • Step 2: Set Up Realtime Database & Security Rules
  • Step 3: Configure Authentication
  • Step 4: Register Android App & OAuth Client
  • Step 5: Enable Google Drive API & OAuth Scopes
  • Step 6: Import or Enter Credentials in SwiftBackupPrem
• Migrating & Accessing Backups from Default Firebase
• Backup Migration
  • Local Migrator (Decrypt, Convert & Re-encrypt)
  • Universal Cloud Discovery & Snapshot Injection
  • Firebase Realtime Database Metadata Sync
• LSPatch Rootless Integration & In-App Settings
• Configuration Export & Migration
• Building from Source
• Community & Support
• Frequently Asked Questions (FAQ)
• Credits & Acknowledgements
• License & Disclaimer

• Unlocks Premium Features: Unlocks all Swift Backup Premium features (batch operations, scheduling, cloud backups, app data backup/restore, custom folder backups) without requiring Google Play Store licensing checks.
• Privacy & Telemetry Suppression: Blocks Firebase Analytics, Crashlytics, Sessions, Installations, and Google DataTransport calls to keep your backup operations private.
• Root & Rootless Environments: Works in rooted environments (Magisk, KernelSU, APatch with LSPosed or Vector) and non-rooted environments via JingMatrix/LSPatch.

• Local Account Cloud Features (Zero-Firebase Mode): Enables cloud backup creation, cloud file uploads, and cloud backup restores for offline/local accounts without requiring a Google account or Firebase project. Intercepts Realtime Database calls to persist catalog metadata locally and to cloud providers directly, with optional Custom Encryption UID for backups.
• Universal Cloud Discovery & Snapshot Injection: Multi-cloud scanner (Google Drive, Microsoft OneDrive, Dropbox, Box, pCloud, Amazon S3, WebDAV / Nextcloud / ownCloud) that discovers cloud backups without prior database records, injecting synthetic Firebase DataSnapshot objects directly into Swift Backup's native restore screens.
• Fast-Path Remote Discovery & Cloud Cache: Caches catalog metadata locally for instant offline navigation across restore screens, and synchronizes canonical cache files to cloud remotes for instant discovery on new devices.
• Remote APK Manifest Parsing via HTTP Range Requests: Uses ApkRangeManifestParser for cloud discovered backups to fetch only the remote APK ZIP Central Directory and parse AndroidManifest.xml via HTTP byte ranges in seconds, displaying exact app labels, package names, and version codes without downloading gigabytes of data.
• Google Drive Full OAuth Scope Expansion: Upgrades runtime OAuth scopes from restricted drive.file to full drive access so Swift Backup can query and restore backups uploaded from other devices or Swift Backup accounts on different Firebase projects.
• Local Backup Migrator & Re-encryptor: On-device cryptographic engine to decrypt archives, repair missing metadata, switch encryption keys (Shared Anonymous Key vs Custom Firebase UID), or export unencrypted portable archives (.apk, .tar.gz, .json).

• Modern Material 3 UI: Clean user interface built with Jetpack Compose, Material 3 guidelines, dynamic color adaptation, and edge-to-edge support.
• Android TV / Leanback Support: Features a custom Leanback banner, native D-pad focus traversal, and big-screen friendly layouts for Android TV devices.
• In-App Settings Integration: When running in LSPatch Integrated Mode, module settings inject natively into Swift Backup's settings menu (Settings → SwiftBackupPrem).
• Guided Setup & 1-Tap Helpers: In-app Setup Wizard with clipboard helpers (Package Name, SHA-1 signing fingerprint) and one-tap import for google-services.json files.
• Configuration Export & Import: Export your active configuration to sbp_config.json and restore it instantly on fresh ROM installs or secondary devices.
• Quick Process Controls: One-tap Root Force Stop and Launch shortcuts directly within the app.

• Dynamic DexKit Bytecode Scanning: Utilizes DexKit to dynamically locate obfuscated classes, methods, and fields at runtime across versions, ensuring robust compatibility with newer app releases without requiring fragile hardcoded ProGuard symbols.
• Native JNI Protection: Leverages a companion C native library (libnativelib.so) to intercept JNI_OnLoad calls, ensuring 16 KB kernel page-size alignment for Android 15+ devices.

Automatically download and receive updates by adding SwiftBackupPrem to Obtainium:

Or add the repository URL manually in Obtainium:

https://github.com/s1ddhants1/SwiftBackupPrem

1. Download the latest APK from the Releases page.
2. Install the APK on your device.

1. Open LSPosed Manager (or your active LibXposed framework manager).
2. Navigate to the Modules tab and tap SwiftBackupPrem.
3. Toggle Enable module.
4. Ensure the scope includes Swift Backup (org.swiftapps.swiftbackup).
5. Force stop Swift Backup or reboot your device.
6. Open SwiftBackupPrem to configure your preferred cloud mode (see Choosing Your Cloud Workflow).

SwiftBackupPrem fully supports rootless installation via LSPatch:

• Manager Mode:
  1. Patch Swift Backup with LSPatch in Manager Mode.
  2. Install SwiftBackupPrem APK as a separate companion application.
  3. Enable SwiftBackupPrem in LSPatch Manager under Swift Backup's module list.
• Integrated Mode (Standalone APK):
  1. Patch Swift Backup with LSPatch in Integrated Mode, selecting the SwiftBackupPrem APK as an embedded module.
  2. Install the patched Swift Backup APK.
  3. Module settings will appear natively inside Swift Backup under Settings → SwiftBackupPrem! (No manager app required).

SwiftBackupPrem includes native Android TV metadata:

• Sideload the APK onto your Android TV or Google TV box via ADB or a file manager.
• The app appears directly on your Leanback home screen launcher with a dedicated banner.
• All interface controls, tabs, and buttons are navigable via the standard D-pad remote control.

SwiftBackupPrem provides two ways to manage cloud backups. Pick the workflow that fits your needs:

• Workflow A: Local Account Cloud Features
  Use Swift Backup with a Local Account (no Google Sign-In). Enables full cloud backup creation, file uploads, and restores across any supported provider (WebDAV, Nextcloud, S3, OneDrive, Google Drive, etc.) with zero Firebase or Google Cloud setup.

• Workflow B: Custom Firebase Backend
  Connect your own personal Firebase project to sign in with your Google Account. Ideal if you want backups linked to your Google identity and want metadata persisted to your private Realtime Database.

Swift Backup normally restricts cloud storage and cloud backups to users signed in with a Google account via Firebase. Selecting "Local Account" disables cloud access.

Local Account Cloud Features completely removes this restriction, enabling full cloud backup creation, cloud file uploads, and cloud backup restores for offline and local accounts.

1. Open Swift Backup and choose Local Account (skip Google Sign-In).
2. Open SwiftBackupPrem and toggle on Local Account Cloud Features.
3. (Optional) Under Encryption Key, select Shared Anonymous Key (offline-restorable on any device) or Custom Key (enter any custom UID).
4. Return to Swift Backup > Settings > Cloud Storage and configure your cloud provider (WebDAV, Nextcloud, OneDrive, Dropbox, Box, pCloud, S3, or Google Drive).
5. Perform backups, view cloud sync, and restore directly!

• Identity Spoofing: LocalCloudUnlockHook transparently intercepts isAnonymous() calls during cloud operations, making Swift Backup recognize the local user as fully authorized.
• Database Virtualization: CloudDatabaseManager virtualizes Firebase Realtime Database reads and writes in memory and keeps a canonical cache at /sdcard/SwiftBackup/cloud_discovered_cache.json.
• Direct Cloud Uploads: Application metadata manifests are automatically written and synchronized directly to your connected cloud storage remotes.
• Dialog Suppression: FirebaseConnectionWatcher intercepts backend connectivity loops and suppresses network error dialogs.

Swift Backup encrypts backup data using Facebook Conceal (AES-256-GCM) keyed to the account UID:

• Shared Anonymous Key (d58b0944415a4889d7f11aa95fbeca50): Standard anonymous key that stores backups under account folder hash 8690a48a4fcc72f1. These backups can be restored offline on any device running Swift Backup.
• Custom Key: Enter a custom string or UID. The hook sets your custom UID into memory so that encryption key derivation (deriveConcealKey) and directory hashes (computeAccountHash) match your private key.

By default, Swift Backup authenticates against the app developer's Firebase project. If the developer blocks or bans your account on their Firebase instance, access to the account will be revoked, and you will not be able to restore your backups.

Connecting your own personal Firebase project gives you complete isolation, ensures data privacy, and prevents remote bans.

1. Go to the Firebase Console.
2. Click Add project (or Create a project).
3. Enter a project name (e.g., SwiftBackup-Personal) and continue.
4. Google Analytics can be disabled (optional) to speed up creation.
5. Click Create project and wait for provisioning to finish.

1. In your Firebase project sidebar, go to Databases & Storage > Realtime Database.
2. Click Create Database, select a region close to you (e.g., United States or Belgium), and choose Start in locked mode.
3. Once created, switch to the Rules tab at the top.
4. Replace the existing rules with the following user-isolated security rules:

{
  "rules": {
    "users": {
      "$uid": {
        ".read": "$uid === auth.uid",
        ".write": "$uid === auth.uid"
      }
    }
  }
}

5. Click Publish to save the rules.
6. Copy your Realtime Database URL from the Data tab (e.g., https://your-project-id-default-rtdb.firebaseio.com/).

1. In the Firebase sidebar, navigate to Security > Authentication.
2. Select the Sign-in method tab.
3. Under Additional providers, select Google.
4. Toggle Enable, enter a Public-facing name for project of your choice, choose a Project support email, and click Save.

1. In Firebase Console, go to the Project Overview page from the sidebar.
2. Under "Select a platform to get started", click the Android icon (Add app).
3. Enter the package details:
   • Android package name: org.swiftapps.swiftbackup (or tap "Copy Package" in SwiftBackupPrem's Custom Firebase setup screen)
   • App Nickname: SwiftBackupPersonal (or any name you like)
4. Click Register app.
5. Click Download google-services.json to save the configuration file.
6. Click Next through the remaining setup steps, then click Continue to console.
7. On the Project Overview page, click the newly registered app card and select the Gear icon (Project Settings).
8. Scroll down to the Your apps section, click Add fingerprint, paste your SHA-1 fingerprint (tap "Copy Fingerprint" in the Custom Firebase setup screen in the module), and click Save.
9. (Optional) Click the Data privacy tab on Project Settings and uncheck Firebase Service Data Sharing.

1. Open the Google Cloud API Credentials Console by clicking View in Google Cloud on the Firebase Project Settings page.
2. Ensure your Firebase / Google Cloud project is selected in the top project dropdown.
3. In the sidebar, navigate to APIs & Services > Credentials.
4. Under OAuth 2.0 Client IDs, edit the auto-generated Android client for org.swiftapps.swiftbackup.
5. Under Advanced settings, check Enable custom URI scheme (click Yes in the confirmation popup).
6. Click Save.
7. Copy the generated Client ID string (e.g., xxxxxxxxxxxx-xxxxxxxxxxxxxxxx.apps.googleusercontent.com).

If you plan to use Google Drive for cloud backups:

1. Visit the Google Cloud Drive API Console.
2. Select your Firebase / Google Cloud project at the top.
3. Click Enable to allow Swift Backup to interact with Google Drive via your project.

1. Open the Google Cloud OAuth Scopes Console.
2. Ensure your project is selected at the top.
3. Navigate to Data Access > click Add or remove scopes.
4. In the filter box, search for and enable:

   https://www.googleapis.com/auth/drive.file
   

   (This provides safe, per-file access for files created or opened by Swift Backup without requiring broad drive permissions).
5. Click Update, then click Save (or Save and continue).

1. Open SwiftBackupPrem on your device.
2. Enable Custom Firebase app.
3. Choose either method:
   • Method A (Automatic): Tap Import google-services.json and pick the downloaded JSON file. Then paste your OAuth Client ID into the Client ID field.
   • Method B (Manual Wizard): Follow the guided setup in the app to review and confirm all fields.
4. Tap Finish & Save.
5. Tap Force Stop at the bottom to kill any running Swift Backup instances, then tap Open App.
6. Sign in to Swift Backup with your Google account.

Install Swift Backup with the default Firebase configuration and log in to pull your UID from /data/data/org.swiftapps.swiftbackup/shared_prefs/com.google.firebase.auth.api.Store.*.xml:

su -c 'grep -o "GET_TOKEN_RESPONSE\.[^\"]*" /data/data/org.swiftapps.swiftbackup/shared_prefs/com.google.firebase.auth.api.Store.*.xml | cut -d. -f2'

Swift Backup takes the MD5 hash of your Firebase UID and uses the first 16 characters for the folder name:

echo -n "example uid" | md5sum | cut -c 1-16

Output: example16char -> /sdcard/SwiftBackup/accounts/example16char/
or in case of cloud folder: Swift Backup (example16char)

1. Install Firebase tools using your preferred package manager (e.g., via Node.js):

   npm install -g firebase-tools

2. Run firebase login to connect your account:

   firebase login

3. Create a users.json file:

   {
     "users": [
       {
         "localId": "example uid",
         "email": "examplemail@gmail.com",
         "emailVerified": true,
         "displayName": "examplename"
       }
     ]
   }

4. View your Project ID:

   firebase projects:list

5. Run the import command:

   firebase auth:import users.json --project exampleprojectID

6. Log in again to Swift Backup.

SwiftBackupPrem features a powerful, built-in Backup Migration Tool (accessible by tapping the Backup Migration card from the main screen).

The Migration Tool bridges the gap between different Firebase environments and cloud storage configurations through two dedicated tabs:

1. Local Migration: An on-device cryptographic and metadata reconstruction tool to decrypt, convert, and re-encrypt existing backup folders across different Firebase UIDs, anonymous keys, or unencrypted portable formats.
2. Cloud Discovery & Injection: A runtime hooking and scanning engine that discovers backups across diverse cloud providers (Google Drive, OneDrive, Dropbox, Box, pCloud, S3, WebDAV / Nextcloud) and injects them directly into Swift Backup's restore screens without requiring prior database records.

Swift Backup encrypts application data (.dat, .extdat, .med), system payloads, and directory archives (folder-base.fld) using Facebook Conceal (AES-256-GCM + Zstandard compression) keyed against the user's active Firebase UID. If you switch to a custom Firebase backend, set up a new account, or recover backups after being banned from the official backend, the encryption key changes—making older backups unreadable by the new account.

The Local Migrator resolves this entirely on-device without requiring internet access or root shell commands. It recursively inspects backup folders, decrypts archives using the source key, reconstructs missing metadata, and re-encrypts or extracts the data into your chosen target format.

1. Step 1: Source Folder

   • Enter the path to your existing backup directory or tap the folder icon to select it via the system Document picker.
   • The engine recursively walks the directory tree (up to 20 levels deep) to identify all app backup directories (containing .app, .apk, .dat, .splits, .extdat, .med, .xml, or .extra) and folder backups (starting with Folder- or containing folder-base.* / metadata.json).

2. Step 2: Decryption Key (Source UID)

   • Enter or paste the Firebase UID that originally encrypted the backups.
   • Key Presets & Detected UIDs: Tap the refresh icon to auto-detect candidate Firebase UIDs found in Swift Backup's local configuration, cached tokens (.sbp_auth_state), or preferences.
   • Shared Anonymous Key: Tap the Shared Anonymous Key chip to fill in the built-in anonymous key (d58b0944415a4889d7f11aa95fbeca50) if migrating from anonymous offline backups.

3. Step 3: Target Encryption Mode Choose how you want the migrated backups to be packaged:

   • Shared Anonymous Key (Recommended): Re-encrypts archives using Swift Backup's static anonymous key. Output can be restored in Swift Backup offline without logging into any Firebase account.
   • Custom Firebase UID: Re-encrypts archives specifically for your custom Firebase project UID.
   • Unencrypted Backups: Strips AES-256-GCM Conceal encryption completely from data slices and keeps Swift Backup's directory layout.
     • Portable Formats Checkbox: When Unencrypted mode is active, check Convert to standard portable formats (.apk, .tar.gz, .json) to extract standard standalone files into ExtractedBackups/:
       • .app / .apk → <packageName>.apk
       • .splits → <packageName>_splits.tar
       • .dat → <packageName>_data.tar
       • .extdat → <packageName>_external_data.tar
       • .med → <packageName>_media.tar
       • .extra → <packageName>_extras.json
       • .xml → <packageName>_metadata.json
       • .cls → <packageName>_call_logs.json
       • .msg → <packageName>_sms_messages.json
       • .wfi → <packageName>_wifi.json
       • .wal → <packageName>_wallpaper.png
       • folder-base.fld → <folderName>.tar
       • folder-base.flm → <folderName>_manifest.json

4. Step 4: Destination Folder & Start Migration

   • Enter the output directory (defaults to /storage/emulated/0/SwiftBackup).
   • The engine organizes files into Swift Backup's standard hierarchy:
     • SwiftBackup/accounts/<accountHash>/backups/apps/local/<packageName>/<backupId>/
     • SwiftBackup/accounts/<accountHash>/backups/folders/local/<folderName>/
   • Tap Start Migration. The screen displays real-time progress indicators (item count, percentage bar, and current package), along with live execution logs.
   • Metadata Reconstruction: If the original .xml metadata is missing, the engine automatically extracts metadata from the APK manifest (versionCode, versionName, app label) and decrypts the .extra payload for SSAID, permission states, and notification policy settings.

Swift Backup normally depends strictly on Firebase Realtime Database (RTDB) records to discover and list cloud backups. If an RTDB record is missing (such as when using a Custom Firebase backend, restoring after an account ban, or restoring across devices), Swift Backup cannot see the backups stored in your cloud, even if the files exist in your cloud drive.

The Cloud Discovery & Injection option bypasses this limitation entirely. It scans configured cloud storage remotes, extracts metadata on the fly, and injects snapshots into Swift Backup's runtime memory.

• Default Swift Backup Behavior: Requests the restricted https://www.googleapis.com/auth/drive.file scope, limiting file visibility strictly to files created by the current app session.
• Expanded Scope: When Google Drive Full OAuth Scope is enabled, the module dynamically intercepts OAuth request builders, URI builders, and authentication intents during sign-in, upgrading the requested scope to:

  https://www.googleapis.com/auth/drive
  

• Result: Grants Swift Backup visibility to query and restore backups uploaded from different devices, previous ROMs, or prior accounts.

When Universal Cloud Discovery is toggled on, SwiftBackupPrem scans across all connected remote storage providers supported by Swift Backup:

• Applications: APKs (.app/.apk), split APKs (.splits), app data (.dat), external data (.extdat), media (.med), and metadata (.extra).
• Folders: Custom folder archives (.fld, .flm, metadata.json).
• System Data: Call logs (.cls), SMS messages (.msg), Wallpapers (.wal, .wal.png), and Wi-Fi configurations (.wfi).

To display accurate app titles, package names, and version codes without downloading multi-gigabyte APKs over mobile data, the discovery engine incorporates ApkRangeManifestParser. It performs HTTP Range requests to fetch only the ZIP central directory and parse AndroidManifest.xml remotely in seconds.

The module includes an in-memory Firebase Snapshot Synthesizer:

• Hooks into Swift Backup's internal Firebase queries and DataSnapshot handlers (single-app details listeners, batch cloud restore loaders, app filter helpers, cloud sync tab, and folder loaders).
• Synthesizes live DataSnapshot objects formatted identically to native RTDB entries under the cloud_v1 hierarchy.
• Result: Discovered cloud backups appear immediately in:
  • Single App Details (with all restorable parts: APK, Data, Ext Data, Splits)
  • Cloud Sync Tab (with accurate backup timestamps and device tags)
  • Batch Restore Screen (allowing one-tap bulk restoration)
  • Cloud Backup Tags Dropdown (filtering backups by device model / tag)

Discovered cloud backups are saved locally to:

/sdcard/SwiftBackup/cloud_discovered_cache.json

• Provides instant offline navigation across restore screens without waiting for network scans on every screen launch.
• An in-memory cache TTL (60 seconds) prevents redundant cloud network requests during rapid screen switching.
• Tap Clear Cloud Cache in the app at any time to purge cached entries and trigger an immediate fresh scan across your cloud providers.

While Snapshot Injection dynamically provides in-memory restore entries, you can also permanently persist discovered and reconstructed metadata to your private Firebase Realtime Database using the Sync Metadata to Custom Firebase feature:

• Native cloud_v1 Structure: The sync engine writes directly to Swift Backup's official RTDB schema:

  /users/<UID>/cloud_v1/<provider_key>/tags/<device_tag>/apps/<sanitized_pkg>/<backup_id>
  /users/<UID>/cloud_v1/<provider_key>/tags/<device_tag>/folders/<folder_id>
  

  (where <provider_key> is resolved in the format <provider> (<sanitized_email>)).
• Smart Deduplication: Before writing, the sync engine queries your existing RTDB cloud_v1 tree to skip existing records and avoid redundant write operations.
• Token Resolution & Authentication: Automatically resolves Firebase Auth ID tokens from Swift Backup's OAuth session or exchanged refresh tokens, ensuring secure authenticated database writes.
• Sync Now Button: Tap the Sync Now button inside the Cloud Discovery tab to trigger an immediate full sync of all local and cloud metadata records.

SwiftBackupPrem provides complete, first-class support for rootless setups using LSPatch (the actively maintained JingMatrix/LSPatch fork is recommended):

When patched using LSPatch's Integrated Mode, SwiftBackupPrem's hook engine embeds directly into Swift Backup:

• Native Settings Menu: Module preferences are injected into Swift Backup's settings hierarchy under Settings → SwiftBackupPrem.
• Streamlined Experience: You can toggle Premium Features, Telemetry Suppression, Local Account Cloud Features, and Custom Firebase directly inside Swift Backup without needing an external manager app.

Under LSPatch, root daemon processes launched by libsu (RootService) for SBA root backups would normally crash (SIGABRT / GetObjectField(null) in liblspatch.so) because bare daemon processes lack Android Application and ActivityThread contexts.

SwiftBackupPrem solves this transparently:

• Intercepts root process startup tasks and wraps execution in an isolated Linux mount namespace (unshare -m).
• Inside the private namespace, it bind-mounts the original, unpatched APK over the patched wrapper.
• Root SBA backup and restore daemons start and bind cleanly with zero LSPatch crashes.

• Export Config: Tap the top-right menu (⋮) > Export Config to save your active configuration to a JSON file (sbp_config.json).
• Import Config: Tap Import Config to restore your settings in a single tap on a new device or fresh ROM install.

• JDK 17+ (e.g. Adoptium Eclipse Temurin 17 or 25)
• Android SDK with Platform 37 (compileSdk 37)
• Android NDK (29.0.14206865 or higher) & CMake 3.22.1+

1. Clone the repository:

   git clone https://github.com/s1ddhants1/SwiftBackupPrem.git
   cd SwiftBackupPrem

2. Run unit tests:

   ./gradlew testDebugUnitTest

3. Build debug APK:

   ./gradlew assembleDebug

4. Build optimized release APK:

   ./gradlew assembleRelease

The compiled APK will be located in app/build/outputs/apk/release/app-release.apk.

• main: Modern LibXposed (API 101/102+) implementation for LSPosed v2.0.0+, Vector, and LSPatch.
• legacy: Classic Xposed API implementation for older Android environments (EdXposed / classic Xposed).

Join the official Telegram group for discussion, support, release updates, and assistance:

• Group Link: https://t.me/SwiftBackupPrem
• Get Help: Ask troubleshooting questions or share setup tips.
• Releases & APKs: Get direct download links and release notifications directly inside Telegram.

firebase auth:import users.json --project YOUR_PROJECT_ID

• Juby210 — Original creator and author of SwiftBackupPrem.
• s1ddhants1 — Maintainer & Lead Developer.
• LuckyPray/DexKit — Powerful runtime DEX search and hooking engine.
• LSPosed — ART hooking framework for modern Android.
• JingMatrix/LSPatch — Rootless Xposed hooking framework (actively maintained fork).

This project is licensed under the MIT License.

Disclaimer: This project is intended strictly for personal, educational, and backup management purposes. Swift Backup is developed by SwiftApps. If you enjoy Swift Backup, consider supporting the official developers.