| /* |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| */ |
| |
| #import "CDVFile.h" |
| #import "NSArray+Comparisons.h" |
| #import "NSDictionary+Extensions.h" |
| #import "CDVJSON.h" |
| #import "NSData+Base64.h" |
| #import <AssetsLibrary/ALAsset.h> |
| #import <AssetsLibrary/ALAssetRepresentation.h> |
| #import <AssetsLibrary/ALAssetsLibrary.h> |
| #import <MobileCoreServices/MobileCoreServices.h> |
| #import "CDVAvailability.h" |
| #import "sys/xattr.h" |
| |
| extern NSString * const NSURLIsExcludedFromBackupKey __attribute__((weak_import)); |
| |
| #ifndef __IPHONE_5_1 |
| NSString* const NSURLIsExcludedFromBackupKey = @"NSURLIsExcludedFromBackupKey"; |
| #endif |
| |
| NSString* const kCDVAssetsLibraryPrefix = @"assets-library://"; |
| |
| @implementation CDVFile |
| |
| @synthesize appDocsPath, appLibraryPath, appTempPath, persistentPath, temporaryPath, userHasAllowed; |
| |
| - (id)initWithWebView:(UIWebView*)theWebView |
| { |
| self = (CDVFile*)[super initWithWebView:theWebView]; |
| if (self) { |
| // get the documents directory path |
| NSArray* paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES); |
| self.appDocsPath = [paths objectAtIndex:0]; |
| |
| paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES); |
| self.appLibraryPath = [paths objectAtIndex:0]; |
| |
| self.appTempPath = [NSTemporaryDirectory ()stringByStandardizingPath]; // remove trailing slash from NSTemporaryDirectory() |
| |
| self.persistentPath = [NSString stringWithFormat:@"/%@", [self.appDocsPath lastPathComponent]]; |
| self.temporaryPath = [NSString stringWithFormat:@"/%@", [self.appTempPath lastPathComponent]]; |
| // NSLog(@"docs: %@ - temp: %@", self.appDocsPath, self.appTempPath); |
| } |
| |
| return self; |
| } |
| |
| - (NSNumber*)checkFreeDiskSpace:(NSString*)appPath |
| { |
| NSFileManager* fMgr = [[NSFileManager alloc] init]; |
| |
| NSError* __autoreleasing pError = nil; |
| |
| NSDictionary* pDict = [fMgr attributesOfFileSystemForPath:appPath error:&pError]; |
| NSNumber* pNumAvail = (NSNumber*)[pDict objectForKey:NSFileSystemFreeSize]; |
| |
| return pNumAvail; |
| } |
| |
| // figure out if the pathFragment represents a persistent of temporary directory and return the full application path. |
| // returns nil if path is not persistent or temporary |
| - (NSString*)getAppPath:(NSString*)pathFragment |
| { |
| NSString* appPath = nil; |
| NSRange rangeP = [pathFragment rangeOfString:self.persistentPath]; |
| NSRange rangeT = [pathFragment rangeOfString:self.temporaryPath]; |
| |
| if ((rangeP.location != NSNotFound) && (rangeT.location != NSNotFound)) { |
| // we found both in the path, return whichever one is first |
| if (rangeP.length < rangeT.length) { |
| appPath = self.appDocsPath; |
| } else { |
| appPath = self.appTempPath; |
| } |
| } else if (rangeP.location != NSNotFound) { |
| appPath = self.appDocsPath; |
| } else if (rangeT.location != NSNotFound) { |
| appPath = self.appTempPath; |
| } |
| return appPath; |
| } |
| |
| /* get the full path to this resource |
| * IN |
| * NSString* pathFragment - full Path from File or Entry object (includes system path info) |
| * OUT |
| * NSString* fullPath - full iOS path to this resource, nil if not found |
| */ |
| |
| /* Was here in order to NOT have to return full path, but W3C synchronous DirectoryEntry.toURI() killed that idea since I can't call into iOS to |
| * resolve full URI. Leaving this code here in case W3C spec changes. |
| -(NSString*) getFullPath: (NSString*)pathFragment |
| { |
| return pathFragment; |
| NSString* fullPath = nil; |
| NSString *appPath = [ self getAppPath: pathFragment]; |
| if (appPath){ |
| |
| // remove last component from appPath |
| NSRange range = [appPath rangeOfString:@"/" options: NSBackwardsSearch]; |
| NSString* newPath = [appPath substringToIndex:range.location]; |
| // add pathFragment to get test Path |
| fullPath = [newPath stringByAppendingPathComponent:pathFragment]; |
| } |
| return fullPath; |
| } */ |
| |
| /* Request the File System info |
| * |
| * IN: |
| * arguments[0] - type (number as string) |
| * TEMPORARY = 0, PERSISTENT = 1; |
| * arguments[1] - size |
| * |
| * OUT: |
| * Dictionary representing FileSystem object |
| * name - the human readable directory name |
| * root = DirectoryEntry object |
| * bool isDirectory |
| * bool isFile |
| * string name |
| * string fullPath |
| * fileSystem = FileSystem object - !! ignored because creates circular reference !! |
| */ |
| |
| - (void)requestFileSystem:(CDVInvokedUrlCommand*)command |
| { |
| NSArray* arguments = command.arguments; |
| |
| // arguments |
| NSString* strType = [arguments objectAtIndex:0]; |
| unsigned long long size = [[arguments objectAtIndex:1] longLongValue]; |
| |
| int type = [strType intValue]; |
| CDVPluginResult* result = nil; |
| |
| if (type > 1) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:NOT_FOUND_ERR]; |
| NSLog(@"iOS only supports TEMPORARY and PERSISTENT file systems"); |
| } else { |
| // NSString* fullPath = [NSString stringWithFormat:@"/%@", (type == 0 ? [self.appTempPath lastPathComponent] : [self.appDocsPath lastPathComponent])]; |
| NSString* fullPath = (type == 0 ? self.appTempPath : self.appDocsPath); |
| // check for avail space for size request |
| NSNumber* pNumAvail = [self checkFreeDiskSpace:fullPath]; |
| // NSLog(@"Free space: %@", [NSString stringWithFormat:@"%qu", [ pNumAvail unsignedLongLongValue ]]); |
| if (pNumAvail && ([pNumAvail unsignedLongLongValue] < size)) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:QUOTA_EXCEEDED_ERR]; |
| } else { |
| NSMutableDictionary* fileSystem = [NSMutableDictionary dictionaryWithCapacity:2]; |
| [fileSystem setObject:(type == TEMPORARY ? kW3FileTemporary:kW3FilePersistent) forKey:@"name"]; |
| NSDictionary* dirEntry = [self getDirectoryEntry:fullPath isDirectory:YES]; |
| [fileSystem setObject:dirEntry forKey:@"root"]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:fileSystem]; |
| } |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* Creates a dictionary representing an Entry Object |
| * |
| * IN: |
| * NSString* fullPath of the entry |
| * FileSystem type |
| * BOOL isDirectory - YES if this is a directory, NO if is a file |
| * OUT: |
| * NSDictionary* |
| Entry object |
| * bool as NSNumber isDirectory |
| * bool as NSNumber isFile |
| * NSString* name - last part of path |
| * NSString* fullPath |
| * fileSystem = FileSystem object - !! ignored because creates circular reference FileSystem contains DirectoryEntry which contains FileSystem.....!! |
| */ |
| - (NSDictionary*)getDirectoryEntry:(NSString*)fullPath isDirectory:(BOOL)isDir |
| { |
| NSMutableDictionary* dirEntry = [NSMutableDictionary dictionaryWithCapacity:4]; |
| NSString* lastPart = [fullPath lastPathComponent]; |
| |
| [dirEntry setObject:[NSNumber numberWithBool:!isDir] forKey:@"isFile"]; |
| [dirEntry setObject:[NSNumber numberWithBool:isDir] forKey:@"isDirectory"]; |
| // NSURL* fileUrl = [NSURL fileURLWithPath:fullPath]; |
| // [dirEntry setObject: [fileUrl absoluteString] forKey: @"fullPath"]; |
| [dirEntry setObject:fullPath forKey:@"fullPath"]; |
| [dirEntry setObject:lastPart forKey:@"name"]; |
| |
| return dirEntry; |
| } |
| |
| /* |
| * Given a URI determine the File System information associated with it and return an appropriate W3C entry object |
| * IN |
| * NSString* fileURI - currently requires full file URI |
| * OUT |
| * Entry object |
| * bool isDirectory |
| * bool isFile |
| * string name |
| * string fullPath |
| * fileSystem = FileSystem object - !! ignored because creates circular reference FileSystem contains DirectoryEntry which contains FileSystem.....!! |
| */ |
| - (void)resolveLocalFileSystemURI:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* inputUri = [command.arguments objectAtIndex:0]; |
| |
| // don't know if string is encoded or not so unescape |
| NSString* cleanUri = [inputUri stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding]; |
| // now escape in order to create URL |
| NSString* strUri = [cleanUri stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]; |
| NSURL* testUri = [NSURL URLWithString:strUri]; |
| CDVPluginResult* result = nil; |
| |
| if (!testUri || ![testUri isFileURL]) { |
| // issue ENCODING_ERR |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:ENCODING_ERR]; |
| } else { |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| NSString* path = [testUri path]; |
| // NSLog(@"url path: %@", path); |
| BOOL isDir = NO; |
| // see if exists and is file or dir |
| BOOL bExists = [fileMgr fileExistsAtPath:path isDirectory:&isDir]; |
| if (bExists) { |
| // see if it contains docs path |
| NSRange range = [path rangeOfString:self.appDocsPath]; |
| NSString* foundFullPath = nil; |
| // there's probably an api or easier way to figure out the path type but I can't find it! |
| if ((range.location != NSNotFound) && (range.length == [self.appDocsPath length])) { |
| foundFullPath = self.appDocsPath; |
| } else { |
| // see if it contains the temp path |
| range = [path rangeOfString:self.appTempPath]; |
| if ((range.location != NSNotFound) && (range.length == [self.appTempPath length])) { |
| foundFullPath = self.appTempPath; |
| } |
| } |
| if (foundFullPath == nil) { |
| // error SECURITY_ERR - not one of the two paths types supported |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:SECURITY_ERR]; |
| } else { |
| NSDictionary* fileSystem = [self getDirectoryEntry:path isDirectory:isDir]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:fileSystem]; |
| } |
| } else { |
| // return NOT_FOUND_ERR |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| } |
| } |
| if (result != nil) { |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| } |
| |
| /* Part of DirectoryEntry interface, creates or returns the specified directory |
| * IN: |
| * NSString* fullPath - full path for this directory |
| * NSString* path - directory to be created/returned; may be full path or relative path |
| * NSDictionary* - Flags object |
| * boolean as NSNumber create - |
| * if create is true and directory does not exist, create dir and return directory entry |
| * if create is true and exclusive is true and directory does exist, return error |
| * if create is false and directory does not exist, return error |
| * if create is false and the path represents a file, return error |
| * boolean as NSNumber exclusive - used in conjunction with create |
| * if exclusive is true and create is true - specifies failure if directory already exists |
| * |
| * |
| */ |
| - (void)getDirectory:(CDVInvokedUrlCommand*)command |
| { |
| NSMutableArray* arguments = [NSMutableArray arrayWithArray:command.arguments]; |
| NSMutableDictionary* options = nil; |
| |
| if ([arguments count] >= 3) { |
| options = [arguments objectAtIndex:2 withDefault:nil]; |
| } |
| // add getDir to options and call getFile() |
| if (options != nil) { |
| options = [NSMutableDictionary dictionaryWithDictionary:options]; |
| } else { |
| options = [NSMutableDictionary dictionaryWithCapacity:1]; |
| } |
| [options setObject:[NSNumber numberWithInt:1] forKey:@"getDir"]; |
| if ([arguments count] >= 3) { |
| [arguments replaceObjectAtIndex:2 withObject:options]; |
| } else { |
| [arguments addObject:options]; |
| } |
| CDVInvokedUrlCommand* subCommand = |
| [[CDVInvokedUrlCommand alloc] initWithArguments:arguments |
| callbackId:command.callbackId |
| className:command.className |
| methodName:command.methodName]; |
| |
| [self getFile:subCommand]; |
| } |
| |
| /* Part of DirectoryEntry interface, creates or returns the specified file |
| * IN: |
| * NSString* fullPath - full path for this file |
| * NSString* path - file to be created/returned; may be full path or relative path |
| * NSDictionary* - Flags object |
| * boolean as NSNumber create - |
| * if create is true and file does not exist, create file and return File entry |
| * if create is true and exclusive is true and file does exist, return error |
| * if create is false and file does not exist, return error |
| * if create is false and the path represents a directory, return error |
| * boolean as NSNumber exclusive - used in conjunction with create |
| * if exclusive is true and create is true - specifies failure if file already exists |
| * |
| * |
| */ |
| - (void)getFile:(CDVInvokedUrlCommand*)command |
| { |
| // arguments are URL encoded |
| NSString* fullPath = [command.arguments objectAtIndex:0]; |
| NSString* requestedPath = [command.arguments objectAtIndex:1]; |
| NSDictionary* options = [command.arguments objectAtIndex:2 withDefault:nil]; |
| |
| // return unsupported result for assets-library URLs |
| if ([fullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_MALFORMED_URL_EXCEPTION messageAsString:@"getFile not supported for assets-library URLs."]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| CDVPluginResult* result = nil; |
| BOOL bDirRequest = NO; |
| BOOL create = NO; |
| BOOL exclusive = NO; |
| int errorCode = 0; // !!! risky - no error code currently defined for 0 |
| |
| if ([options valueForKeyIsNumber:@"create"]) { |
| create = [(NSNumber*)[options valueForKey:@"create"] boolValue]; |
| } |
| if ([options valueForKeyIsNumber:@"exclusive"]) { |
| exclusive = [(NSNumber*)[options valueForKey:@"exclusive"] boolValue]; |
| } |
| |
| if ([options valueForKeyIsNumber:@"getDir"]) { |
| // this will not exist for calls directly to getFile but will have been set by getDirectory before calling this method |
| bDirRequest = [(NSNumber*)[options valueForKey:@"getDir"] boolValue]; |
| } |
| // see if the requested path has invalid characters - should we be checking for more than just ":"? |
| if ([requestedPath rangeOfString:@":"].location != NSNotFound) { |
| errorCode = ENCODING_ERR; |
| } else { |
| // was full or relative path provided? |
| NSRange range = [requestedPath rangeOfString:fullPath]; |
| BOOL bIsFullPath = range.location != NSNotFound; |
| |
| NSString* reqFullPath = nil; |
| |
| if (!bIsFullPath) { |
| reqFullPath = [fullPath stringByAppendingPathComponent:requestedPath]; |
| } else { |
| reqFullPath = requestedPath; |
| } |
| |
| // NSLog(@"reqFullPath = %@", reqFullPath); |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| BOOL bIsDir; |
| BOOL bExists = [fileMgr fileExistsAtPath:reqFullPath isDirectory:&bIsDir]; |
| if (bExists && (create == NO) && (bIsDir == !bDirRequest)) { |
| // path exists and is of requested type - return TYPE_MISMATCH_ERR |
| errorCode = TYPE_MISMATCH_ERR; |
| } else if (!bExists && (create == NO)) { |
| // path does not exist and create is false - return NOT_FOUND_ERR |
| errorCode = NOT_FOUND_ERR; |
| } else if (bExists && (create == YES) && (exclusive == YES)) { |
| // file/dir already exists and exclusive and create are both true - return PATH_EXISTS_ERR |
| errorCode = PATH_EXISTS_ERR; |
| } else { |
| // if bExists and create == YES - just return data |
| // if bExists and create == NO - just return data |
| // if !bExists and create == YES - create and return data |
| BOOL bSuccess = YES; |
| NSError __autoreleasing* pError = nil; |
| if (!bExists && (create == YES)) { |
| if (bDirRequest) { |
| // create the dir |
| bSuccess = [fileMgr createDirectoryAtPath:reqFullPath withIntermediateDirectories:NO attributes:nil error:&pError]; |
| } else { |
| // create the empty file |
| bSuccess = [fileMgr createFileAtPath:reqFullPath contents:nil attributes:nil]; |
| } |
| } |
| if (!bSuccess) { |
| errorCode = ABORT_ERR; |
| if (pError) { |
| NSLog(@"error creating directory: %@", [pError localizedDescription]); |
| } |
| } else { |
| // NSLog(@"newly created file/dir (%@) exists: %d", reqFullPath, [fileMgr fileExistsAtPath:reqFullPath]); |
| // file existed or was created |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:[self getDirectoryEntry:reqFullPath isDirectory:bDirRequest]]; |
| } |
| } // are all possible conditions met? |
| } |
| |
| if (errorCode > 0) { |
| // create error callback |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:errorCode]; |
| } |
| |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* |
| * Look up the parent Entry containing this Entry. |
| * If this Entry is the root of its filesystem, its parent is itself. |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath |
| * NSMutableDictionary* options |
| * empty |
| */ |
| - (void)getParent:(CDVInvokedUrlCommand*)command |
| { |
| // arguments are URL encoded |
| NSString* fullPath = [command.arguments objectAtIndex:0]; |
| |
| // we don't (yet?) support getting the parent of an asset |
| if ([fullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_READABLE_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| CDVPluginResult* result = nil; |
| NSString* newPath = nil; |
| |
| if ([fullPath isEqualToString:self.appDocsPath] || [fullPath isEqualToString:self.appTempPath]) { |
| // return self |
| newPath = fullPath; |
| } else { |
| // since this call is made from an existing Entry object - the parent should already exist so no additional error checking |
| // remove last component and return Entry |
| NSRange range = [fullPath rangeOfString:@"/" options:NSBackwardsSearch]; |
| newPath = [fullPath substringToIndex:range.location]; |
| } |
| |
| if (newPath) { |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| BOOL bIsDir; |
| BOOL bExists = [fileMgr fileExistsAtPath:newPath isDirectory:&bIsDir]; |
| if (bExists) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:[self getDirectoryEntry:newPath isDirectory:bIsDir]]; |
| } |
| } |
| if (!result) { |
| // invalid path or file does not exist |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* |
| * get MetaData of entry |
| * Currently MetaData only includes modificationTime. |
| */ |
| - (void)getMetadata:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| __block CDVPluginResult* result = nil; |
| |
| if ([argPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| // In this case, we need to use an asynchronous method to retrieve the file. |
| // Because of this, we can't just assign to `result` and send it at the end of the method. |
| // Instead, we return after calling the asynchronous method and send `result` in each of the blocks. |
| ALAssetsLibraryAssetForURLResultBlock resultBlock = ^(ALAsset * asset) { |
| if (asset) { |
| // We have the asset! Retrieve the metadata and send it off. |
| NSDate* date = [asset valueForProperty:ALAssetPropertyDate]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDouble:[date timeIntervalSince1970] * 1000]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } else { |
| // We couldn't find the asset. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| }; |
| // TODO(maxw): Consider making this a class variable since it's the same every time. |
| ALAssetsLibraryAccessFailureBlock failureBlock = ^(NSError * error) { |
| // Retrieving the asset failed for some reason. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[error localizedDescription]]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| }; |
| |
| ALAssetsLibrary* assetsLibrary = [[ALAssetsLibrary alloc] init]; |
| [assetsLibrary assetForURL:[NSURL URLWithString:argPath] resultBlock:resultBlock failureBlock:failureBlock]; |
| return; |
| } |
| |
| NSString* testPath = argPath; // [self getFullPath: argPath]; |
| |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| NSError* __autoreleasing error = nil; |
| |
| NSDictionary* fileAttribs = [fileMgr attributesOfItemAtPath:testPath error:&error]; |
| |
| if (fileAttribs) { |
| NSDate* modDate = [fileAttribs fileModificationDate]; |
| if (modDate) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDouble:[modDate timeIntervalSince1970] * 1000]; |
| } |
| } else { |
| // didn't get fileAttribs |
| CDVFileError errorCode = ABORT_ERR; |
| NSLog (@"error getting metadata: %@", [error localizedDescription]); |
| if ([error code] == NSFileNoSuchFileError) { |
| errorCode = NOT_FOUND_ERR; |
| } |
| // log [NSNumber numberWithDouble: theMessage] objCtype to see what it returns |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:errorCode]; |
| } |
| if (!result) { |
| // invalid path or file does not exist |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* |
| * set MetaData of entry |
| * Currently we only support "com.apple.MobileBackup" (boolean) |
| */ |
| - (void)setMetadata:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* filePath = [command.arguments objectAtIndex:0]; |
| NSDictionary* options = [command.arguments objectAtIndex:1 withDefault:nil]; |
| CDVPluginResult* result = nil; |
| BOOL ok = NO; |
| |
| // setMetadata doesn't make sense for asset library files |
| if (![filePath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| // we only care about this iCloud key for now. |
| // set to 1/true to skip backup, set to 0/false to back it up (effectively removing the attribute) |
| NSString* iCloudBackupExtendedAttributeKey = @"com.apple.MobileBackup"; |
| id iCloudBackupExtendedAttributeValue = [options objectForKey:iCloudBackupExtendedAttributeKey]; |
| |
| if ((iCloudBackupExtendedAttributeValue != nil) && [iCloudBackupExtendedAttributeValue isKindOfClass:[NSNumber class]]) { |
| if (IsAtLeastiOSVersion(@"5.1")) { |
| NSURL* url = [NSURL fileURLWithPath:filePath]; |
| NSError* __autoreleasing error = nil; |
| |
| ok = [url setResourceValue:[NSNumber numberWithBool:[iCloudBackupExtendedAttributeValue boolValue]] forKey:NSURLIsExcludedFromBackupKey error:&error]; |
| } else { // below 5.1 (deprecated - only really supported in 5.01) |
| u_int8_t value = [iCloudBackupExtendedAttributeValue intValue]; |
| if (value == 0) { // remove the attribute (allow backup, the default) |
| ok = (removexattr([filePath fileSystemRepresentation], [iCloudBackupExtendedAttributeKey cStringUsingEncoding:NSUTF8StringEncoding], 0) == 0); |
| } else { // set the attribute (skip backup) |
| ok = (setxattr([filePath fileSystemRepresentation], [iCloudBackupExtendedAttributeKey cStringUsingEncoding:NSUTF8StringEncoding], &value, sizeof(value), 0, 0) == 0); |
| } |
| } |
| } |
| } |
| |
| if (ok) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK]; |
| } else { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* removes the directory or file entry |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath |
| * |
| * returns NO_MODIFICATION_ALLOWED_ERR if is top level directory or no permission to delete dir |
| * returns INVALID_MODIFICATION_ERR if is non-empty dir or asset library file |
| * returns NOT_FOUND_ERR if file or dir is not found |
| */ |
| - (void)remove:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* fullPath = [command.arguments objectAtIndex:0]; |
| CDVPluginResult* result = nil; |
| CDVFileError errorCode = 0; // !! 0 not currently defined |
| |
| // return error for assets-library URLs |
| if ([fullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| errorCode = INVALID_MODIFICATION_ERR; |
| } else if ([fullPath isEqualToString:self.appDocsPath] || [fullPath isEqualToString:self.appTempPath]) { |
| // error if try to remove top level (documents or tmp) dir |
| errorCode = NO_MODIFICATION_ALLOWED_ERR; |
| } else { |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| BOOL bIsDir = NO; |
| BOOL bExists = [fileMgr fileExistsAtPath:fullPath isDirectory:&bIsDir]; |
| if (!bExists) { |
| errorCode = NOT_FOUND_ERR; |
| } |
| if (bIsDir && ([[fileMgr contentsOfDirectoryAtPath:fullPath error:nil] count] != 0)) { |
| // dir is not empty |
| errorCode = INVALID_MODIFICATION_ERR; |
| } |
| } |
| if (errorCode > 0) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:errorCode]; |
| } else { |
| // perform actual remove |
| result = [self doRemove:fullPath]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* recursively removes the directory |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath |
| * |
| * returns NO_MODIFICATION_ALLOWED_ERR if is top level directory or no permission to delete dir |
| * returns NOT_FOUND_ERR if file or dir is not found |
| */ |
| - (void)removeRecursively:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* fullPath = [command.arguments objectAtIndex:0]; |
| |
| // return unsupported result for assets-library URLs |
| if ([fullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_MALFORMED_URL_EXCEPTION messageAsString:@"removeRecursively not supported for assets-library URLs."]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| CDVPluginResult* result = nil; |
| |
| // error if try to remove top level (documents or tmp) dir |
| if ([fullPath isEqualToString:self.appDocsPath] || [fullPath isEqualToString:self.appTempPath]) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NO_MODIFICATION_ALLOWED_ERR]; |
| } else { |
| result = [self doRemove:fullPath]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* remove the file or directory (recursively) |
| * IN: |
| * NSString* fullPath - the full path to the file or directory to be removed |
| * NSString* callbackId |
| * called from remove and removeRecursively - check all pubic api specific error conditions (dir not empty, etc) before calling |
| */ |
| |
| - (CDVPluginResult*)doRemove:(NSString*)fullPath |
| { |
| CDVPluginResult* result = nil; |
| BOOL bSuccess = NO; |
| NSError* __autoreleasing pError = nil; |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| |
| @try { |
| bSuccess = [fileMgr removeItemAtPath:fullPath error:&pError]; |
| if (bSuccess) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK]; |
| } else { |
| // see if we can give a useful error |
| CDVFileError errorCode = ABORT_ERR; |
| NSLog(@"error getting metadata: %@", [pError localizedDescription]); |
| if ([pError code] == NSFileNoSuchFileError) { |
| errorCode = NOT_FOUND_ERR; |
| } else if ([pError code] == NSFileWriteNoPermissionError) { |
| errorCode = NO_MODIFICATION_ALLOWED_ERR; |
| } |
| |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:errorCode]; |
| } |
| } @catch(NSException* e) { // NSInvalidArgumentException if path is . or .. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:SYNTAX_ERR]; |
| } |
| |
| return result; |
| } |
| |
| - (void)copyTo:(CDVInvokedUrlCommand*)command |
| { |
| [self doCopyMove:command isCopy:YES]; |
| } |
| |
| - (void)moveTo:(CDVInvokedUrlCommand*)command |
| { |
| [self doCopyMove:command isCopy:NO]; |
| } |
| |
| /** |
| * Helper function to check to see if the user attempted to copy an entry into its parent without changing its name, |
| * or attempted to copy a directory into a directory that it contains directly or indirectly. |
| * |
| * IN: |
| * NSString* srcDir |
| * NSString* destinationDir |
| * OUT: |
| * YES copy/ move is allows |
| * NO move is onto itself |
| */ |
| - (BOOL)canCopyMoveSrc:(NSString*)src ToDestination:(NSString*)dest |
| { |
| // This weird test is to determine if we are copying or moving a directory into itself. |
| // Copy /Documents/myDir to /Documents/myDir-backup is okay but |
| // Copy /Documents/myDir to /Documents/myDir/backup not okay |
| BOOL copyOK = YES; |
| NSRange range = [dest rangeOfString:src]; |
| |
| if (range.location != NSNotFound) { |
| NSRange testRange = {range.length - 1, ([dest length] - range.length)}; |
| NSRange resultRange = [dest rangeOfString:@"/" options:0 range:testRange]; |
| if (resultRange.location != NSNotFound) { |
| copyOK = NO; |
| } |
| } |
| return copyOK; |
| } |
| |
| /* Copy/move a file or directory to a new location |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath of entry |
| * 1 - NSString* newName the new name of the entry, defaults to the current name |
| * NSMutableDictionary* options - DirectoryEntry to which to copy the entry |
| * BOOL - bCopy YES if copy, NO if move |
| * |
| */ |
| - (void)doCopyMove:(CDVInvokedUrlCommand*)command isCopy:(BOOL)bCopy |
| { |
| NSArray* arguments = command.arguments; |
| |
| // arguments |
| NSString* srcFullPath = [arguments objectAtIndex:0]; |
| NSString* destRootPath = [arguments objectAtIndex:1]; |
| // optional argument |
| NSString* newName = ([arguments count] > 2) ? [arguments objectAtIndex:2] : [srcFullPath lastPathComponent]; // use last component from appPath if new name not provided |
| |
| __block CDVPluginResult* result = nil; |
| CDVFileError errCode = 0; // !! Currently 0 is not defined, use this to signal error !! |
| |
| /*NSString* destRootPath = nil; |
| NSString* key = @"fullPath"; |
| if([options valueForKeyIsString:key]){ |
| destRootPath = [options objectForKey:@"fullPath"]; |
| }*/ |
| |
| if (!destRootPath) { |
| // no destination provided |
| errCode = NOT_FOUND_ERR; |
| } else if ([newName rangeOfString:@":"].location != NSNotFound) { |
| // invalid chars in new name |
| errCode = ENCODING_ERR; |
| } else { |
| NSString* newFullPath = [destRootPath stringByAppendingPathComponent:newName]; |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| if ([newFullPath isEqualToString:srcFullPath]) { |
| // source and destination can not be the same |
| errCode = INVALID_MODIFICATION_ERR; |
| } else if ([srcFullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| if (bCopy) { |
| // Copying (as opposed to moving) an assets library file is okay. |
| // In this case, we need to use an asynchronous method to retrieve the file. |
| // Because of this, we can't just assign to `result` and send it at the end of the method. |
| // Instead, we return after calling the asynchronous method and send `result` in each of the blocks. |
| ALAssetsLibraryAssetForURLResultBlock resultBlock = ^(ALAsset * asset) { |
| if (asset) { |
| // We have the asset! Get the data and try to copy it over. |
| if (![fileMgr fileExistsAtPath:destRootPath]) { |
| // The destination directory doesn't exist. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } else if ([fileMgr fileExistsAtPath:newFullPath]) { |
| // A file already exists at the destination path. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:PATH_EXISTS_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| // We're good to go! Write the file to the new destination. |
| ALAssetRepresentation* assetRepresentation = [asset defaultRepresentation]; |
| Byte* buffer = (Byte*)malloc ([assetRepresentation size]); |
| NSUInteger bufferSize = [assetRepresentation getBytes:buffer fromOffset:0.0 length:[assetRepresentation size] error:nil]; |
| NSData* data = [NSData dataWithBytesNoCopy:buffer length:bufferSize freeWhenDone:YES]; |
| [data writeToFile:newFullPath atomically:YES]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:[self getDirectoryEntry:newFullPath isDirectory:NO]]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } else { |
| // We couldn't find the asset. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| }; |
| ALAssetsLibraryAccessFailureBlock failureBlock = ^(NSError * error) { |
| // Retrieving the asset failed for some reason. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[error localizedDescription]]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| }; |
| |
| ALAssetsLibrary* assetsLibrary = [[ALAssetsLibrary alloc] init]; |
| [assetsLibrary assetForURL:[NSURL URLWithString:srcFullPath] resultBlock:resultBlock failureBlock:failureBlock]; |
| return; |
| } else { |
| // Moving an assets library file is not doable, since we can't remove it. |
| errCode = INVALID_MODIFICATION_ERR; |
| } |
| } else { |
| BOOL bSrcIsDir = NO; |
| BOOL bDestIsDir = NO; |
| BOOL bNewIsDir = NO; |
| BOOL bSrcExists = [fileMgr fileExistsAtPath:srcFullPath isDirectory:&bSrcIsDir]; |
| BOOL bDestExists = [fileMgr fileExistsAtPath:destRootPath isDirectory:&bDestIsDir]; |
| BOOL bNewExists = [fileMgr fileExistsAtPath:newFullPath isDirectory:&bNewIsDir]; |
| if (!bSrcExists || !bDestExists) { |
| // the source or the destination root does not exist |
| errCode = NOT_FOUND_ERR; |
| } else if (bSrcIsDir && (bNewExists && !bNewIsDir)) { |
| // can't copy/move dir to file |
| errCode = INVALID_MODIFICATION_ERR; |
| } else { // no errors yet |
| NSError* __autoreleasing error = nil; |
| BOOL bSuccess = NO; |
| if (bCopy) { |
| if (bSrcIsDir && ![self canCopyMoveSrc:srcFullPath ToDestination:newFullPath] /*[newFullPath hasPrefix:srcFullPath]*/) { |
| // can't copy dir into self |
| errCode = INVALID_MODIFICATION_ERR; |
| } else if (bNewExists) { |
| // the full destination should NOT already exist if a copy |
| errCode = PATH_EXISTS_ERR; |
| } else { |
| bSuccess = [fileMgr copyItemAtPath:srcFullPath toPath:newFullPath error:&error]; |
| } |
| } else { // move |
| // iOS requires that destination must not exist before calling moveTo |
| // is W3C INVALID_MODIFICATION_ERR error if destination dir exists and has contents |
| // |
| if (!bSrcIsDir && (bNewExists && bNewIsDir)) { |
| // can't move a file to directory |
| errCode = INVALID_MODIFICATION_ERR; |
| } else if (bSrcIsDir && ![self canCopyMoveSrc:srcFullPath ToDestination:newFullPath]) { // [newFullPath hasPrefix:srcFullPath]){ |
| // can't move a dir into itself |
| errCode = INVALID_MODIFICATION_ERR; |
| } else if (bNewExists) { |
| if (bNewIsDir && ([[fileMgr contentsOfDirectoryAtPath:newFullPath error:NULL] count] != 0)) { |
| // can't move dir to a dir that is not empty |
| errCode = INVALID_MODIFICATION_ERR; |
| newFullPath = nil; // so we won't try to move |
| } else { |
| // remove destination so can perform the moveItemAtPath |
| bSuccess = [fileMgr removeItemAtPath:newFullPath error:NULL]; |
| if (!bSuccess) { |
| errCode = INVALID_MODIFICATION_ERR; // is this the correct error? |
| newFullPath = nil; |
| } |
| } |
| } else if (bNewIsDir && [newFullPath hasPrefix:srcFullPath]) { |
| // can't move a directory inside itself or to any child at any depth; |
| errCode = INVALID_MODIFICATION_ERR; |
| newFullPath = nil; |
| } |
| |
| if (newFullPath != nil) { |
| bSuccess = [fileMgr moveItemAtPath:srcFullPath toPath:newFullPath error:&error]; |
| } |
| } |
| if (bSuccess) { |
| // should verify it is there and of the correct type??? |
| NSDictionary* newEntry = [self getDirectoryEntry:newFullPath isDirectory:bSrcIsDir]; // should be the same type as source |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:newEntry]; |
| } else { |
| errCode = INVALID_MODIFICATION_ERR; // catch all |
| if (error) { |
| if (([error code] == NSFileReadUnknownError) || ([error code] == NSFileReadTooLargeError)) { |
| errCode = NOT_READABLE_ERR; |
| } else if ([error code] == NSFileWriteOutOfSpaceError) { |
| errCode = QUOTA_EXCEEDED_ERR; |
| } else if ([error code] == NSFileWriteNoPermissionError) { |
| errCode = NO_MODIFICATION_ALLOWED_ERR; |
| } |
| } |
| } |
| } |
| } |
| } |
| if (errCode > 0) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:errCode]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* return the URI to the entry |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath of entry |
| * 1 - desired mime type of entry - ignored - always returns file:// |
| */ |
| |
| /* Not needed since W3C toURI is synchronous. Leaving code here for now in case W3C spec changes..... |
| - (void) toURI:(CDVInvokedUrlCommand*)command |
| { |
| NSString* callbackId = command.callbackId; |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| PluginResult* result = nil; |
| NSString* jsString = nil; |
| |
| NSString* fullPath = [self getFullPath: argPath]; |
| if (fullPath) { |
| // do we need to make sure the file actually exists? |
| // create file uri |
| NSString* strUri = [fullPath stringByReplacingPercentEscapesUsingEncoding: NSUTF8StringEncoding]; |
| NSURL* fileUrl = [NSURL fileURLWithPath:strUri]; |
| if (fileUrl) { |
| result = [PluginResult resultWithStatus:CDVCommandStatus_OK messageAsString: [fileUrl absoluteString]]; |
| jsString = [result toSuccessCallbackString:callbackId]; |
| } // else NOT_FOUND_ERR |
| } |
| if(!jsString) { |
| // was error |
| result = [PluginResult resultWithStatus:CDVCommandStatus_OK messageAsInt: NOT_FOUND_ERR cast: @"window.localFileSystem._castError"]; |
| jsString = [result toErrorCallbackString:callbackId]; |
| } |
| |
| [self writeJavascript:jsString]; |
| }*/ |
| - (void)getFileMetadata:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| |
| __block CDVPluginResult* result = nil; |
| |
| NSString* fullPath = argPath; // [self getFullPath: argPath]; |
| |
| if (fullPath) { |
| if ([fullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| // In this case, we need to use an asynchronous method to retrieve the file. |
| // Because of this, we can't just assign to `result` and send it at the end of the method. |
| // Instead, we return after calling the asynchronous method and send `result` in each of the blocks. |
| ALAssetsLibraryAssetForURLResultBlock resultBlock = ^(ALAsset * asset) { |
| if (asset) { |
| // We have the asset! Populate the dictionary and send it off. |
| NSMutableDictionary* fileInfo = [NSMutableDictionary dictionaryWithCapacity:5]; |
| ALAssetRepresentation* assetRepresentation = [asset defaultRepresentation]; |
| [fileInfo setObject:[NSNumber numberWithUnsignedLongLong:[assetRepresentation size]] forKey:@"size"]; |
| [fileInfo setObject:argPath forKey:@"fullPath"]; |
| NSString* filename = [assetRepresentation filename]; |
| [fileInfo setObject:filename forKey:@"name"]; |
| [fileInfo setObject:[self getMimeTypeFromPath:filename] forKey:@"type"]; |
| NSDate* creationDate = [asset valueForProperty:ALAssetPropertyDate]; |
| NSNumber* msDate = [NSNumber numberWithDouble:[creationDate timeIntervalSince1970] * 1000]; |
| [fileInfo setObject:msDate forKey:@"lastModifiedDate"]; |
| |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:fileInfo]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } else { |
| // We couldn't find the asset. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| }; |
| ALAssetsLibraryAccessFailureBlock failureBlock = ^(NSError * error) { |
| // Retrieving the asset failed for some reason. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[error localizedDescription]]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| }; |
| |
| ALAssetsLibrary* assetsLibrary = [[ALAssetsLibrary alloc] init]; |
| [assetsLibrary assetForURL:[NSURL URLWithString:argPath] resultBlock:resultBlock failureBlock:failureBlock]; |
| return; |
| } else { |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| BOOL bIsDir = NO; |
| // make sure it exists and is not a directory |
| BOOL bExists = [fileMgr fileExistsAtPath:fullPath isDirectory:&bIsDir]; |
| if (!bExists || bIsDir) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| } else { |
| // create dictionary of file info |
| NSError* __autoreleasing error = nil; |
| NSDictionary* fileAttrs = [fileMgr attributesOfItemAtPath:fullPath error:&error]; |
| NSMutableDictionary* fileInfo = [NSMutableDictionary dictionaryWithCapacity:5]; |
| [fileInfo setObject:[NSNumber numberWithUnsignedLongLong:[fileAttrs fileSize]] forKey:@"size"]; |
| [fileInfo setObject:argPath forKey:@"fullPath"]; |
| [fileInfo setObject:@"" forKey:@"type"]; // can't easily get the mimetype unless create URL, send request and read response so skipping |
| [fileInfo setObject:[argPath lastPathComponent] forKey:@"name"]; |
| NSDate* modDate = [fileAttrs fileModificationDate]; |
| NSNumber* msDate = [NSNumber numberWithDouble:[modDate timeIntervalSince1970] * 1000]; |
| [fileInfo setObject:msDate forKey:@"lastModifiedDate"]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:fileInfo]; |
| } |
| } |
| } |
| if (!result) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_INSTANTIATION_EXCEPTION]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| - (void)readEntries:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* fullPath = [command.arguments objectAtIndex:0]; |
| |
| // return unsupported result for assets-library URLs |
| if ([fullPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_MALFORMED_URL_EXCEPTION messageAsString:@"readEntries not supported for assets-library URLs."]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| CDVPluginResult* result = nil; |
| |
| NSFileManager* fileMgr = [[NSFileManager alloc] init]; |
| NSError* __autoreleasing error = nil; |
| NSArray* contents = [fileMgr contentsOfDirectoryAtPath:fullPath error:&error]; |
| |
| if (contents) { |
| NSMutableArray* entries = [NSMutableArray arrayWithCapacity:1]; |
| if ([contents count] > 0) { |
| // create an Entry (as JSON) for each file/dir |
| for (NSString* name in contents) { |
| // see if is dir or file |
| NSString* entryPath = [fullPath stringByAppendingPathComponent:name]; |
| BOOL bIsDir = NO; |
| [fileMgr fileExistsAtPath:entryPath isDirectory:&bIsDir]; |
| NSDictionary* entryDict = [self getDirectoryEntry:entryPath isDirectory:bIsDir]; |
| [entries addObject:entryDict]; |
| } |
| } |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsArray:entries]; |
| } else { |
| // assume not found but could check error for more specific error conditions |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| } |
| |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* read and return file data |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath |
| * 1 - NSString* encoding - NOT USED, iOS reads and writes using UTF8! |
| * 2 - NSString* start - OPTIONAL, only provided when not == 0. |
| * 3 - NSString* end - OPTIONAL, only provided when not == length. |
| */ |
| - (void)readAsText:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| NSInteger start = 0; |
| NSInteger end = -1; |
| |
| if ([command.arguments count] >= 3) { |
| start = [[command.arguments objectAtIndex:2] integerValue]; |
| } |
| if ([command.arguments count] >= 4) { |
| end = [[command.arguments objectAtIndex:3] integerValue]; |
| } |
| |
| // NSString* encoding = [command.arguments objectAtIndex:2]; // not currently used |
| CDVPluginResult* result = nil; |
| |
| NSFileHandle* file = [NSFileHandle fileHandleForReadingAtPath:argPath]; |
| |
| if ([argPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| // can't read assets-library URLs as text |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_READABLE_ERR]; |
| } else if (!file) { |
| // invalid path entry |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| } else { |
| if (start > 0) { |
| [file seekToFileOffset:start]; |
| } |
| |
| NSData* readData; |
| if (end < 0) { |
| readData = [file readDataToEndOfFile]; |
| } else { |
| readData = [file readDataOfLength:(end - start)]; |
| } |
| |
| [file closeFile]; |
| NSString* pNStrBuff = nil; |
| if (readData) { |
| pNStrBuff = [[NSString alloc] initWithBytes:[readData bytes] length:[readData length] encoding:NSUTF8StringEncoding]; |
| } else { |
| // return empty string if no data |
| pNStrBuff = @""; |
| } |
| |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:pNStrBuff]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* Read content of text file and return as base64 encoded data url. |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* fullPath |
| * |
| * Determines the mime type from the file extension, returns ENCODING_ERR if mimetype can not be determined. |
| */ |
| |
| - (void)readAsDataURL:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| NSInteger start = 0; |
| NSInteger end = -1; |
| |
| if ([command.arguments count] >= 2) { |
| start = [[command.arguments objectAtIndex:1] integerValue]; |
| } |
| if ([command.arguments count] >= 3) { |
| end = [[command.arguments objectAtIndex:2] integerValue]; |
| } |
| |
| CDVFileError errCode = ABORT_ERR; |
| __block CDVPluginResult* result = nil; |
| |
| if (!argPath) { |
| errCode = SYNTAX_ERR; |
| } else if ([argPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| // In this case, we need to use an asynchronous method to retrieve the file. |
| // Because of this, we can't just assign to `result` and send it at the end of the method. |
| // Instead, we return after calling the asynchronous method and send `result` in each of the blocks. |
| ALAssetsLibraryAssetForURLResultBlock resultBlock = ^(ALAsset * asset) { |
| if (asset) { |
| // We have the asset! Get the data and send it off. |
| ALAssetRepresentation* assetRepresentation = [asset defaultRepresentation]; |
| Byte* buffer = (Byte*)malloc ([assetRepresentation size]); |
| NSUInteger bufferSize = [assetRepresentation getBytes:buffer fromOffset:0.0 length:[assetRepresentation size] error:nil]; |
| NSData* data = [NSData dataWithBytesNoCopy:buffer length:bufferSize freeWhenDone:YES]; |
| NSString* mimeType = [self getMimeTypeFromPath:[assetRepresentation filename]]; |
| NSString* dataString = [NSString stringWithFormat:@"data:%@;base64,%@", mimeType, [data base64EncodedString]]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:dataString]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } else { |
| // We couldn't find the asset. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NOT_FOUND_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| }; |
| ALAssetsLibraryAccessFailureBlock failureBlock = ^(NSError * error) { |
| // Retrieving the asset failed for some reason. Send the appropriate error. |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsString:[error localizedDescription]]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| }; |
| |
| ALAssetsLibrary* assetsLibrary = [[ALAssetsLibrary alloc] init]; |
| [assetsLibrary assetForURL:[NSURL URLWithString:argPath] resultBlock:resultBlock failureBlock:failureBlock]; |
| return; |
| } else { |
| NSString* mimeType = [self getMimeTypeFromPath:argPath]; |
| if (!mimeType) { |
| // can't return as data URL if can't figure out the mimeType |
| errCode = ENCODING_ERR; |
| } else { |
| NSFileHandle* file = [NSFileHandle fileHandleForReadingAtPath:argPath]; |
| if (start > 0) { |
| [file seekToFileOffset:start]; |
| } |
| |
| NSData* readData; |
| if (end < 0) { |
| readData = [file readDataToEndOfFile]; |
| } else { |
| readData = [file readDataOfLength:(end - start)]; |
| } |
| |
| [file closeFile]; |
| if (readData) { |
| NSString* output = [NSString stringWithFormat:@"data:%@;base64,%@", mimeType, [readData base64EncodedString]]; |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:output]; |
| } else { |
| errCode = NOT_FOUND_ERR; |
| } |
| } |
| } |
| if (!result) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:errCode]; |
| } |
| // NSLog(@"readAsDataURL return: %@", jsString); |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| /* helper function to get the mimeType from the file extension |
| * IN: |
| * NSString* fullPath - filename (may include path) |
| * OUT: |
| * NSString* the mime type as type/subtype. nil if not able to determine |
| */ |
| - (NSString*)getMimeTypeFromPath:(NSString*)fullPath |
| { |
| NSString* mimeType = nil; |
| |
| if (fullPath) { |
| CFStringRef typeId = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, (__bridge CFStringRef)[fullPath pathExtension], NULL); |
| if (typeId) { |
| mimeType = (__bridge_transfer NSString*)UTTypeCopyPreferredTagWithClass(typeId, kUTTagClassMIMEType); |
| if (!mimeType) { |
| // special case for m4a |
| if ([(__bridge NSString*) typeId rangeOfString:@"m4a-audio"].location != NSNotFound) { |
| mimeType = @"audio/mp4"; |
| } else if ([[fullPath pathExtension] rangeOfString:@"wav"].location != NSNotFound) { |
| mimeType = @"audio/wav"; |
| } |
| } |
| CFRelease(typeId); |
| } |
| } |
| return mimeType; |
| } |
| |
| - (void)truncate:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| unsigned long long pos = (unsigned long long)[[command.arguments objectAtIndex:1] longLongValue]; |
| |
| // assets-library files can't be truncated |
| if ([argPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NO_MODIFICATION_ALLOWED_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| NSString* appFile = argPath; // [self getFullPath:argPath]; |
| |
| unsigned long long newPos = [self truncateFile:appFile atPosition:pos]; |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsInt:newPos]; |
| |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| - (unsigned long long)truncateFile:(NSString*)filePath atPosition:(unsigned long long)pos |
| { |
| unsigned long long newPos = 0UL; |
| |
| NSFileHandle* file = [NSFileHandle fileHandleForWritingAtPath:filePath]; |
| |
| if (file) { |
| [file truncateFileAtOffset:(unsigned long long)pos]; |
| newPos = [file offsetInFile]; |
| [file synchronizeFile]; |
| [file closeFile]; |
| } |
| return newPos; |
| } |
| |
| /* write |
| * IN: |
| * NSArray* arguments |
| * 0 - NSString* file path to write to |
| * 1 - NSString* data to write |
| * 2 - NSNumber* position to begin writing |
| */ |
| - (void)write:(CDVInvokedUrlCommand*)command |
| { |
| NSString* callbackId = command.callbackId; |
| NSArray* arguments = command.arguments; |
| |
| // arguments |
| NSString* argPath = [arguments objectAtIndex:0]; |
| NSString* argData = [arguments objectAtIndex:1]; |
| unsigned long long pos = (unsigned long long)[[arguments objectAtIndex:2] longLongValue]; |
| |
| // text can't be written into assets-library files |
| if ([argPath hasPrefix:kCDVAssetsLibraryPrefix]) { |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:NO_MODIFICATION_ALLOWED_ERR]; |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| return; |
| } |
| |
| NSString* fullPath = argPath; // [self getFullPath:argPath]; |
| |
| [self truncateFile:fullPath atPosition:pos]; |
| |
| [self writeToFile:fullPath withData:argData append:YES callback:callbackId]; |
| } |
| |
| - (void)writeToFile:(NSString*)filePath withData:(NSString*)data append:(BOOL)shouldAppend callback:(NSString*)callbackId |
| { |
| CDVPluginResult* result = nil; |
| CDVFileError errCode = INVALID_MODIFICATION_ERR; |
| int bytesWritten = 0; |
| NSData* encData = [data dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES]; |
| |
| if (filePath) { |
| NSOutputStream* fileStream = [NSOutputStream outputStreamToFileAtPath:filePath append:shouldAppend]; |
| if (fileStream) { |
| NSUInteger len = [encData length]; |
| [fileStream open]; |
| |
| bytesWritten = [fileStream write:[encData bytes] maxLength:len]; |
| |
| [fileStream close]; |
| if (bytesWritten > 0) { |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsInt:bytesWritten]; |
| // } else { |
| // can probably get more detailed error info via [fileStream streamError] |
| // errCode already set to INVALID_MODIFICATION_ERR; |
| // bytesWritten = 0; // may be set to -1 on error |
| } |
| } // else fileStream not created return INVALID_MODIFICATION_ERR |
| } else { |
| // invalid filePath |
| errCode = NOT_FOUND_ERR; |
| } |
| if (!result) { |
| // was an error |
| result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsInt:errCode]; |
| } |
| [self.commandDelegate sendPluginResult:result callbackId:callbackId]; |
| } |
| |
| - (void)testFileExists:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| |
| // Get the file manager |
| NSFileManager* fMgr = [NSFileManager defaultManager]; |
| NSString* appFile = argPath; // [ self getFullPath: argPath]; |
| |
| BOOL bExists = [fMgr fileExistsAtPath:appFile]; |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsInt:(bExists ? 1:0)]; |
| |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| - (void)testDirectoryExists:(CDVInvokedUrlCommand*)command |
| { |
| // arguments |
| NSString* argPath = [command.arguments objectAtIndex:0]; |
| |
| // Get the file manager |
| NSFileManager* fMgr = [[NSFileManager alloc] init]; |
| NSString* appFile = argPath; // [self getFullPath: argPath]; |
| BOOL bIsDir = NO; |
| BOOL bExists = [fMgr fileExistsAtPath:appFile isDirectory:&bIsDir]; |
| |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsInt:((bExists && bIsDir) ? 1:0)]; |
| |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| // Returns number of bytes available via callback |
| - (void)getFreeDiskSpace:(CDVInvokedUrlCommand*)command |
| { |
| // no arguments |
| |
| NSNumber* pNumAvail = [self checkFreeDiskSpace:self.appDocsPath]; |
| |
| NSString* strFreeSpace = [NSString stringWithFormat:@"%qu", [pNumAvail unsignedLongLongValue]]; |
| // NSLog(@"Free space is %@", strFreeSpace ); |
| |
| CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:strFreeSpace]; |
| |
| [self.commandDelegate sendPluginResult:result callbackId:command.callbackId]; |
| } |
| |
| @end |
