MPMediaPlayerController Error: timed out waiting for fence barrier from com.apple.MusicUIService

Resolving 'timed out waiting for fence barrier' in MPMediaPlayerController on iOS 7

Troubleshoot and fix the common 'timed out waiting for fence barrier from com.apple.MusicUIService' error when using MPMediaPlayerController in iOS 7 applications.

Developers working with MPMediaPickerController on iOS 7 often encounter a cryptic error message in the console: "timed out waiting for fence barrier from com.apple.MusicUIService". This error typically appears when attempting to present the media picker, leading to UI freezes or crashes. While the message itself is not directly actionable, it points to an underlying issue with how the media picker is being presented or dismissed, particularly concerning threading and view controller lifecycle.

Understanding the 'Fence Barrier' Error

The 'fence barrier' message is an internal system log indicating that a process (in this case, com.apple.MusicUIService, which handles the media picker UI) is waiting for a synchronization point that isn't being met. This often happens when UI updates or view controller presentations are not performed on the main thread, or when there's a conflict in the view hierarchy during presentation or dismissal. On iOS 7, MPMediaPickerController can be particularly sensitive to these timing and threading issues.

sequenceDiagram
    participant App as Your App
    participant MusicUIService as com.apple.MusicUIService
    App->>MusicUIService: Present MPMediaPickerController
    Note over MusicUIService: Starts UI rendering
    MusicUIService-->>App: Awaits 'fence barrier' signal
    alt Correct Presentation
        App->>MusicUIService: UI updates on main thread
        MusicUIService->>App: UI presented successfully
    else Incorrect Presentation (e.g., background thread)
        App->>MusicUIService: UI updates on background thread
        MusicUIService--xApp: 'timed out waiting for fence barrier'
        Note over App,MusicUIService: UI freeze/crash
    end

Sequence diagram illustrating the 'fence barrier' timeout scenario.

Common Causes and Solutions

The primary cause for this error is almost always related to presenting or dismissing the MPMediaPickerController from a background thread or in a way that conflicts with the main thread's UI operations. Ensuring all UI-related tasks are on the main thread is crucial.

Implementing a Robust Presentation Method

To reliably present MPMediaPickerController and avoid the 'fence barrier' error, ensure that the presentation is enqueued on the main thread. The following code snippet demonstrates the correct approach using dispatch_async.

- (void)presentMediaPicker {
    MPMediaPickerController *mediaPicker = [[MPMediaPickerController alloc] initWithMediaTypes:MPMediaTypeAnyAudio];
    mediaPicker.delegate = self;
    mediaPicker.allowsPickingMultipleItems = NO;
    mediaPicker.prompt = @"Select an item";

    // Ensure presentation happens on the main thread
    dispatch_async(dispatch_get_main_queue(), ^{
        [self presentViewController:mediaPicker animated:YES completion:nil];
    });
}

// MPMediaPickerControllerDelegate methods
- (void)mediaPicker: (MPMediaPickerController *)mediaPicker didPickMediaItems: (MPMediaItemCollection *)mediaItemCollection {
    // Dismiss the media picker on the main thread
    dispatch_async(dispatch_get_main_queue(), ^{
        [self dismissViewControllerAnimated:YES completion:nil];
    });
    // Handle selected media items
}

- (void)mediaPickerDidCancel:(MPMediaPickerController *)mediaPicker {
    // Dismiss the media picker on the main thread
    dispatch_async(dispatch_get_main_queue(), ^{
        [self dismissViewControllerAnimated:YES completion:nil];
    });
}

Correctly presenting and dismissing MPMediaPickerController on the main thread.

In this example, both the presentation of mediaPicker and its dismissal (within the delegate methods) are explicitly wrapped in dispatch_async(dispatch_get_main_queue(), ^{ ... });. This guarantees that these UI operations are executed on the main thread, preventing the system from timing out while waiting for UI synchronization.