Core File Import Import

Import Media Files

Prepare the device hotspot, fetch its media list, and import the selected MediaFileInfoModel values.

Device-to-app media import path

The SDK prepares the device hotspot, returns authoritative media models, downloads the selection, and optionally stabilizes video.

Configure Hotspot — Prepare the temporary device network used for media transfer.
Enter Transfer Mode — Switch the connected device into its media-file transfer mode.
Connect Hotspot — Wait for the hotspot, then join the SSID reported by the callback.
Fetch Media Models — Receive the MediaFileInfoModel values that are valid import inputs.
Select Files — Choose from the returned models without replacing them with custom IDs.
Start Import — Pass the selected models into importMediaFiles and retain task progress.
Download Files — Track chunks, individual files, batch position, and transfer speed.
Stabilize Video — Run optional SDK-managed post-processing when stabilization is available.
Complete Import — Inspect every imported result and persist temporary files when required.

Prerequisites

The device is connected and conforms to DeviceMediaFileImportAPI.
The app can join the device Wi-Fi hotspot and has the required local-network permissions.
Keep the returned media models; imports accept models, not arbitrary file IDs or destination paths.

API Reference

Framework

AIBuds.xcframework

Import

Swift

import AIBuds
import AIBudsFoundation

Objective-C

#import <AIBuds/AIBuds.h>
#import <AIBuds/AIBuds-Swift.h>

Protocol Symbols

Symbol	Purpose
`isVideoStabilizationAvailable`	Whether SDK-managed stabilization is currently available.
`fetchMediaFilesInfo`	Prepare transfer mode and return device media information.
`importMediaFiles`	Download selected files and optionally post-process video.
`cancelMediaFileImport`	Cancel transfer or active post-processing.
`deleteMediaFile`	Delete one device file by file name.
`deleteAllMediaFiles`	Delete all device media files.

Declarations

The declarations preserve the SDK's multi-stage callback contract.

Swift

/// Whether SDK-internal video stabilization is available for media file import.
///
/// Returns `true` only when a stabilization plugin is registered AND stabilization
/// is not explicitly disabled. When `false`, imported six-axis files will be
/// returned with `stabilizationStatus = .disabled` (or `.pluginUnavailable`),
/// allowing the app to handle stabilization itself.
var isVideoStabilizationAvailable: Bool { get }

/// Fetch media files info from the device.
///
/// - Parameters:
///   - configureHotspotStartingHandler: A closure that is called when the hotspot configuration starts.
///   - hotspotConfigureCompletionHandler: A closure that is called when the hotspot configuration completes.
///     - success: `true` if the configuration succeeded; otherwise `false`.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
///   - enterFileTransferModeStartingHandler: A closure that is called when the file transfer mode entry starts.
///   - enterFileTransferModeCompletedHandler: A closure that is called when the file transfer mode entry completes.
///     - success: `true` if entering file transfer mode succeeded; otherwise `false`.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
///   - waitingForHotspotOpenHandler: A closure that is called when the device is waiting for the hotspot to open.
///   - connectDeviceHotspotStartingHandler: A closure that is called when the device hotspot connection starts.
///     - ssid: The SSID of the device hotspot.
///   - deviceHotspotConnectCompletionHandler: A closure that is called when the device hotspot connection completes.
///     - success: `true` if the connection succeeded; otherwise `false`.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
///   - completionHandler: A closure that is called when the fetch media files info operation completes.
///     - success: `true` if the operation was successful; otherwise `false`.
///     - mediaFiles: The media file info models to be imported.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
func fetchMediaFilesInfo(
    configureHotspotStartingHandler: AIBudsMediaFileImportConfigureHotspotStartingHandler?,
    hotspotConfigureCompletionHandler: AIBudsMediaFileImportHotspotConfigureCompletionHandler?,
    enterFileTransferModeStartingHandler: AIBudsEnterMediaFileTransferModeStartingHandler?,
    enterFileTransferModeCompletedHandler: AIBudsEnterMediaFileTransferModeCompletionHandler?,
    waitingForHotspotOpenHandler: AIBudsMediaFileImportStartingToWaitForHotspotOpenHandler?,
    connectDeviceHotspotStartingHandler: AIBudsMediaFileImportConnectDeviceHotspotStartingHandler?,
    deviceHotspotConnectCompletionHandler: AIBudsMediaFileImportDeviceHotspotConnectCompletionHandler?,
    completionHandler: AIBudsMediaFileImportFetchMediaFilesInfoCompletionHandler?
)

