899 lines
45 KiB
Objective-C
899 lines
45 KiB
Objective-C
//
|
|
// TUIChatMediaDataProvider.m
|
|
// TUIChat
|
|
//
|
|
// Created by harvy on 2022/12/20.
|
|
// Copyright © 2023 Tencent. All rights reserved.
|
|
//
|
|
|
|
#import "TUIChatMediaDataProvider.h"
|
|
|
|
#import <AssetsLibrary/AssetsLibrary.h>
|
|
#import <MobileCoreServices/MobileCoreServices.h>
|
|
#import <Photos/Photos.h>
|
|
#import <PhotosUI/PhotosUI.h>
|
|
#import <SDWebImage/SDWebImage.h>
|
|
|
|
#import <TIMCommon/TIMDefine.h>
|
|
#import <TIMCommon/TUIUserAuthorizationCenter.h>
|
|
#import <TIMCommon/NSTimer+TUISafe.h>
|
|
#import <TUICore/TUITool.h>
|
|
#import <TUICore/TUICore.h>
|
|
#import "TUICameraViewController.h"
|
|
#import "TUIChatConfig.h"
|
|
#import "AlbumPicker.h"
|
|
#import "MultimediaRecorder.h"
|
|
#define kTUIChatMediaSelectImageMax 9
|
|
@interface TUIChatMediaDataProvider () <PHPickerViewControllerDelegate,
|
|
UINavigationControllerDelegate,
|
|
UIImagePickerControllerDelegate,
|
|
UIDocumentPickerDelegate,
|
|
TUICameraViewControllerDelegate>
|
|
|
|
@end
|
|
|
|
@implementation TUIChatMediaDataProvider
|
|
|
|
#pragma mark - Public API
|
|
- (void)selectPhoto {
|
|
if ([AlbumPicker sharedInstance].advancedAlbumPicker) {
|
|
__weak typeof(self) weakSelf = self;
|
|
__strong typeof(weakSelf.listener) strongListener = weakSelf.listener;
|
|
[[AlbumPicker sharedInstance].advancedAlbumPicker pickMediaWithCaller:self.presentViewController originalMediaPicked:^(NSDictionary *param) {
|
|
if (param) {
|
|
NSString * type = param[@"type"];
|
|
if ([type isEqualToString:@"image"]) {
|
|
// image do nothing
|
|
}
|
|
else if ([type isEqualToString:@"video"]) {
|
|
TUIMessageCellData *placeHolderCellData = param[@"placeHolderCellData"];
|
|
if ([strongListener respondsToSelector:@selector(sendPlaceHolderUIMessage:)]) {
|
|
[strongListener sendPlaceHolderUIMessage:placeHolderCellData];
|
|
}
|
|
TUIChatMediaTask * task = [[TUIChatMediaTask alloc] init];
|
|
task.placeHolderCellData = placeHolderCellData;
|
|
task.msgID = placeHolderCellData.msgID;
|
|
task.conversationID = weakSelf.conversationID;
|
|
if (placeHolderCellData.msgID.length > 0) {
|
|
[TUIChatMediaSendingManager.sharedInstance addMediaTask: task forKey:placeHolderCellData.msgID];
|
|
}
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
}
|
|
} progressCallback:^(NSDictionary *param) {
|
|
NSLog(@"%@,strongListener:%@",param,strongListener);
|
|
} finishedCallback:^(NSDictionary *param) {
|
|
if (param) {
|
|
V2TIMMessage * message = param[@"message"];
|
|
NSString * type = param[@"type"];
|
|
if ([type isEqualToString:@"image"]) {
|
|
if ([strongListener respondsToSelector:@selector(sendMessage:placeHolderCellData:)]) {
|
|
[strongListener sendMessage:message placeHolderCellData:nil];
|
|
}
|
|
}
|
|
else if ([type isEqualToString:@"video"]) {
|
|
TUIMessageCellData *placeHolderCellData = param[@"placeHolderCellData"];
|
|
if (placeHolderCellData.msgID.length > 0) {
|
|
[TUIChatMediaSendingManager.sharedInstance removeMediaTaskForKey:placeHolderCellData.msgID];
|
|
}
|
|
BOOL canSendByCurrentPage = NO;
|
|
for (id<TUIChatMediaDataListener> currentVC in TUIChatMediaSendingManager.sharedInstance.mediaSendingControllers) {
|
|
if ([currentVC.currentConversationID isEqualToString:self.conversationID]&&
|
|
[currentVC respondsToSelector:@selector(sendMessage:placeHolderCellData:)]) {
|
|
if (currentVC.isPageAppears) {
|
|
[currentVC sendMessage:message placeHolderCellData:placeHolderCellData];
|
|
canSendByCurrentPage = YES;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!canSendByCurrentPage) {
|
|
if ([strongListener respondsToSelector:@selector(sendMessage:placeHolderCellData:)]) {
|
|
[strongListener sendMessage:message placeHolderCellData:placeHolderCellData];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
}
|
|
}];
|
|
}
|
|
else {
|
|
//defalut AlbumPicker
|
|
[self _selectPhoto];
|
|
}
|
|
}
|
|
|
|
- (void)_selectPhoto {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
if (@available(iOS 14.0, *)) {
|
|
PHPickerConfiguration *configuration = [[PHPickerConfiguration alloc] init];
|
|
configuration.filter = [PHPickerFilter anyFilterMatchingSubfilters:@[ [PHPickerFilter imagesFilter], [PHPickerFilter videosFilter] ]];
|
|
configuration.selectionLimit = kTUIChatMediaSelectImageMax;
|
|
PHPickerViewController *picker = [[PHPickerViewController alloc] initWithConfiguration:configuration];
|
|
picker.delegate = self;
|
|
picker.modalPresentationStyle = UIModalPresentationFullScreen;
|
|
picker.view.backgroundColor = [UIColor whiteColor];
|
|
[self.presentViewController presentViewController:picker animated:YES completion:nil];
|
|
} else {
|
|
if ([UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypePhotoLibrary]) {
|
|
UIImagePickerController *picker = [[UIImagePickerController alloc] init];
|
|
picker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
|
|
picker.mediaTypes = [UIImagePickerController availableMediaTypesForSourceType:UIImagePickerControllerSourceTypePhotoLibrary];
|
|
picker.delegate = self;
|
|
[self.presentViewController presentViewController:picker animated:YES completion:nil];
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
- (void)takePicture {
|
|
if ([MultimediaRecorder sharedInstance].advancedVideoRecorder) {
|
|
[[MultimediaRecorder sharedInstance].advancedVideoRecorder takePhoneWithCaller:self.presentViewController successBlock:^(NSURL * _Nonnull uri) {
|
|
NSData *imageData = [NSData dataWithContentsOfURL:uri];
|
|
UIImage *photo = [UIImage imageWithData:imageData];
|
|
NSString *path = [TUIKit_Image_Path stringByAppendingString:[TUITool genImageName:nil]];
|
|
[[NSFileManager defaultManager] createFileAtPath:path
|
|
contents:UIImagePNGRepresentation(photo) attributes:nil];
|
|
if ([self.listener respondsToSelector:@selector(onProvideImage:)]) {
|
|
[self.listener onProvideImage:path];
|
|
}
|
|
} failureBlock:^(NSInteger errorCode, NSString * _Nonnull errorMessage) {
|
|
|
|
}];
|
|
}
|
|
else {
|
|
//defalut PhotoCamera
|
|
[self _takePicture];
|
|
}
|
|
}
|
|
- (void)_takePicture {
|
|
__weak typeof(self) weakSelf = self;
|
|
void (^actionBlock)(void) = ^(void) {
|
|
TUICameraViewController *vc = [[TUICameraViewController alloc] init];
|
|
vc.type = TUICameraMediaTypePhoto;
|
|
vc.delegate = weakSelf;
|
|
if (weakSelf.presentViewController.navigationController) {
|
|
[weakSelf.presentViewController.navigationController pushViewController:vc animated:YES];
|
|
} else {
|
|
[weakSelf.presentViewController presentViewController:vc animated:YES completion:nil];
|
|
}
|
|
};
|
|
if ([TUIUserAuthorizationCenter isEnableCameraAuthorization]) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
actionBlock();
|
|
});
|
|
} else {
|
|
if (![TUIUserAuthorizationCenter isEnableCameraAuthorization]) {
|
|
[TUIUserAuthorizationCenter cameraStateActionWithPopCompletion:^{
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
actionBlock();
|
|
});
|
|
}];
|
|
};
|
|
}
|
|
}
|
|
|
|
- (void)executeBlockWithMicroAndCameraAuth:(void(^)(void))block{
|
|
if ([TUIUserAuthorizationCenter isEnableMicroAuthorization] && [TUIUserAuthorizationCenter isEnableCameraAuthorization]) {
|
|
dispatch_async(dispatch_get_main_queue(), block);
|
|
} else {
|
|
if (![TUIUserAuthorizationCenter isEnableMicroAuthorization]) {
|
|
[TUIUserAuthorizationCenter microStateActionWithPopCompletion:^{
|
|
if ([TUIUserAuthorizationCenter isEnableCameraAuthorization]) {
|
|
dispatch_async(dispatch_get_main_queue(), block);
|
|
}
|
|
}];
|
|
}
|
|
if (![TUIUserAuthorizationCenter isEnableCameraAuthorization]) {
|
|
[TUIUserAuthorizationCenter cameraStateActionWithPopCompletion:^{
|
|
if ([TUIUserAuthorizationCenter isEnableMicroAuthorization]) {
|
|
dispatch_async(dispatch_get_main_queue(), block);
|
|
}
|
|
}];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)takeVideo {
|
|
if ([MultimediaRecorder sharedInstance].advancedVideoRecorder) {
|
|
[[MultimediaRecorder sharedInstance].advancedVideoRecorder recordVideoWithCaller:self.presentViewController successBlock:^(NSURL * _Nonnull uri) {
|
|
if (uri) {
|
|
if ([uri.pathExtension.lowercaseString isEqualToString:@"mp4"]) {
|
|
[self handleVideoPick:YES message:nil videoUrl:uri];
|
|
return;
|
|
}
|
|
else if ([self isImageURL:uri]){
|
|
NSData *imageData = [NSData dataWithContentsOfURL:uri];
|
|
UIImage *photo = [UIImage imageWithData:imageData];
|
|
NSString *path = [TUIKit_Image_Path stringByAppendingString:[TUITool genImageName:nil]];
|
|
[[NSFileManager defaultManager] createFileAtPath:path
|
|
contents:UIImagePNGRepresentation(photo) attributes:nil];
|
|
if ([self.listener respondsToSelector:@selector(onProvideImage:)]) {
|
|
[self.listener onProvideImage:path];
|
|
}
|
|
}
|
|
else {
|
|
[self transcodeIfNeed:YES message:nil videoUrl:uri];
|
|
}
|
|
}
|
|
} failureBlock:^(NSInteger errorCode, NSString * _Nonnull errorMessage) {
|
|
|
|
}];
|
|
|
|
return;
|
|
}
|
|
else {
|
|
//defalut VideoRecorder
|
|
[self _takeVideo];
|
|
}
|
|
}
|
|
- (void)_takeVideo {
|
|
__weak typeof(self) weakSelf = self;
|
|
void (^actionBlock)(void) = ^(void) {
|
|
TUICameraViewController *vc = [[TUICameraViewController alloc] init];
|
|
vc.type = TUICameraMediaTypeVideo;
|
|
vc.videoMinimumDuration = 1.5;
|
|
vc.delegate = weakSelf;
|
|
if ([TUIChatConfig defaultConfig].maxVideoRecordDuration > 0) {
|
|
vc.videoMaximumDuration = [TUIChatConfig defaultConfig].maxVideoRecordDuration;
|
|
}
|
|
if (weakSelf.presentViewController.navigationController) {
|
|
[weakSelf.presentViewController.navigationController pushViewController:vc animated:YES];
|
|
} else {
|
|
[weakSelf.presentViewController presentViewController:vc animated:YES completion:nil];
|
|
}
|
|
};
|
|
|
|
[self executeBlockWithMicroAndCameraAuth:actionBlock];
|
|
}
|
|
|
|
- (void)selectFile {
|
|
UIDocumentPickerViewController *picker = [[UIDocumentPickerViewController alloc] initWithDocumentTypes:@[ (NSString *)kUTTypeData ]
|
|
inMode:UIDocumentPickerModeOpen];
|
|
picker.delegate = self;
|
|
[self.presentViewController presentViewController:picker animated:YES completion:nil];
|
|
}
|
|
|
|
- (BOOL)isImageURL:(NSURL *)url {
|
|
NSArray *imageExtensions = @[@"jpg", @"jpeg", @"png", @"gif", @"bmp", @"tiff", @"webp", @"heic"];
|
|
NSString *pathExtension = url.pathExtension.lowercaseString;
|
|
return [imageExtensions containsObject:pathExtension];
|
|
}
|
|
#pragma mark - Private Do task
|
|
- (void)handleImagePick:(BOOL)succ message:(NSString *)message imageData:(NSData *)imageData {
|
|
static NSDictionary *imageFormatExtensionMap = nil;
|
|
if (imageFormatExtensionMap == nil) {
|
|
imageFormatExtensionMap = @{
|
|
@(SDImageFormatUndefined) : @"",
|
|
@(SDImageFormatJPEG) : @"jpeg",
|
|
@(SDImageFormatPNG) : @"png",
|
|
@(SDImageFormatGIF) : @"gif",
|
|
@(SDImageFormatTIFF) : @"tiff",
|
|
@(SDImageFormatWebP) : @"webp",
|
|
@(SDImageFormatHEIC) : @"heic",
|
|
@(SDImageFormatHEIF) : @"heif",
|
|
@(SDImageFormatPDF) : @"pdf",
|
|
@(SDImageFormatSVG) : @"svg",
|
|
@(SDImageFormatBMP) : @"bmp",
|
|
@(SDImageFormatRAW) : @"raw"
|
|
};
|
|
}
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
if (succ == NO || imageData == nil) {
|
|
if ([self.listener respondsToSelector:@selector(onProvideImageError:)]) {
|
|
[self.listener onProvideImageError:message];
|
|
}
|
|
return;
|
|
}
|
|
|
|
UIImage *image = [UIImage imageWithData:imageData];
|
|
NSData *data = UIImageJPEGRepresentation(image, 1);
|
|
NSString *path = [TUIKit_Image_Path stringByAppendingString:[TUITool genImageName:nil]];
|
|
NSString *extenionName = [imageFormatExtensionMap objectForKey:@(image.sd_imageFormat)];
|
|
if (extenionName.length > 0) {
|
|
path = [path stringByAppendingPathExtension:extenionName];
|
|
}
|
|
|
|
|
|
int32_t imageFormatSizeMax = 28 * 1024 * 1024;
|
|
|
|
if (image.sd_imageFormat == SDImageFormatGIF) {
|
|
imageFormatSizeMax = 10 * 1024 * 1024;
|
|
}
|
|
|
|
if (imageData.length > imageFormatSizeMax) {
|
|
if ([self.listener respondsToSelector:@selector(onProvideFileError:)]) {
|
|
[self.listener onProvideFileError:TIMCommonLocalizableString(TUIKitImageSizeCheckLimited)];
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (image.sd_imageFormat != SDImageFormatGIF) {
|
|
UIImage *newImage = image;
|
|
UIImageOrientation imageOrientation = image.imageOrientation;
|
|
CGFloat aspectRatio = MIN(1920 / image.size.width, 1920 / image.size.height);
|
|
CGFloat aspectWidth = image.size.width * aspectRatio;
|
|
CGFloat aspectHeight = image.size.height * aspectRatio;
|
|
UIGraphicsBeginImageContext(CGSizeMake(aspectWidth, aspectHeight));
|
|
[image drawInRect:CGRectMake(0, 0, aspectWidth, aspectHeight)];
|
|
newImage = UIGraphicsGetImageFromCurrentImageContext();
|
|
UIGraphicsEndImageContext();
|
|
data = UIImageJPEGRepresentation(newImage, 0.75);
|
|
}
|
|
|
|
[[NSFileManager defaultManager] createFileAtPath:path contents:data attributes:nil];
|
|
if ([self.listener respondsToSelector:@selector(onProvideImage:)]) {
|
|
[self.listener onProvideImage:path];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)transcodeIfNeed:(BOOL)succ message:(NSString *)message videoUrl:(NSURL *)url {
|
|
if (succ == NO || url == nil) {
|
|
[self handleVideoPick:NO message:message videoUrl:nil];
|
|
return;
|
|
}
|
|
|
|
if ([url.pathExtension.lowercaseString isEqualToString:@"mp4"]) {
|
|
[self handleVideoPick:succ message:message videoUrl:url];
|
|
return;
|
|
}
|
|
|
|
NSString *tempPath = NSTemporaryDirectory();
|
|
NSURL *urlName = [url URLByDeletingPathExtension];
|
|
NSURL *newUrl = [NSURL URLWithString:[NSString stringWithFormat:@"file://%@%@.mp4", tempPath, [urlName.lastPathComponent stringByRemovingPercentEncoding]]];
|
|
|
|
NSFileManager *fileManager = [NSFileManager defaultManager];
|
|
if ([fileManager fileExistsAtPath:newUrl.path]) {
|
|
NSError *error;
|
|
BOOL success = [fileManager removeItemAtPath:newUrl.path error:&error];
|
|
if (!success || error) {
|
|
NSAssert1(NO, @"removeItemFail: %@", error.localizedDescription);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// mov to mp4
|
|
AVURLAsset *avAsset = [AVURLAsset URLAssetWithURL:url options:nil];
|
|
AVAssetExportSession *exportSession = [[AVAssetExportSession alloc] initWithAsset:avAsset presetName:AVAssetExportPresetHighestQuality];
|
|
exportSession.outputURL = newUrl;
|
|
exportSession.outputFileType = AVFileTypeMPEG4;
|
|
exportSession.shouldOptimizeForNetworkUse = YES;
|
|
|
|
// intercept FirstTime VideoPicture
|
|
NSDictionary *opts = [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:NO] forKey:AVURLAssetPreferPreciseDurationAndTimingKey];
|
|
AVURLAsset *urlAsset = [AVURLAsset URLAssetWithURL:url options:opts];
|
|
NSInteger duration = (NSInteger)urlAsset.duration.value / urlAsset.duration.timescale;
|
|
AVAssetImageGenerator *gen = [[AVAssetImageGenerator alloc] initWithAsset:urlAsset];
|
|
gen.appliesPreferredTrackTransform = YES;
|
|
gen.maximumSize = CGSizeMake(192, 192);
|
|
NSError *error = nil;
|
|
CMTime actualTime;
|
|
CMTime time = CMTimeMakeWithSeconds(0.5, 30);
|
|
CGImageRef imageRef = [gen copyCGImageAtTime:time actualTime:&actualTime error:&error];
|
|
UIImage *image = [[UIImage alloc] initWithCGImage:imageRef];
|
|
CGImageRelease(imageRef);
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
if ([self.listener respondsToSelector:@selector(onProvidePlaceholderVideoSnapshot:SnapImage:Completion:)]) {
|
|
[self.listener onProvidePlaceholderVideoSnapshot:@"" SnapImage:image Completion:^(BOOL finished, TUIMessageCellData * _Nonnull placeHolderCellData) {
|
|
[exportSession exportAsynchronouslyWithCompletionHandler:^{
|
|
switch ([exportSession status]) {
|
|
case AVAssetExportSessionStatusFailed:
|
|
NSLog(@"Export session failed");
|
|
break;
|
|
case AVAssetExportSessionStatusCancelled:
|
|
NSLog(@"Export canceled");
|
|
break;
|
|
case AVAssetExportSessionStatusCompleted: {
|
|
// Video conversion finished
|
|
NSLog(@"Successful!");
|
|
[self handleVideoPick:succ message:message videoUrl:newUrl placeHolderCellData:placeHolderCellData];
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}];
|
|
|
|
[NSTimer tui_scheduledTimerWithTimeInterval:.1 repeats:YES block:^(NSTimer * _Nonnull timer) {
|
|
if (exportSession.status == AVAssetExportSessionStatusExporting) {
|
|
NSLog(@"exportSession.progress:%f",exportSession.progress);
|
|
placeHolderCellData.videoTranscodingProgress = exportSession.progress;
|
|
}
|
|
}];
|
|
|
|
}];
|
|
}
|
|
else {
|
|
[exportSession exportAsynchronouslyWithCompletionHandler:^{
|
|
switch ([exportSession status]) {
|
|
case AVAssetExportSessionStatusCompleted: {
|
|
// Video conversion finished
|
|
NSLog(@"Successful!");
|
|
[self handleVideoPick:succ message:message videoUrl:newUrl];
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
}];
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
- (void)transcodeIfNeed:(BOOL)succ message:(NSString *)message videoUrl:(NSURL *)url placeHolderCellData:(TUIMessageCellData*)placeHolderCellData {
|
|
if (succ == NO || url == nil) {
|
|
[self handleVideoPick:NO message:message videoUrl:nil];
|
|
return;
|
|
}
|
|
|
|
if ([url.pathExtension.lowercaseString isEqualToString:@"mp4"]) {
|
|
[self handleVideoPick:succ message:message videoUrl:url];
|
|
return;
|
|
}
|
|
|
|
NSString *tempPath = NSTemporaryDirectory();
|
|
NSURL *urlName = [url URLByDeletingPathExtension];
|
|
NSURL *newUrl = [NSURL URLWithString:[NSString stringWithFormat:@"file://%@%@.mp4", tempPath, [urlName.lastPathComponent stringByRemovingPercentEncoding]]];
|
|
|
|
NSFileManager *fileManager = [NSFileManager defaultManager];
|
|
if ([fileManager fileExistsAtPath:newUrl.path]) {
|
|
NSError *error;
|
|
BOOL success = [fileManager removeItemAtPath:newUrl.path error:&error];
|
|
if (!success || error) {
|
|
NSAssert1(NO, @"removeItemFail: %@", error.localizedDescription);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// mov to mp4
|
|
AVURLAsset *avAsset = [AVURLAsset URLAssetWithURL:url options:nil];
|
|
AVAssetExportSession *exportSession = [[AVAssetExportSession alloc] initWithAsset:avAsset presetName:AVAssetExportPresetHighestQuality];
|
|
exportSession.outputURL = newUrl;
|
|
exportSession.outputFileType = AVFileTypeMPEG4;
|
|
exportSession.shouldOptimizeForNetworkUse = YES;
|
|
|
|
// intercept FirstTime VideoPicture
|
|
NSDictionary *opts = [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:NO] forKey:AVURLAssetPreferPreciseDurationAndTimingKey];
|
|
AVURLAsset *urlAsset = [AVURLAsset URLAssetWithURL:url options:opts];
|
|
NSInteger duration = (NSInteger)urlAsset.duration.value / urlAsset.duration.timescale;
|
|
AVAssetImageGenerator *gen = [[AVAssetImageGenerator alloc] initWithAsset:urlAsset];
|
|
gen.appliesPreferredTrackTransform = YES;
|
|
gen.maximumSize = CGSizeMake(192, 192);
|
|
NSError *error = nil;
|
|
CMTime actualTime;
|
|
CMTime time = CMTimeMakeWithSeconds(0.5, 30);
|
|
CGImageRef imageRef = [gen copyCGImageAtTime:time actualTime:&actualTime error:&error];
|
|
UIImage *image = [[UIImage alloc] initWithCGImage:imageRef];
|
|
CGImageRelease(imageRef);
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
if ([self.listener respondsToSelector:@selector(onProvidePlaceholderVideoSnapshot:SnapImage:Completion:)]) {
|
|
[exportSession exportAsynchronouslyWithCompletionHandler:^{
|
|
switch ([exportSession status]) {
|
|
case AVAssetExportSessionStatusFailed:
|
|
NSLog(@"Export session failed");
|
|
break;
|
|
case AVAssetExportSessionStatusCancelled:
|
|
NSLog(@"Export canceled");
|
|
break;
|
|
case AVAssetExportSessionStatusCompleted: {
|
|
// Video conversion finished
|
|
NSLog(@"Successful!");
|
|
[self handleVideoPick:succ message:message videoUrl:newUrl placeHolderCellData:placeHolderCellData];
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}];
|
|
|
|
[NSTimer tui_scheduledTimerWithTimeInterval:.1 repeats:YES block:^(NSTimer * _Nonnull timer) {
|
|
if (exportSession.status == AVAssetExportSessionStatusExporting) {
|
|
NSLog(@"exportSession.progress:%f",exportSession.progress);
|
|
placeHolderCellData.videoTranscodingProgress = exportSession.progress;
|
|
}
|
|
}];
|
|
}
|
|
else {
|
|
[exportSession exportAsynchronouslyWithCompletionHandler:^{
|
|
switch ([exportSession status]) {
|
|
case AVAssetExportSessionStatusCompleted: {
|
|
// Video conversion finished
|
|
NSLog(@"Successful!");
|
|
[self handleVideoPick:succ message:message videoUrl:newUrl];
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
}];
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
- (void)handleVideoPick:(BOOL)succ message:(NSString *)message videoUrl:(NSURL *)videoUrl {
|
|
[self handleVideoPick:succ message:message videoUrl:videoUrl placeHolderCellData:nil];
|
|
}
|
|
- (void)handleVideoPick:(BOOL)succ message:(NSString *)message videoUrl:(NSURL *)videoUrl placeHolderCellData:(TUIMessageCellData*)placeHolderCellData{
|
|
if (succ == NO || videoUrl == nil) {
|
|
if ([self.listener respondsToSelector:@selector(onProvideVideoError:)]) {
|
|
[self.listener onProvideVideoError:message];
|
|
}
|
|
return;
|
|
}
|
|
|
|
NSData *videoData = [NSData dataWithContentsOfURL:videoUrl];
|
|
NSString *videoPath = [NSString stringWithFormat:@"%@%@_%u.mp4", TUIKit_Video_Path, [TUITool genVideoName:nil],arc4random()];
|
|
[[NSFileManager defaultManager] createFileAtPath:videoPath contents:videoData attributes:nil];
|
|
|
|
NSDictionary *opts = [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:NO] forKey:AVURLAssetPreferPreciseDurationAndTimingKey];
|
|
AVURLAsset *urlAsset = [AVURLAsset URLAssetWithURL:videoUrl options:opts];
|
|
NSInteger duration = (NSInteger)urlAsset.duration.value / urlAsset.duration.timescale;
|
|
AVAssetImageGenerator *gen = [[AVAssetImageGenerator alloc] initWithAsset:urlAsset];
|
|
gen.appliesPreferredTrackTransform = YES;
|
|
gen.maximumSize = CGSizeMake(192, 192);
|
|
NSError *error = nil;
|
|
CMTime actualTime;
|
|
CMTime time = CMTimeMakeWithSeconds(0.5, 30);
|
|
CGImageRef imageRef = [gen copyCGImageAtTime:time actualTime:&actualTime error:&error];
|
|
UIImage *image = [[UIImage alloc] initWithCGImage:imageRef];
|
|
CGImageRelease(imageRef);
|
|
|
|
NSData *imageData = UIImagePNGRepresentation(image);
|
|
NSString *imagePath = [TUIKit_Video_Path stringByAppendingFormat:@"%@_%u",[TUITool genSnapshotName:nil],arc4random()];
|
|
[[NSFileManager defaultManager] createFileAtPath:imagePath contents:imageData attributes:nil];
|
|
|
|
if ([self.listener respondsToSelector:@selector(onProvideVideo:snapshot:duration:placeHolderCellData:)]) {
|
|
[self.listener onProvideVideo:videoPath snapshot:imagePath duration:duration placeHolderCellData:placeHolderCellData];
|
|
}
|
|
}
|
|
|
|
#pragma mark - PHPickerViewControllerDelegate
|
|
- (void)picker:(PHPickerViewController *)picker didFinishPicking:(NSArray<PHPickerResult *> *)results API_AVAILABLE(ios(14)) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
[picker dismissViewControllerAnimated:YES completion:nil];
|
|
[[[UIApplication sharedApplication] keyWindow] endEditing:YES];
|
|
});
|
|
|
|
if (!results || results.count == 0) {
|
|
return;
|
|
}
|
|
|
|
PHPickerResult *result = [results firstObject];
|
|
for (PHPickerResult *result in results) {
|
|
[self _dealPHPickerResultFinishPicking:result];
|
|
}
|
|
}
|
|
|
|
- (void)_dealPHPickerResultFinishPicking:(PHPickerResult *)result API_AVAILABLE(ios(14)) {
|
|
NSItemProvider *itemProvoider = result.itemProvider;
|
|
__weak typeof(self) weakSelf = self;
|
|
if ([itemProvoider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeImage]) {
|
|
[itemProvoider loadDataRepresentationForTypeIdentifier:(NSString *)kUTTypeImage
|
|
completionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
BOOL succ = YES;
|
|
NSString *message = nil;
|
|
if (error) {
|
|
succ = NO;
|
|
message = error.localizedDescription;
|
|
}
|
|
[weakSelf handleImagePick:succ message:message imageData:data];
|
|
});
|
|
}];
|
|
} else if ([itemProvoider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeMPEG4]) {
|
|
[itemProvoider loadDataRepresentationForTypeIdentifier:(NSString *)kUTTypeMovie
|
|
completionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
NSString *fileName = @"temp.mp4";
|
|
NSString *tempPath = NSTemporaryDirectory();
|
|
NSString *filePath = [tempPath stringByAppendingPathComponent:fileName];
|
|
if ([NSFileManager.defaultManager isDeletableFileAtPath:filePath]) {
|
|
[NSFileManager.defaultManager removeItemAtPath:filePath error:nil];
|
|
}
|
|
NSURL *newUrl = [NSURL fileURLWithPath:filePath];
|
|
BOOL flag = [NSFileManager.defaultManager createFileAtPath:filePath contents:data attributes:nil];
|
|
[weakSelf transcodeIfNeed:flag message:flag ? nil : @"video not found" videoUrl:newUrl];
|
|
});
|
|
}];
|
|
} else if ([itemProvoider hasItemConformingToTypeIdentifier:(NSString *)kUTTypeMovie]) {
|
|
// Mov type: screen first
|
|
if ([self.listener respondsToSelector:@selector(onProvidePlaceholderVideoSnapshot:SnapImage:Completion:)]) {
|
|
[self.listener onProvidePlaceholderVideoSnapshot:@"" SnapImage:nil Completion:^(BOOL finished, TUIMessageCellData * _Nonnull placeHolderCellData) {
|
|
[itemProvoider loadDataRepresentationForTypeIdentifier:(NSString *)kUTTypeMovie
|
|
completionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
// Non-mp4 format video, temporarily use mov suffix, will be converted to mp4 format later
|
|
NSDate *datenow = [NSDate date];
|
|
NSString *timeSp = [NSString stringWithFormat:@"%ld", (long)([datenow timeIntervalSince1970]*1000)];
|
|
NSString *fileName = [NSString stringWithFormat:@"%@_temp.mov",timeSp];
|
|
NSString *tempPath = NSTemporaryDirectory();
|
|
NSString *filePath = [tempPath stringByAppendingPathComponent:fileName];
|
|
if ([NSFileManager.defaultManager isDeletableFileAtPath:filePath]) {
|
|
[NSFileManager.defaultManager removeItemAtPath:filePath error:nil];
|
|
}
|
|
NSURL *newUrl = [NSURL fileURLWithPath:filePath];
|
|
BOOL flag = [NSFileManager.defaultManager createFileAtPath:filePath contents:data attributes:nil];
|
|
[weakSelf transcodeIfNeed:flag message:flag ? nil : @"movie not found" videoUrl:newUrl placeHolderCellData:placeHolderCellData];
|
|
});
|
|
}];
|
|
}];
|
|
}
|
|
} else {
|
|
NSString *typeIdentifier = result.itemProvider.registeredTypeIdentifiers.firstObject;
|
|
[itemProvoider loadFileRepresentationForTypeIdentifier:typeIdentifier
|
|
completionHandler:^(NSURL *_Nullable url, NSError *_Nullable error) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIImage *result;
|
|
NSData *data = [NSData dataWithContentsOfURL:url];
|
|
result = [UIImage imageWithData:data];
|
|
|
|
/**
|
|
* Can't get url when typeIdentifier is public.jepg on emulator:
|
|
* There is a separate JEPG transcoding issue that only affects the simulator (63426347), please refer to
|
|
* https://developer.apple.com/forums/thread/658135 for more information.
|
|
*/
|
|
});
|
|
}];
|
|
}
|
|
}
|
|
|
|
#pragma mark - UIImagePickerController
|
|
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary<NSString *, id> *)info {
|
|
__weak typeof(self) weakSelf = self;
|
|
picker.delegate = nil;
|
|
[picker dismissViewControllerAnimated:YES
|
|
completion:^{
|
|
NSString *mediaType = [info objectForKey:UIImagePickerControllerMediaType];
|
|
if ([mediaType isEqualToString:(NSString *)kUTTypeImage]) {
|
|
NSURL *url = nil;
|
|
if (@available(iOS 11.0, *)) {
|
|
url = [info objectForKey:UIImagePickerControllerImageURL];
|
|
} else {
|
|
url = [info objectForKey:UIImagePickerControllerReferenceURL];
|
|
}
|
|
|
|
BOOL succ = YES;
|
|
NSData *imageData = nil;
|
|
NSString *errorMessage = nil;
|
|
if (url) {
|
|
succ = YES;
|
|
imageData = [NSData dataWithContentsOfURL:url];
|
|
} else {
|
|
succ = NO;
|
|
errorMessage = @"image not found";
|
|
}
|
|
[weakSelf handleImagePick:succ message:errorMessage imageData:imageData];
|
|
} else if ([mediaType isEqualToString:(NSString *)kUTTypeMovie]) {
|
|
NSURL *url = [info objectForKey:UIImagePickerControllerMediaURL];
|
|
if (url) {
|
|
[weakSelf transcodeIfNeed:YES message:nil videoUrl:url];
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* In some cases UIImagePickerControllerMediaURL may be empty, use UIImagePickerControllerPHAsset
|
|
*/
|
|
PHAsset *asset = nil;
|
|
if (@available(iOS 11.0, *)) {
|
|
asset = [info objectForKey:UIImagePickerControllerPHAsset];
|
|
}
|
|
if (asset) {
|
|
[self originURLWithAsset:asset
|
|
completion:^(BOOL success, NSURL *URL) {
|
|
[weakSelf transcodeIfNeed:success
|
|
message:success ? nil : @"origin url with asset not found"
|
|
videoUrl:URL];
|
|
}];
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* UIImagePickerControllerPHAsset may be empty, and other methods need to be used to obtain the original path of the video
|
|
* file
|
|
*/
|
|
url = [info objectForKey:UIImagePickerControllerReferenceURL];
|
|
if (url) {
|
|
[weakSelf originURLWithRefrenceURL:url
|
|
completion:^(BOOL success, NSURL *URL) {
|
|
[weakSelf transcodeIfNeed:success
|
|
message:success ? nil : @"origin url with asset not found"
|
|
videoUrl:URL];
|
|
}];
|
|
return;
|
|
}
|
|
|
|
// not support the video
|
|
[weakSelf transcodeIfNeed:NO message:@"not support the video" videoUrl:nil];
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker {
|
|
[picker dismissViewControllerAnimated:YES completion:nil];
|
|
}
|
|
|
|
/**
|
|
* Get the original file path based on UIImagePickerControllerReferenceURL
|
|
*/
|
|
- (void)originURLWithRefrenceURL:(NSURL *)URL completion:(void (^)(BOOL success, NSURL *URL))completion {
|
|
if (completion == nil) {
|
|
return;
|
|
}
|
|
NSDictionary *queryInfo = [self dictionaryWithURLQuery:URL.query];
|
|
NSString *fileName = @"temp.mp4";
|
|
if ([queryInfo.allKeys containsObject:@"id"] && [queryInfo.allKeys containsObject:@"ext"]) {
|
|
fileName = [NSString stringWithFormat:@"%@.%@", queryInfo[@"id"], [queryInfo[@"ext"] lowercaseString]];
|
|
}
|
|
NSString *tempPath = NSTemporaryDirectory();
|
|
NSString *filePath = [tempPath stringByAppendingPathComponent:fileName];
|
|
if ([NSFileManager.defaultManager isDeletableFileAtPath:filePath]) {
|
|
[NSFileManager.defaultManager removeItemAtPath:filePath error:nil];
|
|
}
|
|
NSURL *newUrl = [NSURL fileURLWithPath:filePath];
|
|
ALAssetsLibrary *assetLibrary = [[ALAssetsLibrary alloc] init];
|
|
[assetLibrary assetForURL:URL
|
|
resultBlock:^(ALAsset *asset) {
|
|
if (asset == nil) {
|
|
completion(NO, nil);
|
|
return;
|
|
}
|
|
ALAssetRepresentation *rep = [asset defaultRepresentation];
|
|
Byte *buffer = (Byte *)malloc(rep.size);
|
|
NSUInteger buffered = [rep getBytes:buffer fromOffset:0.0 length:rep.size error:nil];
|
|
NSData *data = [NSData dataWithBytesNoCopy:buffer length:buffered freeWhenDone:YES]; // this is NSData may be what you want
|
|
BOOL flag = [NSFileManager.defaultManager createFileAtPath:filePath contents:data attributes:nil];
|
|
completion(flag, newUrl);
|
|
}
|
|
failureBlock:^(NSError *err) {
|
|
completion(NO, nil);
|
|
}];
|
|
}
|
|
|
|
- (void)originURLWithAsset:(PHAsset *)asset completion:(void (^)(BOOL success, NSURL *URL))completion {
|
|
if (completion == nil) {
|
|
return;
|
|
}
|
|
|
|
NSArray<PHAssetResource *> *resources = [PHAssetResource assetResourcesForAsset:asset];
|
|
if (resources.count == 0) {
|
|
completion(NO, nil);
|
|
return;
|
|
}
|
|
|
|
PHAssetResourceRequestOptions *options = [[PHAssetResourceRequestOptions alloc] init];
|
|
options.networkAccessAllowed = NO;
|
|
__block BOOL invoked = NO;
|
|
[PHAssetResourceManager.defaultManager requestDataForAssetResource:resources.firstObject
|
|
options:options
|
|
dataReceivedHandler:^(NSData *_Nonnull data) {
|
|
/**
|
|
*
|
|
* There will be a problem of repeated callbacks here
|
|
*/
|
|
if (invoked) {
|
|
return;
|
|
}
|
|
invoked = YES;
|
|
if (data == nil) {
|
|
completion(NO, nil);
|
|
return;
|
|
}
|
|
NSString *fileName = @"temp.mp4";
|
|
NSString *tempPath = NSTemporaryDirectory();
|
|
NSString *filePath = [tempPath stringByAppendingPathComponent:fileName];
|
|
if ([NSFileManager.defaultManager isDeletableFileAtPath:filePath]) {
|
|
[NSFileManager.defaultManager removeItemAtPath:filePath error:nil];
|
|
}
|
|
NSURL *newUrl = [NSURL fileURLWithPath:filePath];
|
|
BOOL flag = [NSFileManager.defaultManager createFileAtPath:filePath contents:data attributes:nil];
|
|
completion(flag, newUrl);
|
|
}
|
|
completionHandler:^(NSError *_Nullable error) {
|
|
completion(NO, nil);
|
|
}];
|
|
}
|
|
|
|
- (NSDictionary *)dictionaryWithURLQuery:(NSString *)query {
|
|
NSArray *components = [query componentsSeparatedByString:@"&"];
|
|
NSMutableDictionary *dict = [NSMutableDictionary dictionary];
|
|
for (NSString *item in components) {
|
|
NSArray *subs = [item componentsSeparatedByString:@"="];
|
|
if (subs.count == 2) {
|
|
[dict setObject:subs.lastObject forKey:subs.firstObject];
|
|
}
|
|
}
|
|
return [NSDictionary dictionaryWithDictionary:dict];
|
|
;
|
|
}
|
|
|
|
#pragma mark - TUICameraViewControllerDelegate
|
|
- (void)cameraViewController:(TUICameraViewController *)controller didFinishPickingMediaWithVideoURL:(NSURL *)url {
|
|
[self transcodeIfNeed:YES message:nil videoUrl:url];
|
|
}
|
|
|
|
- (void)cameraViewController:(TUICameraViewController *)controller didFinishPickingMediaWithImageData:(NSData *)data {
|
|
[self handleImagePick:YES message:nil imageData:data];
|
|
}
|
|
|
|
- (void)cameraViewControllerDidCancel:(TUICameraViewController *)controller {
|
|
}
|
|
|
|
- (void)cameraViewControllerDidPictureLib:(TUICameraViewController *)controller finishCallback:(void (^)(void))callback {
|
|
[self selectPhoto];
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
|
|
#pragma mark - UIDocumentPickerDelegate
|
|
- (void)documentPicker:(UIDocumentPickerViewController *)controller didPickDocumentAtURL:(NSURL *)url {
|
|
[url startAccessingSecurityScopedResource];
|
|
NSFileCoordinator *coordinator = [[NSFileCoordinator alloc] init];
|
|
NSError *error;
|
|
@weakify(self);
|
|
[coordinator
|
|
coordinateReadingItemAtURL:url
|
|
options:0
|
|
error:&error
|
|
byAccessor:^(NSURL *newURL) {
|
|
@strongify(self);
|
|
NSData *fileData = [NSData dataWithContentsOfURL:newURL options:NSDataReadingMappedIfSafe error:nil];
|
|
NSString *fileName = [url lastPathComponent];
|
|
NSString *filePath = [TUIKit_File_Path stringByAppendingString:fileName];
|
|
if (fileData.length > 1e9 || fileData.length == 0) { // 1e9 bytes = 1GB
|
|
UIAlertController *ac = [UIAlertController alertControllerWithTitle:TIMCommonLocalizableString(TUIKitFileSizeCheckLimited) message:nil preferredStyle:UIAlertControllerStyleAlert];
|
|
[ac tuitheme_addAction:[UIAlertAction actionWithTitle:TIMCommonLocalizableString(Confirm) style:UIAlertActionStyleDefault handler:nil]];
|
|
[self.presentViewController presentViewController:ac animated:YES completion:nil];
|
|
return;
|
|
}
|
|
if ([NSFileManager.defaultManager fileExistsAtPath:filePath]) {
|
|
/**
|
|
* If a file with the same name exists, increment the file name
|
|
*/
|
|
int i = 0;
|
|
NSArray *arrayM = [NSFileManager.defaultManager subpathsAtPath:TUIKit_File_Path];
|
|
for (NSString *sub in arrayM) {
|
|
if ([sub.pathExtension isEqualToString:fileName.pathExtension] &&
|
|
[sub.stringByDeletingPathExtension tui_containsString:fileName.stringByDeletingPathExtension]) {
|
|
i++;
|
|
}
|
|
}
|
|
if (i) {
|
|
fileName = [fileName
|
|
stringByReplacingOccurrencesOfString:fileName.stringByDeletingPathExtension
|
|
withString:[NSString stringWithFormat:@"%@(%d)", fileName.stringByDeletingPathExtension, i]];
|
|
filePath = [TUIKit_File_Path stringByAppendingString:fileName];
|
|
}
|
|
}
|
|
|
|
[[NSFileManager defaultManager] createFileAtPath:filePath contents:fileData attributes:nil];
|
|
if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
|
|
unsigned long long fileSize = [[[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil] fileSize];
|
|
if ([self.listener respondsToSelector:@selector(onProvideFile:filename:fileSize:)]) {
|
|
[self.listener onProvideFile:filePath filename:fileName fileSize:fileSize];
|
|
}
|
|
} else {
|
|
if ([self.listener respondsToSelector:@selector(onProvideFileError:)]) {
|
|
[self.listener onProvideFileError:@"file not found"];
|
|
}
|
|
}
|
|
}];
|
|
[url stopAccessingSecurityScopedResource];
|
|
[controller dismissViewControllerAnimated:YES completion:nil];
|
|
}
|
|
|
|
- (void)documentPickerWasCancelled:(UIDocumentPickerViewController *)controller {
|
|
[controller dismissViewControllerAnimated:YES completion:nil];
|
|
}
|
|
|
|
@end
|