Loading Core Data From Large JSON Causing App To Crash - objective-c

I'm attempting to populate CoreData from a JSON file that consists of 170,000 plus dictionaries. The parsing of the json goes quick but when I start trying to add to CoreData I'm blocking the main thread for a long time and then the app eventually crashes. It crashes when calling the method [UIDocument saveToUrl:forSaveOperation:completionHandler] Here is my code. If anyone has an idea of what's causing it to crash or a more efficient way to load CoreData that would be greatly appreciated.
#property (nonatomic, strong) UIManagedDocument *wordDatabase;
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
if (!self.wordDatabase) {
NSURL *url = [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
url = [url URLByAppendingPathComponent:#"Word Database"];
self.wordDatabase = [[UIManagedDocument alloc] initWithFileURL:url];
}
}
- (void)setWordDatabase:(UIManagedDocument *)wordDatabase
{
if (_wordDatabase != wordDatabase) {
_wordDatabase = wordDatabase;
[self useDocument];
}
}
- (void)useDocument
{
if (![[NSFileManager defaultManager] fileExistsAtPath:[self.wordDatabase.fileURL path]]) {
// does not exist on disk, so create it
[self.wordDatabase saveToURL:self.wordDatabase.fileURL forSaveOperation:UIDocumentSaveForCreating completionHandler:^(BOOL success) {
[self setupFetchedResultsController];
[self prepopulateWordDatabaseWithDocument:self.wordDatabase];
}];
}
}
- (void)prepopulateWordDatabaseWithDocument:(UIManagedDocument *)document
{
dispatch_queue_t fetchQ = dispatch_queue_create("Word Fetcher", NULL);
dispatch_async(fetchQ, ^{
//Fetch the words from the json file
NSString *fileString = [[NSBundle mainBundle] pathForResource:#"words" ofType:#"json"];
NSString *jsonString = [[NSString alloc] initWithContentsOfFile:fileString encoding:NSUTF8StringEncoding error: NULL];
NSData *jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
NSError *error;
NSArray *words = [NSJSONSerialization JSONObjectWithData:jsonData options:NSJSONReadingMutableContainers error:&error];
[document.managedObjectContext performBlock:^{
for (NSDictionary *dictionary in words)
{
[Word wordFromDictionary:dictionary inManagedObjectContext:document.managedObjectContext];
}
[document saveToURL:document.fileURL forSaveOperation:UIDocumentSaveForOverwriting completionHandler:NULL];
}];
});
dispatch_release(fetchQ);
}

What I ended up doing that stopped my app from crashing was allocating a new NSManagedObjectContext and peformed all my loading in the background. After saving I called my NSFetchedResultsController and the table repopulated.
- (void)prepopulateWordDatabaseWithDocument:(UIManagedDocument *)document
{
NSManagedObjectContext *backgroundContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
backgroundContext.undoManager = nil;
backgroundContext.persistentStoreCoordinator = document.managedObjectContext.persistentStoreCoordinator;
[backgroundContext performBlock:^{
NSString *fileString = [[NSBundle mainBundle] pathForResource:#"words" ofType:#"json"];
NSString *jsonString = [[NSString alloc] initWithContentsOfFile:fileString encoding:NSUTF8StringEncoding error: NULL];
NSData *jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
NSError *parseError;
NSArray *words = [NSJSONSerialization JSONObjectWithData:jsonData options:NSJSONReadingMutableContainers error:&parseError];
for (NSDictionary *dictionary in words)
{
[Word wordFromDictionary:dictionary inManagedObjectContext:backgroundContext];
}
NSError *loadError;
if ([backgroundContext save:&loadError]) {
dispatch_async(dispatch_get_main_queue(), ^{
[self setupFetchedResultsController];
});
}
}];
}

Related

App crash with " Thread 90: EXC_BAD_ACCESS (code=1, address=0x18)" in Objective C

-(void)writeAllCategoriesInJson:(NSDictionary *)dict
{
NSArray *arry_allCategory = [[NSArray alloc] initWithObjects:dict, nil];
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:arry_allCategory options:NSJSONWritingPrettyPrinted error:&error];
if (!jsonData && error){
NSLog(#"Error creating JSON: %#", [error localizedDescription]);
return;
}
NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
// Build the path, and create if needed.
NSString* filePath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSString* fileName = #"Categories.json";
NSString* fileAtPath = [filePath stringByAppendingPathComponent:fileName];
if (![[NSFileManager defaultManager] fileExistsAtPath:fileAtPath]) {
[[NSFileManager defaultManager] createFileAtPath:fileAtPath contents:nil attributes:nil];
}
// The main act...
[[jsonString dataUsingEncoding:NSUTF8StringEncoding] writeToFile:fileAtPath atomically:NO];
}
Here app crash with
"Thread 90: EXC_BAD_ACCESS (code=1, address=0x18)"
on below line:
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:arry_allCategory options:NSJSONWritingPrettyPrinted error:&error];
What is the issue on this line. Its working fine all time and in between its crashed. I try my best but the issue is still occuring.

Weird NSZombie error in nsmutuablearray

I had faced a weird error for a few days ago. Luckly, i had solved this error about in 4-5 day. However, i just wonder that the error why happen.
First of all, i will describe the situation with same sample of code.
#interface SampleViewController ()
#property (nonatomic, strong) NSMutableArray *selectedIssue;
#property (nonatomic, strong) NSOperationQueue *queueJSON;
#property (nonatomic, strong) NSOperationQueue *queueImage;
#end
#implementation SampleViewController
/** blah blah blah*/
- (void) fillIssueArrayMethodWithIssueId:(NSInteger) selectedId {
NSString *requestURL = [NSString stringWithFormat:#"%#Issues/Get/?id=%d", kAPIRootURL, selectedId];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:requestURL]
cachePolicy:NSURLRequestReloadIgnoringLocalCacheData
timeoutInterval:kNetworkTimeOut];
AFHTTPRequestOperation *op = [[AFHTTPRequestOperation alloc] initWithRequest:request];
op.responseSerializer = [AFJSONResponseSerializer serializer];
[op setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id response) {
NSData *JSONData = [NSData dataWithContentsOfFile:filePath
options:NSDataReadingMappedIfSafe
error:nil];
NSMutableArray *responseObject = [NSJSONSerialization JSONObjectWithData:JSONData
options:NSJSONReadingMutableContainers
error:nil];
if(responseObject) {
if([responseObject isKindOfClass:[NSArray class]]) {
_selectedIssue = [NSMutableArray arrayWithArray:responseObject];
}
}
} failure:^(AFHTTPRequestOperation *operation, NSError *error) { }];
[_queueJSON addOperation:op];
}
-(void)startDownloadImages {
NSArray *objPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *strPath = [objPaths lastObject];
if(!_queueImage)
_queueImage = [[NSOperationQueue alloc] init];
_queueImage.maxConcurrentOperationCount = 3;
NSBlockOperation *completionOperation = [NSBlockOperation new];
for (__block NSDictionary *object in _selectedIssue) {
// Photos
NSString *imgURL = object[#"ImageUrl"];
NSString *strImageFile = [NSString stringWithFormat:#"%#_%#", object[#"Id"], [imgURL lastPathComponent]];
__block NSString *strImagePath = [NSString stringWithFormat:#"%#/Images/Issues/%#", strPath, strImageFile];
NSURLRequest *request4Images = [NSURLRequest requestWithURL:[NSURL URLWithString:imgURL]];
AFHTTPRequestOperation *operation4Images = [[AFHTTPRequestOperation alloc] initWithRequest:request4Images];
[operation4Images setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id rawResult) {
BOOL isImageWrited = [rawResult writeToFile:strImagePath options:NSDataWritingAtomic error:nil];
if(isImageWrited) {
NSLog(#"Image Write Success : %#", operation.request.URL);
} else {
NSLog(#"Image Write Error: %#", imageWriteError.description);
}
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
NSLog(#"Image Write Failed : %# : %ld", operation.request.URL, (long)operation.response.statusCode);
}];
[completionOperation addDependency:operation4Images];
}
[_queueImage addOperations:completionOperation.dependencies waitUntilFinished:NO];
[_queueImage addOperation:completionOperation];
}
#end
Here is problem;
In application lifecycle, fillIssueArrayMethodWithIssueId method get JSON data to mutuablearray first. Then start to download images by getting image URL from the array.
Each second time, i want to access the _selectedIssue in fillIssueArrayMethodWithIssueId method, my app got crash (SIGSEGV)
In according to long investigation, _selectedUssue become instantly zombie object when StartDownloadImages method finished. However in this method i have never reallocated this array. I have just read values in this array. I am sure that the array become zombie object in this method so the issue fixed when removed "__block" in for loop.
So the question, __block type how could affect the _selectedIssue arrays object ?
I just want to know what i am missing...
By the way,i have been tried in StartDownloadImages method before the for loop, i had create temporary array and this temp array just initiated with _selectedIssue mutableCopy or just copy. However, i again faced with zombie problem.

Memory leak using ARC in NSData framework

i can't figure out one memory leak. I will add screen shot with code and marked line where this happens.
Maybe some could help me and take a look.
Thanks.
- (AVAudioPlayer*)getSpeachSoundObject{
NSString *objectIDString = [NSString stringWithFormat:#"%i", jmObject.objectID];
NSString * __weak textPlaySource = [DataController getMediaUrlStringForObjectID:objectIDString parentType:PARENT_TYPE_ITEM_AUDIO];
NSError * error = nil ;
if (textPlaySource) {
//NSURL *soundURL = [[NSURL alloc] initFileURLWithPath:textPlaySource];//[NSURL fileURLWithPath:textPlaySource];
NSData * data = [NSData dataWithContentsOfFile:textPlaySource options:NSDataReadingMapped error:&error ] ;
textPlaySource = nil;
NSError *error;
//speechSound = [[AVAudioPlayer alloc] initWithContentsOfURL:soundURL error:&error];
AVAudioPlayer *lspeechSound = data ? [[AVAudioPlayer alloc] initWithData:data error:&error ] : nil ;
data = nil;
if (error) {
WLog([NSString stringWithFormat:#"Error creating sound file:%#", error]);
}
return lspeechSound;
//soundURL = nil;
}
return nil;
}

reloadData Crashing iOS App

I'm doing a Twitter request for API data with:
TWRequest *postRequest = [[TWRequest alloc] initWithURL:[NSURL URLWithString:#"http://search.twitter.com/search.json?q=a2zwedding&include_entities=true"] parameters:nil requestMethod:TWRequestMethodGET];
then I'm getting all processing the request with:
[postRequest performRequestWithHandler:^(NSData *responseData, NSHTTPURLResponse *urlResponse, NSError *error) {
// NSString *output;
NSArray *results;
if ([urlResponse statusCode] == 200) {
NSError *jsonParsingError = nil;
NSDictionary *publicTimeline = [NSJSONSerialization JSONObjectWithData:responseData options:0 error:&jsonParsingError];
results = [publicTimeline objectForKey:#"results"];
}
[self performSelectorOnMainThread:#selector(populateTable:) withObject:results waitUntilDone:YES];
}];
I'm then trying to display the "results" in a UITableView. My delegate and datasource are the same view controller that is processing the JSON data. My datasource method of:
- (NSInteger)tableView:(UITableView*)tableView numberOfRowsInSection:(NSInteger)section
is returning zero if I try to do the count of my array because my JSON parsing isn't finished when this gets called. If I "return 1" with this method, it properly displays one of the results from my Twitter request. However, if I use reloadData my app crashes. I cannot get it to delay the count. Any ideas?
in .h
//use this as your datasource
#property(nonatomic, strong)NSArray *myResultData;
.m
#synthesize myResultData;
[postRequest performRequestWithHandler:^(NSData *responseData, NSHTTPURLResponse *urlResponse, NSError *error) {
// NSString *output;
NSArray *results;
if ([urlResponse statusCode] == 200) {
NSError *jsonParsingError = nil;
NSDictionary *publicTimeline = [NSJSONSerialization JSONObjectWithData:responseData options:0 error:&jsonParsingError];
results = [publicTimeline objectForKey:#"results"];
if(![results isKindOfClass:[NSNull class]])
{
myResultData = [NSArray alloc]initWithArray:results];
}
[self.tableView reloadData];
}
}];

Upload Video to Vimeo in Objective C on iPhone

I am developing an app from which I want to upload Videos to Vimeo, Facebook and Youtube. Facebook and Youtube have pretty straightforward apis, Vimeo has a good developer documentation, but no Objective C framework. I have seen a couple of Apps which use Vimeo, so I was wondering if there is some kind of Framework out there I'm not aware of.
OK everybody. If you're still interested in how to upload a video to vimeo, here's the code. First you need to register an App with vimeo and obtain your secret and consumer key. Then you need to get the GTMOAuth framework from Google and possibly the SBJson framework. At the moment I unfortunately don't have the time to clean up the below code, but I thought this may be better than nothing for those, who need some help with vimeo. Essentially you authenticate with vimeo, get an upload ticket, upload the video with this ticket and then ad a title and some text.
The code below won't work out of the box, because there are a couple of view elements connected, but it should give you an understanding of what is happening.
#define VIMEO_SECRET #"1234567890"
#define VIMEO_CONSUMER_KEY #"1234567890"
#define VIMEO_BASE_URL #"http://vimeo.com/services/auth/"
#define VIMEO_REQUEST_TOKEN_URL #"http://vimeo.com/oauth/request_token"
#define VIMEO_AUTHORIZATION_URL #"http://vimeo.com/oauth/authorize?permission=write"
#define VIMEO_ACCESS_TOKEN_URL #"http://vimeo.com/oauth/access_token"
#import "MMVimeoUploaderVC.h"
#import "GTMOAuthAuthentication.h"
#import "GTMOAuthSignIn.h"
#import "GTMOAuthViewControllerTouch.h"
#import "JSON.h"
#interface MMVimeoUploaderVC ()
#property (retain) GTMOAuthAuthentication *signedAuth;
#property (retain) NSString *currentTicketID;
#property (retain) NSString *currentVideoID;
#property (assign) BOOL isUploading;
#property (retain) GTMHTTPFetcher *currentFetcher;
#end
#implementation MMVimeoUploaderVC
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
if (self) {
// Custom initialization
first = YES;
[GTMOAuthViewControllerTouch removeParamsFromKeychainForName:#"Vimeo"];
}
return self;
}
- (void)stopUpload {
if ( self.isUploading || self.currentFetcher ) {
[self.currentFetcher stopFetching];
}
}
- (void) setProgress:(float) progress {
// Connect to your views here
}
#pragma mark - handle error
- (void) handleErrorWithText:(NSString *) text {
//notify your views here
self.currentFetcher = nil;
self.isUploading = NO;
self.progressBar.alpha = 0;
self.uploadButton.alpha = 1;
}
#pragma mark - interface callbacks
//step one, authorize
- (void)startUpload {
if ( self.signedAuth ) {
//authentication present, start upload
} else {
//get vimeo authentication
NSURL *requestURL = [NSURL URLWithString:VIMEO_REQUEST_TOKEN_URL];
NSURL *accessURL = [NSURL URLWithString:VIMEO_ACCESS_TOKEN_URL];
NSURL *authorizeURL = [NSURL URLWithString:VIMEO_AUTHORIZATION_URL];
NSString *scope = #"";
GTMOAuthAuthentication *auth = [self vimeoAuth];
// set the callback URL to which the site should redirect, and for which
// the OAuth controller should look to determine when sign-in has
// finished or been canceled
//
// This URL does not need to be for an actual web page
[auth setCallback:#"http://www.....com/OAuthCallback"];
// Display the autentication view
GTMOAuthViewControllerTouch *viewController;
viewController = [[[GTMOAuthViewControllerTouch alloc] initWithScope:scope
language:nil
requestTokenURL:requestURL
authorizeTokenURL:authorizeURL
accessTokenURL:accessURL
authentication:auth
appServiceName:#"Vimeo"
delegate:self
finishedSelector:#selector(viewController:finishedWithAuth:error:)] autorelease];
[[self navigationController] pushViewController:viewController
animated:YES];
}
}
//step two get upload ticket
- (void)viewController:(GTMOAuthViewControllerTouch *)viewController
finishedWithAuth:(GTMOAuthAuthentication *)auth
error:(NSError *)error {
if (error != nil) {
[self handleErrorWithText:nil];
} else {
self.signedAuth = auth;
[self startUpload];
}
}
- (void) startUpload {
self.isUploading = YES;
NSURL *url = [NSURL URLWithString:#"http://vimeo.com/api/rest/v2?format=json&method=vimeo.videos.upload.getQuota"];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[self.signedAuth authorizeRequest:request];
GTMHTTPFetcher* myFetcher = [GTMHTTPFetcher fetcherWithRequest:request];
[myFetcher beginFetchWithDelegate:self
didFinishSelector:#selector(myFetcher:finishedWithData:error:)];
self.currentFetcher = myFetcher;
}
- (void) myFetcher:(GTMHTTPFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *) error {
if (error != nil) {
[self handleErrorWithText:nil];
NSLog(#"error %#", error);
} else {
NSString *info = [[NSString alloc] initWithData:data encoding:NSASCIIStringEncoding];
NSDictionary *result = [info JSONValue];
//quota
int quota = [[result valueForKeyPath:#"user.upload_space.max"] intValue];
//get video file size
NSString *path;
path = #"local video path";
NSFileManager *manager = [NSFileManager defaultManager];
NSDictionary *attrs = [manager attributesOfItemAtPath:path error: NULL];
UInt32 size = [attrs fileSize];
if ( size > quota ) {
[self handleErrorWithText:#"Your Vimeo account quota is exceeded."];
return;
}
//lets assume we have enough quota
NSURL *url = [NSURL URLWithString:#"http://vimeo.com/api/rest/v2?format=json&method=vimeo.videos.upload.getTicket&upload_method=streaming"];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[self.signedAuth authorizeRequest:request];
GTMHTTPFetcher* myFetcher = [GTMHTTPFetcher fetcherWithRequest:request];
[myFetcher beginFetchWithDelegate:self
didFinishSelector:#selector(myFetcher2:finishedWithData:error:)];
self.currentFetcher = myFetcher;
}
}
- (void) myFetcher2:(GTMHTTPFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *) error {
if (error != nil) {
[self handleErrorWithText:nil];
NSLog(#"error %#", error);
} else {
NSString *info = [[NSString alloc] initWithData:data encoding:NSASCIIStringEncoding];
NSDictionary *result = [info JSONValue];
//fail here if neccessary TODO
NSString *urlString = [result valueForKeyPath:#"ticket.endpoint"];
self.currentTicketID = [result valueForKeyPath:#"ticket.id"];
if ( [self.currentTicketID length] == 0 || [urlString length] == 0) {
[self handleErrorWithText:nil];
return;
}
//get video file
// load the file data
NSString *path;
path = [MMMovieRenderer sharedRenderer].localVideoURL;
//get video file size
NSFileManager *manager = [NSFileManager defaultManager];
NSDictionary *attrs = [manager attributesOfItemAtPath:path error: NULL];
UInt32 size = [attrs fileSize];
//insert endpoint here
NSURL *url = [NSURL URLWithString:urlString];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:#"PUT"];
[request setValue:[NSString stringWithFormat:#"%i", size] forHTTPHeaderField:#"Content-Length"];
[request setValue:#"video/mp4" forHTTPHeaderField:#"Content-Type"];
[request setHTTPBody:[NSData dataWithContentsOfFile:path]];
[self.signedAuth authorizeRequest:request];
GTMHTTPFetcher* myFetcher = [GTMHTTPFetcher fetcherWithRequest:request];
myFetcher.sentDataSelector = #selector(myFetcher:didSendBytes:totalBytesSent:totalBytesExpectedToSend:);
[myFetcher beginFetchWithDelegate:self
didFinishSelector:#selector(myFetcher3:finishedWithData:error:)];
self.currentFetcher = myFetcher;
}
}
- (void)myFetcher:(GTMHTTPFetcher *)fetcher
didSendBytes:(NSInteger)bytesSent
totalBytesSent:(NSInteger)totalBytesSent
totalBytesExpectedToSend:(NSInteger)totalBytesExpectedToSend {
NSLog(#"%i / %i", totalBytesSent, totalBytesExpectedToSend);
[self setProgress:(float)totalBytesSent / (float) totalBytesExpectedToSend];
self.uploadLabel.text = #"Uploading to Vimeo...";
}
- (void) myFetcher3:(GTMHTTPFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *) error {
if (error != nil) {
[self handleErrorWithText:nil];
} else {
NSString *info = [[NSString alloc] initWithData:data encoding:NSASCIIStringEncoding];
//finalize upload
NSString *requestString = [NSString stringWithFormat:#"http://vimeo.com/api/rest/v2?format=json&method=vimeo.videos.upload.complete&ticket_id=%#&filename=%#", self.currentTicketID, #"movie.mov"];
NSURL *url = [NSURL URLWithString:requestString];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[self.signedAuth authorizeRequest:request];
GTMHTTPFetcher* myFetcher = [GTMHTTPFetcher fetcherWithRequest:request];
[myFetcher beginFetchWithDelegate:self
didFinishSelector:#selector(myFetcher4:finishedWithData:error:)];
self.currentFetcher = myFetcher;
}
}
- (void) myFetcher4:(GTMHTTPFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *) error {
if (error != nil) {
[self handleErrorWithText:nil];
} else {
//finish upload
NSString *info = [[NSString alloc] initWithData:data encoding:NSASCIIStringEncoding];
NSDictionary *result = [info JSONValue];
self.currentVideoID = [result valueForKeyPath:#"ticket.video_id"];
if ( [self.currentVideoID length] == 0 ) {
[self handleErrorWithText:nil];
return;
}
//set title
NSString *title = [MMMovieSettingsManager sharedManager].movieTitle;
title = [title stringByAddingPercentEscapesUsingEncoding:NSASCIIStringEncoding];
NSString *requestString = [NSString stringWithFormat:#"http://vimeo.com/api/rest/v2?format=json&method=vimeo.videos.setTitle&video_id=%#&title=%#", self.currentVideoID, title];
NSLog(#"%#", requestString);
NSURL *url = [NSURL URLWithString:requestString];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[self.signedAuth authorizeRequest:request];
GTMHTTPFetcher* myFetcher = [GTMHTTPFetcher fetcherWithRequest:request];
[myFetcher beginFetchWithDelegate:self
didFinishSelector:#selector(myFetcher5:finishedWithData:error:)];
}
}
- (void) myFetcher5:(GTMHTTPFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *) error {
if (error != nil) {
[self handleErrorWithText:nil];
NSLog(#"error %#", error);
} else {
//set description
NSString *desc = #"Video created with ... iPhone App.";
desc = [desc stringByAddingPercentEscapesUsingEncoding:NSASCIIStringEncoding];
NSString *requestString = [NSString stringWithFormat:#"http://vimeo.com/api/rest/v2?format=json&method=vimeo.videos.setDescription&video_id=%#&description=%#", self.currentVideoID, desc];
NSURL *url = [NSURL URLWithString:requestString];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[self.signedAuth authorizeRequest:request];
GTMHTTPFetcher* myFetcher = [GTMHTTPFetcher fetcherWithRequest:request];
[myFetcher beginFetchWithDelegate:self
didFinishSelector:#selector(myFetcher6:finishedWithData:error:)];
}
}
- (void) myFetcher6:(GTMHTTPFetcher *)fetcher finishedWithData:(NSData *)data error:(NSError *) error {
if (error != nil) {
[self handleErrorWithText:nil];
NSLog(#"error %#", error);
} else {
//done
//alert your views that the upload has been completed
}
}
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view from its nib.
[self setProgress:0];
}
- (void) viewDidDisappear:(BOOL)animated {
[super viewDidDisappear:animated];
[GTMOAuthViewControllerTouch removeParamsFromKeychainForName:#"Vimeo"];
}
#pragma mark - oauth stuff
- (GTMOAuthAuthentication *)vimeoAuth {
NSString *myConsumerKey = VIMEO_CONSUMER_KEY; // pre-registered with service
NSString *myConsumerSecret = VIMEO_SECRET; // pre-assigned by service
GTMOAuthAuthentication *auth;
auth = [[[GTMOAuthAuthentication alloc] initWithSignatureMethod:kGTMOAuthSignatureMethodHMAC_SHA1
consumerKey:myConsumerKey
privateKey:myConsumerSecret] autorelease];
// setting the service name lets us inspect the auth object later to know
// what service it is for
auth.serviceProvider = #"Vimeo";
return auth;
}
#end
#import <Foundation/Foundation.h>
#protocol vimeodelagate;
#interface Vimeo_uploader : NSObject<NSURLSessionDelegate, NSURLSessionTaskDelegate>
#property(weak) id<vimeodelagate> delegate;
+(id)SharedManger;
-(void)pass_data_header:(NSData *)videoData;
- (void)Give_title_to_video:(NSString *)VIdeo_id With_name:(NSString *)name ;
#end
#protocol vimeodelagate <NSObject>
-(void)vimeouploader_succes:(NSString *)link methodName:(NSString *)methodName;
-(void)vimeouploader_progress:(int64_t)totalBytesSent totalBytesExpectedToSend:(int64_t)totalByte;
-(void)vimeouploader_error:(NSError *)error methodName:(NSString *)methodName;
#end
#define Aurtorizartion #"bearer 123456789" // replace 123456789 with your token, bearer text will be there
#define accept #"application/vnd.vimeo.*+json; version=3.2"
#import "Vimeo_uploader.h"
#implementation Vimeo_uploader
+(id)SharedManger{
static Vimeo_uploader *Vimeouploader = nil;
#synchronized (self) {
static dispatch_once_t oncetoken;
dispatch_once(&oncetoken, ^{
Vimeouploader = [[self alloc] init];
});
}
return Vimeouploader;
}
-(id)init{
if (self = [super init]) {
}
return self;
}
- (void)pass_data_header:(NSData *)videoData{
NSString *tmpUrl=[[NSString alloc]initWithFormat:#"https://api.vimeo.com/me/videos?type=streaming&redirect_url=&upgrade_to_1080=false"];
NSMutableURLRequest *request=[NSMutableURLRequest requestWithURL:[NSURL URLWithString:tmpUrl] cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:0];
[request setHTTPMethod:#"POST"];
[request setValue:Aurtorizartion forHTTPHeaderField:#"Authorization"];
[request setValue:accept forHTTPHeaderField:#"Accept"];//change this according to your need.
NSError *error;
NSData *returnData = [NSURLConnection sendSynchronousRequest: request returningResponse: nil error: &error];
NSDictionary * json = [NSJSONSerialization JSONObjectWithData:returnData options:kNilOptions error:&error];
if (!error) {
[self call_for_ticket:[json valueForKey:#"upload_link_secure"] complet_url:[json valueForKey:#"complete_uri"] videoData:videoData];
}else{
NSLog(#"RESPONSE--->%#",json);
}
}
- (void)call_for_ticket:(NSString *)upload_url complet_url:(NSString *)complet_uri videoData:(NSData *)videoData{
NSURLSessionConfiguration *configuration;
//configuration.timeoutIntervalForRequest = 5;
//configuration.timeoutIntervalForResource = 5;
configuration.HTTPMaximumConnectionsPerHost = 1;
configuration.allowsCellularAccess = YES;
// configuration.networkServiceType = NSURLNetworkServiceTypeBackground;
configuration.discretionary = NO;
NSURLSession *session = [NSURLSession sessionWithConfiguration:configuration
delegate:self
delegateQueue:[NSOperationQueue mainQueue]];
NSURL *url = [NSURL URLWithString:upload_url];
NSMutableURLRequest *urlRequest = [NSMutableURLRequest requestWithURL:url];
[urlRequest setHTTPMethod:#"PUT"];
[urlRequest setTimeoutInterval:0];
[urlRequest setValue:Aurtorizartion forHTTPHeaderField:#"Authorization"];
[urlRequest setValue:accept forHTTPHeaderField:#"Accept"];
NSError *error;
NSString *str_lenth = [NSString stringWithFormat:#"%lu",(unsigned long)videoData.length];
NSDictionary *dict = #{#"str_lenth":str_lenth,
#"Content-Type":#"video/mp4"};
NSData *postData12 = [NSJSONSerialization dataWithJSONObject:dict options:0 error:&error];
[urlRequest setHTTPBody:postData12];
// [urlRequest setHTTPBody:videoData];
// You could try use uploadTaskWithRequest fromData
NSURLSessionUploadTask *taskUpload = [session uploadTaskWithRequest:urlRequest fromData:videoData completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
NSHTTPURLResponse *httpResp = (NSHTTPURLResponse*) response;
if (!error && httpResp.statusCode == 200) {
[self call_complete_uri:complet_uri];
} else {
if([self.delegate respondsToSelector:#selector(vimeouploader_error:methodName:)]){
[self.delegate vimeouploader_error:error methodName:#"vimeo"];}
NSLog(#"ERROR: %# AND HTTPREST ERROR : %ld", error, (long)httpResp.statusCode);
}
}];
[taskUpload resume];
}
-(void)call_complete_uri:(NSString *)complettion_url{
NSString *str_url =[NSString stringWithFormat:#"https://api.vimeo.com%#",complettion_url];
NSMutableURLRequest *request=[NSMutableURLRequest requestWithURL:[NSURL URLWithString:str_url] cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:0];
[request setHTTPMethod:#"DELETE"];
[request setValue:Aurtorizartion forHTTPHeaderField:#"Authorization"];
[request setValue:accept forHTTPHeaderField:#"Accept"];
//change this according to your need.
[NSURLConnection sendAsynchronousRequest:request queue:[NSOperationQueue mainQueue] completionHandler:^(NSURLResponse *response, NSData *data, NSError *error) {
NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*)response;
if ([httpResponse statusCode] == 201) {
NSDictionary *dict = [[NSDictionary alloc]initWithDictionary:[httpResponse allHeaderFields]];
if (dict) {
if([self.delegate respondsToSelector:#selector(vimeouploader_succes:methodName:)]){
// [self.delegate vimeouploader_succes:[dict valueForKey:#"Location"] methodName:#"vimeo"];
NSLog(#"sucesses");
NSString *str = [NSString stringWithFormat:#"title"];
[self Give_title_to_video:[dict valueForKey:#"Location"] With_name:str];
}else{
if([self.delegate respondsToSelector:#selector(vimeouploader_error:methodName:)]){
[self.delegate vimeouploader_error:error methodName:#"vimeo"];}
}
}
}else{
//9
if([self.delegate respondsToSelector:#selector(vimeouploader_error:methodName:)]){
[self.delegate vimeouploader_error:error methodName:#"vimeo"];}
NSLog(#"%#",error.localizedDescription);
}
}];
}
- (void)Give_title_to_video:(NSString *)VIdeo_id With_name:(NSString *)name {
NSString *tmpUrl=[[NSString alloc]initWithFormat:#"https://api.vimeo.com%#",VIdeo_id];
NSMutableURLRequest *request=[NSMutableURLRequest requestWithURL:[NSURL URLWithString:tmpUrl] cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:0];
[request setHTTPMethod:#"PATCH"];
[request setValue:Aurtorizartion forHTTPHeaderField:#"Authorization"];
[request setValue:accept forHTTPHeaderField:#"Accept"];//change this according to your need.
NSError *error;
NSData *returnData = [NSURLConnection sendSynchronousRequest: request returningResponse: nil error: &error];
NSDictionary * json = [NSJSONSerialization JSONObjectWithData:returnData options:kNilOptions error:&error];
NSString *str_description = #"description";
NSDictionary *dict = #{#"name":name,
#"description":str_description,
#"review_link":#"false"
};
NSData *postData12 = [NSJSONSerialization dataWithJSONObject:dict options:0 error:&error];
[request setHTTPBody:postData12];
if (!error) {
NSLog(#"RESPONSE--->%#",json);
[self.delegate vimeouploader_succes:[json valueForKey:#"link"] methodName:#"vimeo"];
}else{
if([self.delegate respondsToSelector:#selector(vimeouploader_error:methodName:)]){
[self.delegate vimeouploader_error:error methodName:#"vimeo"];}
//NSLog(#"%#",error.localizedDescription);
NSLog(#"Give_title_to_video_error--->%#",error);
}
}
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didSendBodyData:(int64_t)bytesSent totalBytesSent:(int64_t)totalBytesSent totalBytesExpectedToSend:(int64_t)totalBytesExpectedToSend {
NSLog(#"didSendBodyData: %lld, totalBytesSent: %lld, totalBytesExpectedToSend: %lld", bytesSent, totalBytesSent, totalBytesExpectedToSend);
if([self.delegate respondsToSelector:#selector(vimeouploader_progress:totalBytesExpectedToSend:)]){
[self.delegate vimeouploader_progress:totalBytesSent totalBytesExpectedToSend:totalBytesExpectedToSend];}
}
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
if (error == nil) {
NSLog(#"Task: %# upload complete", task);
} else {
NSLog(#"Task: %# upload with error: %#", task, [error localizedDescription]);
}
}
#end
The vimeo-Api is enough. Take a closer look to the vimeo-upload-api
The interface can be used in any language which is able to send network-data. You have to create some NSURLConnections and you have to set the HTTP-Body like in their examples.
I wrote AFNetworking Client for Vimeo API - https://github.com/m1entus/RWMViemoClient