/// Import media files from the device.
///
/// The import process consists of two phases: file transfer (downloading the media files
/// from the device) followed by an optional video stabilization post-processing phase.
/// Progress callbacks are provided for each phase so the caller can report status to the user.
///
/// - Parameters:
///   - mediaFiles: The media file info models to be imported.
///   - dataChunkHandler: A closure that is called whenever a data chunk is received during the file transfer.
///     - dataChunk: The received data chunk; `nil` if an error occurred.
///     - taskId: The unique identifier for the current file import task.
///     - fileUrl: The URL of the file being imported.
///     - fileSize: The total size of the file in bytes.
///     - transferredSize: The number of bytes that have been transferred so far.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
///   - singleTransferStartingHandler: A closure that is called when a single file transfer starts.
///     - mediaFile: The media file info model of the file that is starting to be imported.
///   - singleTransferCompletionHandler: A closure that is called when a single file transfer completes.
///     - success: `true` if the file transfer succeeded; otherwise `false`.
///     - importedMediaFile: The local result model for this transfer, including metadata, downloaded local URL, optional playable stabilized URL, and possible error.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
///   - transferSpeedHandler: A closure that is called when the file transfer speed changes.
///     - speed: The current transfer speed in bytes per second.
///   - transferBatchProgressHandler: A closure that is called when the file transfer batch progress changes.
///     - fileIndex: The index of the current file in the batch.
///     - totalFileCount: The total number of files in the batch.
///   - videoStabilizationPhaseBeginHandler: A closure that is called when the video stabilization post-processing phase begins.
///   - videoStabilizationSingleFileProgressHandler: A closure that is called to report progress during the stabilization of an individual video file.
///     - mediaFile: The imported media file model representing the video being stabilized.
///     - progress: The current stabilization progress, in the range `0.0` to `1.0`.
///   - videoStabilizationSingleFileCompletionHandler: A closure that is called when a single video file finishes stabilization (success or failure).
///     - mediaFile: The imported media file model with updated stabilization status.
///     - success: Whether the stabilization succeeded for this file.
///   - videoStabilizationBatchProgressHandler: A closure that is called to report batch progress when stabilizing multiple video files.
///     - fileIndex: The zero-based index of the current file being processed in the batch.
///     - totalFileCount: The total number of files in the stabilization batch.
///   - videoStabilizationPhaseFinishHandler: A closure that is called when the entire video stabilization post-processing phase finishes.
///   - completionHandler: A closure that is called when the import operation completes.
///     - success: `true` if all requested files were downloaded successfully; otherwise `false`.
///     - mediaFiles: The successfully imported files. A post-processing failure falls back to the original file and is reported by the corresponding result model.
///     - error: An `NSError` object that describes the download or local-file error when `success` is `false`, or `nil` if the operation was successful.
func importMediaFiles(
    _ mediaFiles: [MediaFileInfoModel],
    dataChunkHandler: AIBudsMediaFileImportDataChunkHandler?,
    singleTransferStartingHandler: AIBudsMediaFileImportSingleTransferStartingHandler?,
    singleTransferCompletionHandler: AIBudsMediaFileImportSingleTransferCompletionHandler?,
    transferSpeedHandler: AIBudsMediaFileImportTransferSpeedHandler?,
    transferBatchProgressHandler: AIBudsMediaFileImportTransferBatchProgressHandler?,
    videoStabilizationPhaseBeginHandler: AIBudsVideoStabilizationPhaseBeginHandler?,
    videoStabilizationSingleFileProgressHandler: AIBudsVideoStabilizationProgressHandler?,
    videoStabilizationSingleFileCompletionHandler: AIBudsVideoStabilizationSingleFileCompletionHandler?,
    videoStabilizationBatchProgressHandler: AIBudsVideoStabilizationBatchProgressHandler?,
    videoStabilizationPhaseFinishHandler: AIBudsVideoStabilizationPhaseFinishHandler?,
    completionHandler: AIBudsMediaFileImportCompletionHandler?
)

