Keep MKMapSnapshotter as NSData in memory - Swift

问题:

I'm trying to take a screenshot of my MKMapView. I usually achieved this using the below code in Objective C.

I'm wondering how I would keep the NSData object in memory, rather than saving the image, and then reading from it straight away.

I'm also wondering how this could be written in Swift - In particular, the completion handler part. I've looked at the docs - but unsure of syntax:https://developer.apple.com/library/prerelease/iOS/documentation/MapKit/Reference/MKMapSnapshotter_class/index.html#//apple_ref/c/tdef/MKMapSnapshotCompletionHandler

MKMapSnapshotOptions *options = [[MKMapSnapshotOptions alloc] init];
options.region = self.mapView.region;
options.size = self.mapView.frame.size;
options.scale = [[UIScreen mainScreen] scale];

NSURL *fileURL = [NSURL fileURLWithPath:@"path/to/snapshot.png"];

MKMapSnapshotter *snapshotter = [[MKMapSnapshotter alloc] initWithOptions:options];
[snapshotter startWithCompletionHandler:^(MKMapSnapshot *snapshot, NSError *error) {
    if (error) {
        NSLog(@"[Error] %@", error);
        return;
    }

    UIImage *image = snapshot.image;
    NSData *data = UIImagePNGRepresentation(image);
    [data writeToURL:fileURL atomically:YES];
}];

回答1:

In terms of "keeping" it in memory, you could return the NSData via an Objective-C completion block (or Swift closure). From there, you can pass the NSData to another method or save it in a class property.

For example, in Objective-C:

/** Request NSData of PNG representation of map snapshot.
 *
 * @param mapView The MKMapView for which we're capturing the snapshot
 * @param completion The completion block that will be called when the asynchronous snapshot is done. This takes two parameters, the resulting NSData upon success and an NSError if there was an error.
 */

- (void)requestSnapshotDataForMapView:(MKMapView *)mapView completion:(void (^)(NSData *data, NSError *error))completion
{
    MKMapSnapshotOptions *options = [[MKMapSnapshotOptions alloc] init];
    options.region = mapView.region;
    options.size = mapView.frame.size;
    options.scale = [[UIScreen mainScreen] scale];

    MKMapSnapshotter *snapshotter = [[MKMapSnapshotter alloc] initWithOptions:options];
    [snapshotter startWithCompletionHandler:^(MKMapSnapshot *snapshot, NSError *error) {
        if (error) {
            if (completion) {
                completion(nil, error);
            }
            return;
        }

        UIImage *image = snapshot.image;
        NSData *data = UIImagePNGRepresentation(image);
        if (completion) {
            completion(data, nil);
        }
    }];
}

- (IBAction)didTouchUpInsideButton:(id)sender
{
    [self requestSnapshotDataForMapView:self.mapView completion:^(NSData *data, NSError *error) {
        if (error) {
            NSLog(@"requestSnapshotDataForMapView error: %@", error);
            return;
        }

        // do whatever you want with the `data` parameter here, for example,
        // if you had some `@property (nonatomic, strong) NSData *snapshotData;`,
        // you might do:
        //
        // self.snapshotData = data

        // now initiate the next step of the process in which you're presumably
        // going to use the `data` provided by this block.
    }];
}

The Swift equivalent is:

/// Request NSData of PNG representation of map snapshot.
///
/// - parameter mapView:     The MKMapView for which we're capturing the snapshot
/// - parameter completion:  The closure that will be called when the asynchronous snapshot is done. This takes two parameters, the resulting NSData upon success and an NSError if there was an error.

func requestSnapshotData(mapView: MKMapView, completion: (NSData?, NSError?) -> ()) {
    let options = MKMapSnapshotOptions()
    options.region = mapView.region
    options.size = mapView.frame.size
    options.scale = UIScreen.mainScreen().scale

    let snapshotter = MKMapSnapshotter(options: options)
    snapshotter.startWithCompletionHandler() { snapshot, error in
        guard snapshot != nil else {
            completion(nil, error)
            return
        }

        let image = snapshot!.image
        let data = UIImagePNGRepresentation(image)
        completion(data, nil)
    }
}

@IBAction func didTouchUpInsideButton(sender: AnyObject) {
    requestSnapshotData(mapView) { data, error in
        guard data != nil else  {
            print("requestSnapshotData error: \(error)")
            return
        }

        // do whatever you want with the `data` parameter here, for example,
        // if you had some `var snapshotData: NSData?` class property, you might do:
        //
        // self.snapshotData = data

        // now initiate the next step of the process in which you're presumably
        // going to use the `data` provided by this closure.
    }
}

Frankly, if you're trying to use the UIImage somewhere else, I might change these block/closure parameters to use the UIImage rather than the NSData, but hopefully this illustrates the idea.