CODEWITHSUNDEEP
ios8alassetslibraryphotosframeworkphasset
Paul Cezanne
Paul Cezanne

Reputation: 8741

NSURL from PHAsset

I'm converting our app over to use the Photos Framework of iOS8, the ALAsset framework is clearly a second class citizen under iOS8.

I'm having a problem is that our architecture really wants an NSURL that represents the location of the media on "disk." We use this to upload the media to our servers for further processing.

This was easy with ALAsset:

    ALAssetRepresentation *rep = [asset defaultRepresentation];
    self.originalVideo = rep.url;

But I'm just not seeing this ability in PHAsset. I guess I can call:

    imageManager.requestImageDataForAsset

and then write it out to a temp spot in the file system but that seems awfully heavyweight and wasteful, not to mention potentially slow.

Is there a way to get this or am I going to have refactor more of my app to only use NSURLs for iOS7 and some other method for iOS8?

Upvotes: 41

Views: 28666

Answers (10)

Lizhen Hu
Lizhen Hu

Reputation: 944

Here's a handy PHAsset category:

@implementation PHAsset (Utils)

- (NSURL *)fileURL {
    __block NSURL *url = nil;

    switch (self.mediaType) {
        case PHAssetMediaTypeImage: {
            PHImageRequestOptions *options = [[PHImageRequestOptions alloc] init];
            options.synchronous = YES;
            [PHImageManager.defaultManager requestImageDataForAsset:self
                                                            options:options
                                                      resultHandler:^(NSData *imageData, NSString *dataUTI, UIImageOrientation orientation, NSDictionary *info) {
                                                          url = info[@"PHImageFileURLKey"];
                                                      }];
            break;
        }
        case PHAssetMediaTypeVideo: {
            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
            [PHImageManager.defaultManager requestAVAssetForVideo:self
                                                          options:nil
                                                    resultHandler:^(AVAsset *asset, AVAudioMix *audioMix, NSDictionary *info) {
                                                        if ([asset isKindOfClass:AVURLAsset.class]) {
                                                            url = [(AVURLAsset *)asset URL];
                                                        }
                                                        dispatch_semaphore_signal(semaphore);
                                                    }];
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            break;
        }
        default:
            break;
    }
    return url;
}

@end

Upvotes: 1

Oliver Hu
Oliver Hu

Reputation: 148

Just want to post the hidden gem from a comment from @jlw

@rishu1992 For slo-mo videos, grab the AVComposition's AVCompositionTrack (of mediaType AVMediaTypeVideo), grab its first segment (of type AVCompositionTrackSegment), and then access its sourceURL property. – jlw Aug 25 '15 at 11:52

Upvotes: 2

Sazzad Hissain Khan
Sazzad Hissain Khan

Reputation: 40166

In speking of url from PHAsset, I had once prepared a util func on Swift 2 (although only for playing videos from PHAsset). Sharing it in this answer, might help someone.

static func playVideo (view:UIViewController, asset:PHAsset)

Please check this Answer

Upvotes: 1

Gamec
Gamec

Reputation: 414

I had similiar problem with video files, what worked for me was:

NSString* assetID = [asset.localIdentifier substringToIndex:(asset.localIdentifier.length - 7)];
NSURL* videoURL = [NSURL URLWithString:[NSString stringWithFormat:@"assets-library://asset/asset.mov?id=%@&ext=mov", assetID]];

Where asset is PHAsset.

Upvotes: 0

desmond
desmond

Reputation: 560

All the above solutions won't work for slow-motion videos. A solution that I found handles all video asset types is this:

func createFileURLFromVideoPHAsset(asset: PHAsset, destinationURL: NSURL) {
    PHCachingImageManager().requestAVAssetForVideo(self, options: nil) { avAsset, _, _ in
        let exportSession = AVAssetExportSession(asset: avAsset!, presetName: AVAssetExportPresetHighestQuality)!
        exportSession.outputFileType = AVFileTypeMPEG4
        exportSession.outputURL = destinationURL

        exportSession.exportAsynchronouslyWithCompletionHandler {
            guard exportSession.error == nil else {
                log.error("Error exporting video asset: \(exportSession.error)")
                return
            }

            // It worked! You can find your file at: destinationURL
        }
    }
}

Upvotes: 5

Alfie Hanssen
Alfie Hanssen

Reputation: 17094

See this answer here.

And this one here.

In my experience you'll need to first export the asset to disk in order to get a fully accessible / reliable URL.

The answers linked to above describe how to do this.

Upvotes: 3

Adam Studenic
Adam Studenic

Reputation: 2125

SWIFT 2.0 version This function returns NSURL from PHAsset (both image and video)

func getAssetUrl(mPhasset : PHAsset, completionHandler : ((responseURL : NSURL?) -> Void)){

    if mPhasset.mediaType == .Image {
        let options: PHContentEditingInputRequestOptions = PHContentEditingInputRequestOptions()
        options.canHandleAdjustmentData = {(adjustmeta: PHAdjustmentData) -> Bool in
            return true
        }
        mPhasset.requestContentEditingInputWithOptions(options, completionHandler: {(contentEditingInput: PHContentEditingInput?, info: [NSObject : AnyObject]) -> Void in
            completionHandler(responseURL : contentEditingInput!.fullSizeImageURL)
        })
    } else if mPhasset.mediaType == .Video {
        let options: PHVideoRequestOptions = PHVideoRequestOptions()
        options.version = .Original
        PHImageManager.defaultManager().requestAVAssetForVideo(mPhasset, options: options, resultHandler: {(asset: AVAsset?, audioMix: AVAudioMix?, info: [NSObject : AnyObject]?) -> Void in

            if let urlAsset = asset as? AVURLAsset {
                let localVideoUrl : NSURL = urlAsset.URL
                completionHandler(responseURL : localVideoUrl)
            } else {
                completionHandler(responseURL : nil)
            }
        })
    }

}

Upvotes: 19

bcattle
bcattle

Reputation: 12819

Use the new localIdentifier property of PHObject. (PHAsset inherits from this).

It provides similar functionality to an ALAsset URL, namely that you can load assets by calling the method 

+[PHAsset fetchAssetsWithLocalIdentifiers:identifiers options:options]

Upvotes: 9

Sahil
Sahil

Reputation: 1268

If you have a PHAsset, you can get the url for said asset like this:

[asset requestContentEditingInputWithOptions:editOptions
                           completionHandler:^(PHContentEditingInput *contentEditingInput, NSDictionary *info) {
    NSURL *imageURL = contentEditingInput.fullSizeImageURL;
}];

Upvotes: 9

jlw
jlw

Reputation: 3216

If you use [imageManager requestAVAssetForVideo...], it'll return an AVAsset. That AVAsset is actually an AVURLAsset, so if you cast it, you can access it's -url property.

I'm not sure if you can create a new asset out of this, but it does give you the location.

Upvotes: 25

Related Questions