/// Cancel media file import from the device or cancel active post-processing.
///
/// - Parameters:
///   - completion: Called when the operation completes.
///     - success: `true` if the operation was successful; otherwise `false`.
///     - statusCode: The status code returned by the device, or `nil` when unavailable.
///     - error: The operation error, or `nil` when successful.
func cancelMediaFileImport(_ completion: AIBudsStatusCodeCompletionHandler?)

/// Requests the device to delete a specific media file.
///
/// - Parameters:
///   - fileName: The name of the file to delete.
///   - completion: A closure that is called when the operation completes.
///     - success: `true` if the operation was successful; otherwise `false`.
///     - statusCode: The status code returned by the device. `nil` if the operation failed.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
func deleteMediaFile(
    _ fileName: String,
    completion: AIBudsStatusCodeCompletionHandler?
)

/// Requests the device to delete all media files.
///
/// - Parameters:
///   - completion: A closure that is called when the operation completes.
///     - success: `true` if the operation was successful; otherwise `false`.
///     - statusCode: The status code returned by the device. `nil` if the operation failed.
///     - error: An `NSError` object that describes the error that occurred, or `nil` if the operation was successful.
func deleteAllMediaFiles(_ completion: AIBudsStatusCodeCompletionHandler?)

Objective-C

/// Whether SDK-internal video stabilization is available for media file import.
@property (nonatomic, readonly) BOOL isVideoStabilizationAvailable;

/// Fetch media files info from the device.
///
/// - Parameters:
///   - configureHotspotStartingHandler: A block that is called when hotspot configuration starts.
///   - hotspotConfigureCompletionHandler: A block that is called when hotspot configuration completes.
///     - success: `YES` if the configuration succeeded; otherwise `NO`.
///     - error: The error that occurred, or `nil` if the operation was successful.
///   - enterFileTransferModeStartingHandler: A block that is called when file transfer mode entry starts.
///   - enterFileTransferModeCompletedHandler: A block that is called when file transfer mode entry completes.
///     - success: `YES` if entering file transfer mode succeeded; otherwise `NO`.
///     - error: The error that occurred, or `nil` if the operation was successful.
///   - waitingForHotspotOpenHandler: A block that is called while waiting for the device hotspot to open.
///   - connectDeviceHotspotStartingHandler: A block that is called when hotspot connection starts.
///     - ssid: The SSID of the device hotspot.
///   - deviceHotspotConnectCompletionHandler: A block that is called when hotspot connection completes.
///     - success: `YES` if the connection succeeded; otherwise `NO`.
///     - error: The error that occurred, or `nil` if the operation was successful.
///   - completionHandler: A block that is called when fetching media information completes.
///     - success: `YES` if the operation was successful; otherwise `NO`.
///     - mediaFiles: The media file info models to be imported.
///     - error: The error that occurred, or `nil` if the operation was successful.
- (void)fetchMediaFilesInfoWithConfigureHotspotStartingHandler:(AIBudsMediaFileImportConfigureHotspotStartingHandler _Nullable)configureHotspotStartingHandler
        hotspotConfigureCompletionHandler:(AIBudsMediaFileImportHotspotConfigureCompletionHandler _Nullable)hotspotConfigureCompletionHandler
        enterFileTransferModeStartingHandler:(AIBudsEnterMediaFileTransferModeStartingHandler _Nullable)enterFileTransferModeStartingHandler
        enterFileTransferModeCompletedHandler:(AIBudsEnterMediaFileTransferModeCompletionHandler _Nullable)enterFileTransferModeCompletedHandler
        waitingForHotspotOpenHandler:(AIBudsMediaFileImportStartingToWaitForHotspotOpenHandler _Nullable)waitingForHotspotOpenHandler
        connectDeviceHotspotStartingHandler:(AIBudsMediaFileImportConnectDeviceHotspotStartingHandler _Nullable)connectDeviceHotspotStartingHandler
        deviceHotspotConnectCompletionHandler:(AIBudsMediaFileImportDeviceHotspotConnectCompletionHandler _Nullable)deviceHotspotConnectCompletionHandler
        completionHandler:(AIBudsMediaFileImportFetchMediaFilesInfoCompletionHandler _Nullable)completionHandler;

