I am using ASI to download files and I keep seeing ASIFileManagementError. I am guessing that means that there is something wrong with how I'm building the download paths for my requests but it's not consistent. Sometimes the download works just fine and other times it fails. Even when using the same code on the same device to download the same file! Here is my code.
-(ASIHTTPRequest*)buildDownloadLinkForUpdate:(ContentItem*)update
{
NSString *URLString = [[NSString alloc] initWithFormat:#"%#?%#=%#", update.downloadUrl.absoluteString, #"auth_token", database.userAuthToken];
NSURL *url = [NSURL URLWithString:URLString];
ASIHTTPRequest *request = [ASIHTTPRequest requestWithURL:url];
[request setRequestMethod:#"GET"];
ContentItem* item = [database getItemWithId:update.uniqueId];
[request setDownloadDestinationPath:item.contentPath];
[request setTemporaryFileDownloadPath:[[AppSettings instance].temporaryPath stringByAppendingPathComponent:item.fileName]];
[request setAllowResumeForFileDownloads:TRUE];
[request setShowAccurateProgress: TRUE];
[request setDelegate:[_currentItem progressDelegate]];
return request;
}
-(void)initalizeNetworkQueue
{
if(!networkQueue) networkQueue = [[ASINetworkQueue alloc] init];
[networkQueue cancelAllOperations];
[networkQueue reset];
if([_currentItem progressDelegate])
{
[networkQueue setDownloadProgressDelegate:[_currentItem progressDelegate]];
}
[networkQueue setDelegate:self];
[networkQueue setRequestDidFinishSelector:#selector(networkQueueComplete:)];
[networkQueue setRequestDidFailSelector:#selector(networkQueueFailed:)];
[networkQueue setShowAccurateProgress:YES];
networkQueue.maxConcurrentOperationCount = 1;
}
And then here is the code that actually invokes this:
[self initalizeNetworkQueue];
[networkQueue addOperation:[self buildDownloadLinkForUpdate:_currentUpdate]];
[networkQueue go];
currentState = ContentUpdaterStateDownloading;
Is there something obviously wrong here?
-= UPDATE=-
It's saying that it's failing because it's unable to move the file from the temporary location to the final location.
Download Failed: Failed to move file from '/var/mobile/Applications/33E1DF3C-17F5-432F-8204-A9B53AB5AAE3/Documents/.temp/FileShare+Gate+4.pptx' to '/var/mobile/Applications/33E1DF3C-17F5-432F-8204-A9B53AB5AAE3/Documents/.content/FileShare+Gate+4.pptx'
I had this error before, it was in the connection, it is of type ASINetworkErrorType, it means that the host cannot be reached.
Anyway ASIHttprequest is dead now, you will not find answers for many questions you have, take my advice and go with AFNetworking, it is great and do the job.
Related
I am developing a application which uses ASIHTTPRequest to download the content from server. When downloading if I move from Portrait to Landscape mode the downloads process is going to stop. I need the download process still to be continued.
I have searched for the solution in stackoverflow but no useful.
How can I solve this problem...
This is the piece of code i am using to download.
NSURL *downloadURL = [publisher contentURLForIssueWithName:issueTitle];
if (!networkQueue) {
networkQueue = [[ASINetworkQueue alloc] init];
}
if(!downloadURL) return;
[self performSelectorInBackground:#selector(read) withObject:nil];
request = [ASIHTTPRequest requestWithURL:downloadURL];
[request setDelegate:self];
[request setDownloadProgressDelegate:progressView];
[request setShowAccurateProgress:YES];
request.shouldContinueWhenAppEntersBackground=YES;
request.allowResumeForFileDownloads=YES;
[request startAsynchronous];
Any help to be appreciated..
Ok, this seems like it should be very simple - All I want to do is call my ServerConnect.m (NSObject), NSURL Connection Request Method, from my SignIn.m (ViewController) and stop the UIActivityIndicatorView after the NSURL Request has completed. Of course, if I do it all on the main thread:
- (IBAction)forgotPassword:(id)sender {
[activityIndicator startAnimating];
connection = [[ServerConnect alloc] init];
[connection sendUserPassword:email withSecurity:securityID];
[activityIndicator stopAnimating];
}
Then, everything will then execute concurrently, and the activity indicator will start and stop before the connection method finishes...
Thus, I attempted to place the connection request on a secondary thread:
- (IBAction)forgotPassword:(id)sender {
[NSThread detachNewThreadSelector: #selector(requestNewPassword:) toTarget:self withObject:userEmail.text];
}
- (void) requestNewPassword:(NSString *)email
{
[self->thinkingIndicator performSelectorOnMainThread:#selector(startAnimating) withObject:nil waitUntilDone:NO];
//Make NSURL Connection to server on secondary thread
NSString *securityID = [[NSString alloc] init];
securityID = #"security";
connection = [[ServerConnect alloc] init];
[connection sendUserPassword:email withSecurity:securityID];
[self->thinkingIndicator performSelectorOnMainThread:#selector(stopAnimating) withObject:nil waitUntilDone:NO];
}
But, I don't see the activity indicators here either, which may be due the NSURL Request not functioning properly on the secondary thread (i.e. for some reason, it does not gather an xml string as it does when requested on the main thread).
What is the proper way to architecture my code to make this work? I am surprised at how much work has been involved in trying to figure out how to get my activity indicator to simply stop after a method from another file has finished executing. Is there a way to run the code in series (one after another) and not concurrently? Any help would be appreciated.
Updated to Show: sendUserPassword:(NSString *)withSecurity:(NSString *)
- (void)sendUserPassword:(NSString *)emailString
withSecurity:(NSString *)passCode;
{
NSLog(#"Making request for user's password");
newUser = NO;
fbUser = NO;
forgotPassword = YES;
NSString *post = [NSString stringWithFormat: #"email=%#&s=%#", emailString, passCode];
NSData *postData = [post dataUsingEncoding:NSUTF8StringEncoding];
//Construct the web service URL
NSURL *url = [NSURL URLWithString:#"http://www.someurl.php"];
//Create a request object with that URL
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url
cachePolicy:NSURLRequestReloadIgnoringCacheData
timeoutInterval:90];
[request setURL:url];
[request setHTTPMethod:#"POST"];
[request setHTTPBody:postData];
//Clear out the existing connection if there is one
if(connectionInProgress) {
[connectionInProgress cancel];
}
//Instantiate the object to hold all incoming data
xmlData = [[NSMutableData alloc] init];
//Create and initiate the conection - non-blocking
connectionInProgress = [[NSURLConnection alloc] initWithRequest: request
delegate:self
startImmediately:YES];
}
One suggestion try like this:
- (IBAction)forgotPassword:(id)sender
{
[self->thinkingIndicator startAnimating];
[NSThread detachNewThreadSelector: #selector(requestNewPassword:) toTarget:self withObject:userEmail.text];
}
- (void) requestNewPassword:(NSString *)email
{
//Make NSURL Connection to server on secondary thread
NSString *securityID = [[NSString alloc] init];
securityID = #"security";
connection = [[ServerConnect alloc] init];
[connection sendUserPassword:email withSecurity:securityID];
[self->thinkingIndicator performSelectorOnMainThread:#selector(stopAnimating) withObject:nil waitUntilDone:NO];
}
I ended up incorporating the NSNotification system (see Multithreading for iOS) to solve my problem. Any reason why this would be frowned upon:
"One easy way to send updates from one part of your code to another is Apple’s built-in NSNotification system.
It’s quite simple. You get the NSNotificationCenter singleton (via [NSNotificationCenter defaultCenter]) and:
1.) If you have an update you want to send, you call postNotificationName. You just give it a unique string you make up (such as “com.razeware.imagegrabber.imageupdated”) and an object (such as the ImageInfo that just finished downloading its image).
2.) If you want to find out when this update happens, you call addObserver:selector:name:object. In our case the ImageListViewController will want to know when this happens so it can reload the appropriate table view cell. A good spot to put this is in viewDidLoad.
3.) Don’t forget to call removeObserver:name:object when the view gets unloaded. Otherwise, the notification system might try to call a method on an unloaded view (or worse an unallocated object), which would be a bad thing!"
You could try something this, it uses a block when it is finished. I had similar thing right here.
// Turn indicator on
// Setup the request
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:urlString]];
[request setTimeoutInterval: 90.0];
[request setHTTPMethod:#"POST"];
[request setHTTPBody:postData];
request.cachePolicy = NSURLRequestReturnCacheDataElseLoad;
[NSURLConnection sendAsynchronousRequest:request
queue:[NSOperationQueue currentQueue]
completionHandler:^(NSURLResponse *response, NSData *data, NSError *error) {
// Its has finished but sort out the result (test for data and HTTP 200 i.e. not 404)
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
if (data != nil && error == nil && [httpResponse statusCode] == 200)
{
// Connection finished a gooden
// Do whatever you like with data
// Stop indicator
}
else
{
// There was an error, alert the user
// Do whatever you like with data
// Stop indicator
}
}];
I am uploading Image to server. Length Of NSData will depend On the size of image. if image is too big, NSData length will be 6798791 (length will vary). if image is small Request is getting Uploaded to server. if request it too big (Contains very big image) request is not getting uploaded. Below is request format of an image.
<vaayoo:message xmlns:vaayoo="http://www.vaayoo.com<vaayoo:ostype>iphone</vaayoo:ostype><vaayoo:osversion>8</vaayoo:osversion><vaayoo:deviceid>354043043430851</vaayoo:deviceid><vaayoo:sku>lite</vaayoo:sku><vaayoo:xmlversion>1.0</vaayoo:xmlversion></vaayoo:header><vaayoo:vaayoodata xmlns:vaayoo="http://www.vaayoo.com/version2/yooml" datatype="content" mobiletid="8DD7A158-FC05-4588-B4D6-39D93F10E504" formname="frm_reportupload" streamid="A58BFEAF-E566-4ddc-842D-F8C5976FC300"><vaayoo:event type="control_click" name="btn_submit"><vaayoo:action type="form.asyncsubmit" url="http://content.vaayoo.com/AppsPlatForm/PhotoReportCreatorService/PhotoReportCreator.svc/PhotoreportResponse" asyncurl="http://content.vaayoo.com/AppsPlatForm/ConentUploadService/1_1/MyuploadService.svc/UploadData"/></vaayoo:event><vaayoo:data type="formdata" collection="true"><vaayoo:input name="img_0" type="image" filename="01262013035548648.jpg" currentchunk="18" totalchunk="18">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</vaayoo:input><vaayoo:input name="txt_rpt_name" type="text" textmode="multiline">anil dairy</vaayoo:input></vaayoo:data></vaayoo:vaayoodata></vaayoo:message>
Below is the method which is writing the data to server.
-(BOOL)write:(NSData *)data toURI:(NSString *)URI
{
BOOL retVal = NO;
NSString* requestDataLengthString = [[NSString alloc] initWithFormat:#"%d", [data length]];
NSLog(#"Data length is %#",requestDataLengthString);
NSLog(#"Urlis %#",URI);
NSRange range = [URI rangeOfString:#"http"];//Is http?
if(range.location != NSNotFound)
{
//Yes, http
NSMutableURLRequest *httpRequest = [[NSMutableURLRequest alloc] initWithURL: [NSURL URLWithString:URI]];
[httpRequest setHTTPMethod:#"POST"];
[httpRequest setHTTPBody:data];
[httpRequest setValue:#"application/xml" forHTTPHeaderField:#"Content-Type"];
[httpRequest setValue:requestDataLengthString forHTTPHeaderField:#"Content-Length"];
NSURLConnection *theConnection=[[NSURLConnection alloc] initWithRequest:httpRequest delegate:self];
[theConnection release];
[httpRequest release];
if (theConnection)
{
receivedData=[[NSMutableData data] retain];
retVal = YES;
}
else
{
NSError *error = [NSError alloc];
NSLog(#"Connection failed! Error - %# %#",
[error localizedDescription],
[[error userInfo] objectForKey:NSURLErrorFailingURLStringErrorKey]);
[error release];
retVal = NO;
}
}
return retVal;
}
What am i doing wrong in Write method ? it works fine for small images, but doesn't work for bigger images, not even getting any kind of exception if i try to upload big images. How to troubleshoot this problem. Help me out plz.. Thanks in advance..
Have you tried using the asynchronous upload with NSURLConnection delegates? Probably the error might show up there. What language are you using for the webservice? It could be the setting on your webserver that makes it fail to upload big image. Try to see the maximum request length that is set on your server. If it's smaller than the image size, then it would fail.
Use NSTimeoutInterval and try its working:
NSMutableURLRequest *request1 = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:urlString] cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:1000.0];
Instead of using:
[httpRequest setHTTPBody:data];
Use:
NSInputStream *stream = [[NSInputStream alloc] initWithFileAtPath:filePath];
request setHTTPBodyStream:stream];
Apple has an example of this.
I have a problem with uploading big video asset to a server from PhotoLibrary.
I get my asset data as described here, export the video to local document, and then upload.
But when I upload a big video (2 minutes and about 300Mb or more in size), this method causes a crash and I got no reason nor any any information.
I use webDAV to upload files just like this:
// Set up credentials
NSURLCredential *userCredentials = [NSURLCredential credentialWithUser:username
password:password
persistence:NSURLCredentialPersistenceForSession];
NSURLProtectionSpace *space = [[NSURLProtectionSpace alloc] initWithHost:host
port:80
protocol:#"http"
realm:#" webDAV"
authenticationMethod:nil];
[[NSURLCredentialStorage sharedCredentialStorage] setCredential:userCredentials forProtectionSpace:space];
[space release];
// Create the request
NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:#"PUT"];
[request setValue:[self mimetypeForFile:self.filepath] forHTTPHeaderField:#"Content-Type"];
NSNumber *contentLength = (NSNumber *) [[[NSFileManager defaultManager]
attributesOfItemAtPath:self.filepath error:NULL]
objectForKey:NSFileSize];
[request setValue:[contentLength description] forHTTPHeaderField:#"Content-Length"];
if (self.useStreaming)
{
if (self.currentFileStream!=nil)
{
[self.currentFileStream close], self.currentFileStream = nil;
}
self.currentFileStream = [NSInputStream inputStreamWithFileAtPath:self.filepath];
if (currentFileStream!=nil)
{
[request setHTTPBodyStream:currentFileStream];
}
else
{
[request setHTTPBody:[NSData dataWithContentsOfFile:self.filepath]];
}
}
else
{
[request setHTTPBody:[NSData dataWithContentsOfFile:self.filepath]];
}
NSURLConnection* conn = [[NSURLConnection alloc] initWithRequest:request delegate:self];
if (self.currentConnection!=nil)
{
self.currentConnection = nil;
}
self.currentConnection = conn;
[conn release];
[self.currentConnection start];
When the code reache this line:
self.currentFileStream = [NSInputStream inputStreamWithFileAtPath:self.filepath];
[request setHTTPBodyStream:currentFileStream];
OR:
[request setHTTPBody:[NSData dataWithContentsOfFile:self.filepath]];
It crashed.
Do you have any suggestion?
Thanks.
========================
Edit: It crash at setHTTPBody: OR setHTTPBodyStream:
So I think it's about memory leak or something.
================
EDIT2: Now I decide to compress video, I get video data by current method is too large(more than 300mb), But I find use UIImagePickerController select the same video, it just 30mb; So compress is help; I'll try UIVideoEditorController, and will post my result soon;
Completed. the solution is try to compress big video to small file;
1.just like before, export video asset to tmp directory;
2.use UIVideoEditorController to compress the video file;
3.just upload compressed file like the code I post.
That's all.
check following post , where i am uploading image on server, instead of image you can post your video Uploading Image via POST in Objective C
I am downloading a bunch of images via ASINetworkQueue. I have no problems in the simulator, but on the iPad some of the images (each time they are different) are not downloaded. How can I fix this?
Here is the code:
Queue Creation:
if (addedPaintings > 0) {
[currentPaintingsArray addObjectsFromArray:objectsToAdd];
[unseenPaintings addObjectsFromArray:objectsToAdd];
[self downloadImages];
}
// update plist file if data was altered.
if (addedPaintings > 0 || removedPaintings > 0)
[currentPaintingsArray writeToFile:dataFilePath atomically:YES];
else
[self completeSync:request.responseStatusCode];
}
Image Download method:
- (void) downloadImages {
[networkQueue reset];
[networkQueue setDelegate:self];
[networkQueue setShowAccurateProgress:YES];
[networkQueue setDownloadProgressDelegate:self.progressView.customView];
[networkQueue setQueueDidFinishSelector:#selector(imageQueueDownloadComplete:)];
for (NSDictionary *dict in [Globals sharedGlobals].unseenPaintings) {
NSString *link = [dict objectForKey:#"link"];
NSString *smallLink = [dict objectForKey:#"smallLink"];
if ([link length] != 0) {
NSURL *url = [NSURL URLWithString:[[URL stringByAppendingString:GALLERY] stringByAppendingString: link]];
ASIHTTPRequest *downloadRequest = [[ASIHTTPRequest alloc] initWithURL:url];
[downloadRequest setDownloadDestinationPath:[documentsDirectory stringByAppendingPathComponent:link]];
[downloadRequest setDidFailSelector:#selector(imageDownloadFailed:)];
[downloadRequest setDidFinishSelector:#selector(imageDownloadComplete:)];
[downloadRequest setUserInfo:dict];
[downloadRequest setDelegate:self];
[networkQueue addOperation:downloadRequest];
[downloadRequest release];
NSURL *urlCarousel = [NSURL URLWithString:[[URL stringByAppendingString:WS_IMAGES] stringByAppendingString: smallLink]];
downloadRequest = [[ASIHTTPRequest alloc] initWithURL:urlCarousel];
[downloadRequest setDownloadDestinationPath:[documentsDirectory stringByAppendingPathComponent:smallLink]];
[downloadRequest setDidFailSelector:#selector(imageDownloadFailed:)];
[downloadRequest setUserInfo:dict];
[downloadRequest setDelegate:self];
[networkQueue addOperation:downloadRequest];
[downloadRequest release];
}
}
[networkQueue go];
}
Based on the comments you've left to the question, (Specifically: Also, if I change the download method from networkQueue to [downloadRequest startAsynchronous], everything works.) it may be that your request is timing out when being run synchronously.
Another thing you should know is that the "ASI network classes" are no longer being maintained. The developer offers several alternatives in his blog post announcing the end-of-life of that software.