/// Import media files from the device.
///
/// The import process consists of file transfer followed by an optional video
/// stabilization post-processing phase.
///
/// - Parameters:
///   - mediaFiles: The media file info models to import.
///   - dataChunkHandler: Returns the received chunk, task ID, file URL, total byte count, transferred byte count, and error.
///   - singleTransferStartingHandler: Returns the media file when an individual transfer starts.
///   - singleTransferCompletionHandler: Returns transfer success, the imported local result model, and error.
///   - transferSpeedHandler: Returns the current transfer speed in bytes per second.
///   - transferBatchProgressHandler: Returns the current file index and total file count.
///   - videoStabilizationPhaseBeginHandler: Called when video stabilization begins.
///   - videoStabilizationSingleFileProgressHandler: Returns the imported file and progress from `0.0` to `1.0`.
///   - videoStabilizationSingleFileCompletionHandler: Returns the updated imported file and stabilization success.
///   - videoStabilizationBatchProgressHandler: Returns the zero-based file index and total stabilization file count.
///   - videoStabilizationPhaseFinishHandler: Called when the stabilization phase finishes.
///   - completionHandler: Returns download success, successfully imported files, and a download or local-file error.
- (void)importMediaFiles:(NSArray<AIBudsMediaFileInfoModel *> * _Nonnull)mediaFiles
        dataChunkHandler:(AIBudsMediaFileImportDataChunkHandler _Nullable)dataChunkHandler
        singleTransferStartingHandler:(AIBudsMediaFileImportSingleTransferStartingHandler _Nullable)singleTransferStartingHandler
        singleTransferCompletionHandler:(AIBudsMediaFileImportSingleTransferCompletionHandler _Nullable)singleTransferCompletionHandler
        transferSpeedHandler:(AIBudsMediaFileImportTransferSpeedHandler _Nullable)transferSpeedHandler
        transferBatchProgressHandler:(AIBudsMediaFileImportTransferBatchProgressHandler _Nullable)transferBatchProgressHandler
        videoStabilizationPhaseBeginHandler:(AIBudsVideoStabilizationPhaseBeginHandler _Nullable)videoStabilizationPhaseBeginHandler
        videoStabilizationSingleFileProgressHandler:(AIBudsVideoStabilizationProgressHandler _Nullable)videoStabilizationSingleFileProgressHandler
        videoStabilizationSingleFileCompletionHandler:(AIBudsVideoStabilizationSingleFileCompletionHandler _Nullable)videoStabilizationSingleFileCompletionHandler
        videoStabilizationBatchProgressHandler:(AIBudsVideoStabilizationBatchProgressHandler _Nullable)videoStabilizationBatchProgressHandler
        videoStabilizationPhaseFinishHandler:(AIBudsVideoStabilizationPhaseFinishHandler _Nullable)videoStabilizationPhaseFinishHandler
        completionHandler:(AIBudsMediaFileImportCompletionHandler _Nullable)completionHandler;

/// Cancel media file import from the device or cancel active post-processing.
///
/// - Parameters:
///   - completion: Called when the operation completes.
///     - success: `YES` if the operation was successful; otherwise `NO`.
///     - statusCode: The status code returned by the device, or `nil` when unavailable.
///     - error: The operation error, or `nil` when successful.
- (void)cancelMediaFileImportWithCompletion:(AIBudsStatusCodeCompletionHandler _Nullable)completion;

/// Requests the device to delete a specific media file.
///
/// - Parameters:
///   - fileName: The name of the file to delete.
///   - completion: Returns success, an optional device status code, and an error.
- (void)deleteMediaFile:(NSString * _Nonnull)fileName
        completion:(AIBudsStatusCodeCompletionHandler _Nullable)completion;

/// Requests the device to delete all media files.
///
/// - Parameters:
///   - completion: Returns success, an optional device status code, and an error.
- (void)deleteAllMediaFilesWithCompletion:(AIBudsStatusCodeCompletionHandler _Nullable)completion;

Return Value

These members do not return operation results directly. Results arrive through their completion and progress handlers. fetchMediaFilesInfo supplies the MediaFileInfoModel values accepted by importMediaFiles; cancel and delete operations also supply an optional device status code.

Usage Examples

The examples follow the Demo's two-stage fetch-and-import flow. They keep each pipeline phase visible while leaving UI presentation to the host app.

Swift

guard let device = device as? DeviceMediaFileImportAPI else { return }

device.fetchMediaFilesInfo(
    configureHotspotStartingHandler: {
        print("Configuring hotspot")
    },
    hotspotConfigureCompletionHandler: { success, error in
        print(success ? "Hotspot configured" : "Configuration failed: \(error?.localizedDescription ?? "Unknown error")")
    },
    enterFileTransferModeStartingHandler: {
        print("Entering file transfer mode")
    },
    enterFileTransferModeCompletedHandler: { success, error in
        print(success ? "File transfer mode ready" : "Transfer mode failed: \(error?.localizedDescription ?? "Unknown error")")
    },
    waitingForHotspotOpenHandler: {
        print("Waiting for the device hotspot")
    },
    connectDeviceHotspotStartingHandler: { ssid in
        print("Connecting to \(ssid)")
    },
    deviceHotspotConnectCompletionHandler: { success, error in
        print(success ? "Device hotspot connected" : "Connection failed: \(error?.localizedDescription ?? "Unknown error")")
    },
    completionHandler: { success, mediaFiles, error in
        guard success, !mediaFiles.isEmpty else {
            print(error?.localizedDescription ?? "No media available")
            return
        }

        device.importMediaFiles(
            mediaFiles,
            dataChunkHandler: { _, taskID, fileURL, fileSize, transferredSize, error in
                guard error == nil, fileSize > 0 else { return }
                let progress = Double(transferredSize) / Double(fileSize)
                print("\(taskID): \(fileURL) \(Int(progress * 100))%")
            },
            singleTransferStartingHandler: { mediaFile in
                print("Starting \(mediaFile.fileName)")
            },
            singleTransferCompletionHandler: { success, importedFile, error in
                print(success ? "Downloaded \(importedFile.metadata.fileName)" : "Download failed: \(error?.localizedDescription ?? "Unknown error")")
            },
            transferSpeedHandler: { bytesPerSecond in
                print("Transfer speed: \(bytesPerSecond) B/s")
            },
            transferBatchProgressHandler: { index, total in
                print("Transfer file \(index + 1) of \(total)")
            },
            videoStabilizationPhaseBeginHandler: {
                print("Video stabilization started")
            },
            videoStabilizationSingleFileProgressHandler: { file, progress in
                print("Stabilizing \(file.metadata.fileName): \(Int(progress * 100))%")
            },
            videoStabilizationSingleFileCompletionHandler: { file, success in
                print("Stabilization \(success ? "completed" : "failed") for \(file.metadata.fileName)")
            },
            videoStabilizationBatchProgressHandler: { index, total in
                print("Stabilization file \(index + 1) of \(total)")
            },
            videoStabilizationPhaseFinishHandler: {
                print("Video stabilization finished")
            },
            completionHandler: { success, importedFiles, error in
                print(success ? "Imported \(importedFiles.count) files" : (error?.localizedDescription ?? "Import failed"))
            }
        )
    }
)

Objective-C

id<AIBudsDeviceMediaFileImportAPI> device =
    (id<AIBudsDeviceMediaFileImportAPI>)self.device;

if (![device conformsToProtocol:@protocol(AIBudsDeviceMediaFileImportAPI)]) {
    return;
}

[device fetchMediaFilesInfoWithConfigureHotspotStartingHandler:^{
    NSLog(@"Configuring hotspot");
} hotspotConfigureCompletionHandler:^(BOOL success, NSError * _Nullable error) {
    NSLog(@"%@", success ? @"Hotspot configured" : error.localizedDescription);
} enterFileTransferModeStartingHandler:^{
    NSLog(@"Entering file transfer mode");
} enterFileTransferModeCompletedHandler:^(BOOL success, NSError * _Nullable error) {
    NSLog(@"%@", success ? @"File transfer mode ready" : error.localizedDescription);
} waitingForHotspotOpenHandler:^{
    NSLog(@"Waiting for the device hotspot");
} connectDeviceHotspotStartingHandler:^(NSString * _Nonnull ssid) {
    NSLog(@"Connecting to %@", ssid);
} deviceHotspotConnectCompletionHandler:^(BOOL success, NSError * _Nullable error) {
    NSLog(@"%@", success ? @"Device hotspot connected" : error.localizedDescription);
} completionHandler:^(BOOL success,
                      NSArray<AIBudsMediaFileInfoModel *> * _Nonnull mediaFiles,
                      NSError * _Nullable error) {
    if (!success || mediaFiles.count == 0) {
        NSLog(@"Fetch failed: %@", error.localizedDescription);
        return;
    }

    [device importMediaFiles:mediaFiles
        dataChunkHandler:^(NSData * _Nullable dataChunk,
                           NSString * _Nonnull taskId,
                           NSString * _Nonnull fileUrl,
                           uint64_t fileSize,
                           uint64_t transferredSize,
                           NSError * _Nullable chunkError) {
            if (chunkError == nil && fileSize > 0) {
                double progress = (double)transferredSize / (double)fileSize;
                NSLog(@"%@: %@ %.0f%%", taskId, fileUrl, progress * 100.0);
            }
        }
        singleTransferStartingHandler:^(AIBudsMediaFileInfoModel * _Nonnull mediaFile) {
            NSLog(@"Starting %@", mediaFile.fileName);
        }
        singleTransferCompletionHandler:^(BOOL transferSuccess,
                                          AIBudsImportedMediaFileModel * _Nonnull importedFile,
                                          NSError * _Nullable transferError) {
            NSLog(@"%@", transferSuccess ? @"Download completed" : transferError.localizedDescription);
        }
        transferSpeedHandler:^(uint64_t bytesPerSecond) {
            NSLog(@"Transfer speed: %llu B/s", bytesPerSecond);
        }
        transferBatchProgressHandler:^(NSInteger index, NSInteger total) {
            NSLog(@"Transfer file %ld of %ld", (long)index + 1, (long)total);
        }
        videoStabilizationPhaseBeginHandler:^{
            NSLog(@"Video stabilization started");
        }
        videoStabilizationSingleFileProgressHandler:^(AIBudsImportedMediaFileModel * _Nonnull file,
                                                      double progress) {
            NSLog(@"Stabilizing %@: %.0f%%", file.metadata.fileName, progress * 100.0);
        }
        videoStabilizationSingleFileCompletionHandler:^(AIBudsImportedMediaFileModel * _Nonnull file,
                                                        BOOL stabilizationSuccess) {
            NSLog(@"Stabilization %@ for %@",
                  stabilizationSuccess ? @"completed" : @"failed",
                  file.metadata.fileName);
        }
        videoStabilizationBatchProgressHandler:^(NSInteger index, NSInteger total) {
            NSLog(@"Stabilization file %ld of %ld", (long)index + 1, (long)total);
        }
        videoStabilizationPhaseFinishHandler:^{
            NSLog(@"Video stabilization finished");
        }
        completionHandler:^(BOOL importSuccess,
                            NSArray<AIBudsImportedMediaFileModel *> * _Nonnull importedFiles,
                            NSError * _Nullable importError) {
            if (importSuccess) {
                NSLog(@"Imported %lu files", (unsigned long)importedFiles.count);
            } else {
                NSLog(@"Import failed: %@", importError.localizedDescription);
            }
        }];
}];

Cancel or Delete Media

Swift

device.cancelMediaFileImport { success, statusCode, error in
    print(success ? "Import cancelled" : (error?.localizedDescription ?? "Cancel failed"))
}

device.deleteMediaFile("example.mp4") { success, statusCode, error in
    print(success ? "File deleted" : (error?.localizedDescription ?? "Delete failed"))
}

device.deleteAllMediaFiles { success, statusCode, error in
    print(success ? "All media deleted" : (error?.localizedDescription ?? "Delete failed"))
}

Objective-C

[device cancelMediaFileImportWithCompletion:^(BOOL success, NSNumber * _Nullable statusCode, NSError * _Nullable error) {
    NSLog(@"%@", success ? @"Import cancelled" : error.localizedDescription);
}];

[device deleteMediaFile:@"example.mp4"
              completion:^(BOOL success, NSNumber * _Nullable statusCode, NSError * _Nullable error) {
    NSLog(@"%@", success ? @"File deleted" : error.localizedDescription);
}];

[device deleteAllMediaFilesWithCompletion:^(BOOL success, NSNumber * _Nullable statusCode, NSError * _Nullable error) {
    NSLog(@"%@", success ? @"All media deleted" : error.localizedDescription);
}];

Error Handling

Treat hotspot configuration, transfer-mode entry, hotspot connection, file download, and stabilization as separate phases in the UI. A stabilization failure does not necessarily mean the original download failed; inspect each imported result model and use its original local URL when the playable stabilized URL is unavailable.

Do not infer undocumented status-code meanings. For cancel and delete operations, use success and error as the primary result until the SDK publishes the status-code contract.

Best Practices

Check protocol conformance before starting the pipeline.
Pass the MediaFileInfoModel objects returned by fetchMediaFilesInfo to importMediaFiles; do not replace them with custom IDs.
Present hotspot configuration, transfer-mode entry, hotspot connection, download, and stabilization as distinct UI phases.
Dispatch UI updates to the main queue because progress callbacks may arrive on another queue.
Copy imported files from temporary SDK locations into app-managed persistent storage when they must survive future sessions.
Prevent duplicate import requests while a transfer is active and expose cancellation when appropriate.

Notes

Import remains available when isVideoStabilizationAvailable is false; only SDK-managed stabilization is unavailable.
A stabilization failure can still leave a usable original local file. Inspect each ImportedMediaFileModel.
deleteMediaFile expects the device file name, not an app-local file URL.

AIBuds SDK documentation · Full documentation · API Reference

AIBuds SDK iOS Wiki

Introduction
- Overview
Getting Started
Core Concepts
Core Features
- Basic Features
  - Overview
  - Factory Reset
  - Format Media Storage
  - Power Off
  - Unpair Device
- Device Info
  - Overview
  - Get Device Details
  - Sync Device Time
  - Set Device Time
  - Set Device Language
  - Query Storage Information
  - Query Media Count
- Find Device
  - Overview
  - Find Device
  - Stop Find Device
  - Report iPhone Found
- Physical Operations
  - Overview
  - Operations and Functions
  - View Operation Mapping
  - Assign Functions
- Work Mode
  - Overview
  - Get Work Mode
- Work Status
  - Overview
  - Work States
  - Get Work Status
- Wear Detection
  - Overview
  - View Wear Detection Capability
  - View Wear Detection State
  - Set Wear Detection
- Volume Control
  - Overview
  - View Volume Capability and Levels
  - Set Volume
- Music Control
  - Overview
  - Control Music Playback
- TWS
  - Overview
  - Identify a TWS Device
  - View TWS Connection State
- Equalizer
  - Overview
  - Set Equalizer
- ANC
  - Overview
  - Active Noise Cancellation
- Audio
  - Overview
  - Standard Recording
  - AI Audio Recording
  - Maximum Recording Duration
- Camera
  - Overview
  - View Camera Firmware Version
  - Maximum Video Recording Duration
  - Take Photos
  - Record Video
- Remote Camera
  - Overview
  - Handle Remote Shutter
- File Import
  - Overview
  - Import Media Files
- Teleprompter
  - Overview
  - Teleprompter Content and Settings
- Segment Navigation
  - Overview
  - Send Navigation Information
  - Navigation Maneuvers
  - Navigation Alerts
- Live Streaming
  - Overview
  - RTSP Live Streaming
  - JPEG Image Live Streaming
  - Stop Live Streaming
- Device Applications
  - Overview
  - Manage Device Applications
- OTA
  - Overview
  - Device Firmware Update
- Camera OTA
  - Overview
  - Camera Firmware Update
Service Auth
AI Services
- Overview
- Events & Intents
  - AI Session Events
  - AI Intents
- Select AI Provider
- AI Audio Recording
- Streaming ASR
- Text to Speech
- AI Summary
- AI Text Translation
- Simultaneous Interpretation
- Conversation Translation
- AI Chat
- Image Generation
- AI Asking
Voice Assistant
Logging
Advanced Topics
Releases
- Releases
- Changelog
Troubleshooting
- Common Issues
- Issue Report Template

Core File Import Import

Import Media Files

Prerequisites

API Reference

Framework

Import

Swift

Objective-C

Protocol Symbols

Declarations

Swift

Objective-C

Return Value

Usage Examples

Swift

Objective-C

Cancel or Delete Media

Swift

Objective-C

Error Handling

Best Practices

Notes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!