CB-9544 Add file plugin for OSX

tripodsan · shazron · commit b37497913ce0 · 2015-08-26T16:02:17.000-07:00
- defining osx filesystems roots
- updating readme to include osx
- updating test case for osx
diff --git a/README.md b/README.md
@@ -59,11 +59,11 @@ Although in the global scope, it is not available until after the `deviceready`
 - BlackBerry 10
 - Firefox OS
 - iOS
+- OS X
 - Windows Phone 7 and 8*
 - Windows 8*
 - Windows*
 - Browser
-- OS X
 
 \* _These platforms do not support `FileReader.readAsArrayBuffer` nor `FileWriter.write(blob)`._
 
@@ -74,12 +74,12 @@ Each URL is in the form _file:///path/to/spot/_, and can be converted to a
 `DirectoryEntry` using `window.resolveLocalFileSystemURL()`.
 
 * `cordova.file.applicationDirectory` - Read-only directory where the application 
-  is installed. (_iOS_, _Android_, _BlackBerry 10_)
+  is installed. (_iOS_, _Android_, _BlackBerry 10_, _OSX_)
 
 * `cordova.file.applicationStorageDirectory` - Root directory of the application's 
   sandbox; on iOS this location is read-only (but specific subdirectories [like 
   `/Documents`] are read-write). All data contained within is private to the app. (
-  _iOS_, _Android_, _BlackBerry 10_)
+  _iOS_, _Android_, _BlackBerry 10_, _OSX_)
 
 * `cordova.file.dataDirectory` - Persistent and private data storage within the 
   application's sandbox using internal memory (on Android, if you need to use 
@@ -89,7 +89,7 @@ Each URL is in the form _file:///path/to/spot/_, and can be converted to a
 * `cordova.file.cacheDirectory` -  Directory for cached data files or any files 
   that your app can re-create easily. The OS may delete these files when the device 
   runs low on storage, nevertheless, apps should not rely on the OS to delete files 
-  in here. (_iOS_, _Android_, _BlackBerry 10_)
+  in here. (_iOS_, _Android_, _BlackBerry 10_, _OSX_)
 
 * `cordova.file.externalApplicationStorageDirectory` - Application space on 
   external storage. (_Android_)
@@ -104,13 +104,13 @@ Each URL is in the form _file:///path/to/spot/_, and can be converted to a
 
 * `cordova.file.tempDirectory` - Temp directory that the OS can clear at will. Do not 
   rely on the OS to clear this directory; your app should always remove files as 
-  applicable. (_iOS_)
+  applicable. (_iOS_, _OSX_)
 
 * `cordova.file.syncedDataDirectory` - Holds app-specific files that should be synced 
   (e.g. to iCloud). (_iOS_)
 
 * `cordova.file.documentsDirectory` - Files private to the app, but that are meaningful 
-  to other application (e.g. Office files). (_iOS_)
+  to other application (e.g. Office files). Note that for _OSX_ this is the user's `~/Documents` directory. (_iOS_, _OSX_)
 
 * `cordova.file.sharedDirectory` - Files globally available to all applications (_BlackBerry 10_)
 
@@ -186,6 +186,28 @@ properties are `null`.
 
 *Note*: When application is deployed to work perimeter, all paths are relative to /accounts/1000-enterprise.
 
+### OS X File System Layout
+
+| Device Path                                      | `cordova.file.*`            | `iosExtraFileSystems` | r/w? |  OS clears | private |
+|:-------------------------------------------------|:----------------------------|:----------------------|:----:|:---------:|:-------:|
+| `/Applications/<appname>.app`                    | applicationDirectory        | bundle                | r    |     N/A   |   Yes   |
+| `~/Library/Application Support/<bundle-id>/`     | applicationStorageDirectory | -                     | r/w  |     No    |   Yes   |
+| &nbsp;&nbsp;&nbsp;&nbsp;`files/`                 | dataDirectory               | -                     | r/w  |     No    |   Yes   |
+| `~/Documents/`                                   | documentsDirectory          | documents             | r/w  |     No    |    No   |
+| `~/Library/Caches/<bundle-id>/`                  | cacheDirectory              | cache                 | r/w  |     No    |   Yes   |
+| `/tmp/`                                          | tempDirectory               | -                     | r/w  |    Yes\*  |   Yes   |
+| `/`                                              | rootDirectory               | root                  | r/w  |    No\*\* |    No   |
+
+**Note**: This is the layout for non sandboxed applications. I you enable sandboxing, the `applicationStorageDirectory` will be below ` ~/Library/Containers/<bundle-id>/Data/Library/Application Support`.
+
+\* Files persist across app restarts and upgrades, but this directory can 
+     be cleared whenever the OS desires. Your app should be able to recreate any 
+     content that might be deleted. You should clear this directory as 
+     appropriate for your application.
+
+\*\* Allows access to the entire file system. This is only available for non sandboxed apps.
+
+
 ## Android Quirks
 
 ### Android Persistent storage location
diff --git a/src/osx/CDVFile.h b/src/osx/CDVFile.h
@@ -20,9 +20,22 @@
 #import <Foundation/Foundation.h>
 #import <Cordova/CDVPlugin.h>
 
-NSString* const kCDVAssetsLibraryPrefix;
 NSString* const kCDVFilesystemURLPrefix;
 
+/**
+* The default filesystems if non are specified.
+*/
+#define CDV_FILESYSTEMS_DEFAULT @"documents,cache,bundle,root"
+
+/**
+* Preference name of the extra filesystems to be "mounted". the following are supported:
+* 'bundle'    - mounts the application directory
+* 'documents' - mounts the users Documents directory (~/Documents)
+* 'root'      - mounts the root file system
+* 'cache'     - mounts the caches directory (~/Library/Caches/<bundle-id/)
+*/
+#define CDV_PREF_EXTRA_FILESYSTEM @"osxextrafilesystems"
+
 enum CDVFileError {
     NO_ERROR = 0,
     NOT_FOUND_ERR = 1,
@@ -141,17 +154,36 @@ typedef int CDVFileError;
 /* Internal methods for testing */
 - (void)_getLocalFilesystemPath:(CDVInvokedUrlCommand*)command;
 
-@property (nonatomic, strong) NSString* rootDocsPath;
+/**
+ * local path of the 'documents' file system (~/Documents)
+ */
 @property (nonatomic, strong) NSString* appDocsPath;
-@property (nonatomic, strong) NSString* appLibraryPath;
+
+/**
+* local path of the 'applicationStorageDirectory' file system (~/Library/Application Support/<bundle-id>)
+*/
+@property (nonatomic, strong) NSString* appSupportPath;
+
+/**
+* local path of the 'persistent' file system (~/Library/Application Support/<bundle-id>/files)
+*/
+@property (nonatomic, strong) NSString* appDataPath;
+
+/**
+* local path of the 'documents' file system (~/Documents)
+*/
 @property (nonatomic, strong) NSString* appTempPath;
-@property (nonatomic, strong) NSString* persistentPath;
-@property (nonatomic, strong) NSString* temporaryPath;
+
+/**
+* local path of the 'cache' file system (~/Library/Caches/<bundle-id>)
+*/
+@property (nonatomic, strong) NSString* appCachePath;
+
+/**
+ * registered file systems
+ */
 @property (nonatomic, strong) NSMutableArray* fileSystems;
 
 @property BOOL userHasAllowed;
 
 @end
-
-#define kW3FileTemporary @"temporary"
-#define kW3FilePersistent @"persistent"
diff --git a/src/osx/CDVFile.m b/src/osx/CDVFile.m
@@ -184,7 +184,7 @@ - (NSCachedURLResponse *)connection:(NSURLConnection *)connection
 
 @implementation CDVFile
 
-@synthesize rootDocsPath, appDocsPath, appLibraryPath, appTempPath, userHasAllowed, fileSystems=fileSystems_;
+@synthesize appDocsPath, appDataPath, appSupportPath, appTempPath, appCachePath, userHasAllowed, fileSystems=fileSystems_;
 
 - (void)registerFilesystem:(NSObject<CDVFileSystem> *)fs {
     __weak CDVFile* weakSelf = self;
@@ -235,12 +235,12 @@ - (NSArray *)getExtraFileSystemsPreference:(NSWindowController *)vc
 {
     NSString *filesystemsStr = nil;
     if([self.viewController isKindOfClass:[CDVViewController class]]) {
-        CDVViewController *vc = (CDVViewController *)self.viewController;
+        CDVViewController *vc = self.viewController;
         NSDictionary *settings = [vc settings];
-        filesystemsStr = [settings[@"osxextrafilesystems"] lowercaseString];
+        filesystemsStr = [settings[CDV_PREF_EXTRA_FILESYSTEM] lowercaseString];
     }
     if (!filesystemsStr) {
-        filesystemsStr = @"library,library-nosync,documents,documents-nosync,cache,bundle,root";
+        filesystemsStr = CDV_FILESYSTEMS_DEFAULT;
     }
     return [filesystemsStr componentsSeparatedByString:@","];
 }
@@ -260,13 +260,6 @@ - (void)registerExtraFileSystems:(NSArray *)filesystems fromAvailableSet:(NSDict
 {
     NSMutableSet *installedFilesystems = [[NSMutableSet alloc] initWithCapacity:7];
 
-    /* Build non-syncable directories as necessary */
-    for (NSString *nonSyncFS in @[@"library-nosync", @"documents-nosync"]) {
-        if ([filesystems containsObject:nonSyncFS]) {
-            [self makeNonSyncable:availableFileSystems[nonSyncFS]];
-        }
-    }
-
     /* Register filesystems in order */
     for (NSString *fsName in filesystems) {
         if (![installedFilesystems containsObject:fsName]) {
@@ -283,88 +276,66 @@ - (void)registerExtraFileSystems:(NSArray *)filesystems fromAvailableSet:(NSDict
 
 - (NSDictionary *)getAvailableFileSystems
 {
-    NSString *libPath = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0];
-    NSString *docPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
     return @{
-        @"library": libPath,
-        @"library-nosync": [libPath stringByAppendingPathComponent:@"NoCloud"],
-        @"documents": docPath,
-        @"documents-nosync": [docPath stringByAppendingPathComponent:@"NoCloud"],
-        @"cache": [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) objectAtIndex:0],
+        @"documents": self.appDocsPath,
+        @"cache": self.appCachePath,
         @"bundle": [[NSBundle mainBundle] bundlePath],
         @"root": @"/"
     };
 }
 
 - (void)pluginInitialize
-{
-    filePlugin = self;
+{   filePlugin = self;
     [NSURLProtocol registerClass:[CDVFilesystemURLProtocol class]];
 
     fileSystems_ = [[NSMutableArray alloc] initWithCapacity:3];
 
-    // Get the Library directory path
-    NSArray* paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
-    self.appLibraryPath = [[paths objectAtIndex:0] stringByAppendingPathComponent:@"files"];
-
     // Get the Temporary directory path
     self.appTempPath = [NSTemporaryDirectory()stringByStandardizingPath];   // remove trailing slash from NSTemporaryDirectory()
+    [self registerFilesystem:[[CDVLocalFilesystem alloc] initWithName:@"temporary" root:self.appTempPath]];
 
-    // Get the Documents directory path
-    paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
-    self.rootDocsPath = [paths objectAtIndex:0];
-    self.appDocsPath = [self.rootDocsPath stringByAppendingPathComponent:@"files"];
+    // ~/Library/Application Support/<bundle-id>
+    self.appSupportPath = [self getSupportDirectoryFor:NSApplicationSupportDirectory pathComponents:nil];
 
+    // ~/Library/Application Support/<bundle-id>/files
+    self.appDataPath = [self getSupportDirectoryFor:NSApplicationSupportDirectory pathComponents:@[@"files"]];
+    [self registerFilesystem:[[CDVLocalFilesystem alloc] initWithName:@"persistent" root:self.appDataPath]];
 
-    NSString *location = nil;
-    if([self.viewController isKindOfClass:[CDVViewController class]]) {
-        CDVViewController *vc = (CDVViewController *)self.viewController;
-        NSMutableDictionary *settings = vc.settings;
-        location = [[settings objectForKey:@"iospersistentfilelocation"] lowercaseString];
-    }
-    if (location == nil) {
-        // Compatibilty by default (if the config preference is not set, or
-        // if we're not embedded in a CDVViewController somehow.)
-        location = @"compatibility";
-    }
+    // ~/Documents/
+    self.appDocsPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
 
-    NSError *error;
-    if ([[NSFileManager defaultManager] createDirectoryAtPath:self.appTempPath
-                                  withIntermediateDirectories:YES
-                                                   attributes:nil
-                                                        error:&error]) {
-        [self registerFilesystem:[[CDVLocalFilesystem alloc] initWithName:@"temporary" root:self.appTempPath]];
-    } else {
-        NSLog(@"Unable to create temporary directory: %@", error);
-    }
-    if ([location isEqualToString:@"library"]) {
-        if ([[NSFileManager defaultManager] createDirectoryAtPath:self.appLibraryPath
-                                      withIntermediateDirectories:YES
-                                                       attributes:nil
-                                                            error:&error]) {
-            [self registerFilesystem:[[CDVLocalFilesystem alloc] initWithName:@"persistent" root:self.appLibraryPath]];
-        } else {
-            NSLog(@"Unable to create library directory: %@", error);
-        }
-    } else if ([location isEqualToString:@"compatibility"]) {
-        /*
-         *  Fall-back to compatibility mode -- this is the logic implemented in
-         *  earlier versions of this plugin, and should be maintained here so
-         *  that apps which were originally deployed with older versions of the
-         *  plugin can continue to provide access to files stored under those
-         *  versions.
-         */
-        [self registerFilesystem:[[CDVLocalFilesystem alloc] initWithName:@"persistent" root:self.rootDocsPath]];
-    } else {
-        NSAssert(false,
-            @"File plugin configuration error: Please set iosPersistentFileLocation in config.xml to one of \"library\" (for new applications) or \"compatibility\" (for compatibility with previous versions)");
-    }
+    // ~/Library/Caches/<bundle-id>/files
+    self.appCachePath = [self getSupportDirectoryFor:NSCachesDirectory pathComponents:nil];
 
     [self registerExtraFileSystems:[self getExtraFileSystemsPreference:self.viewController]
                   fromAvailableSet:[self getAvailableFileSystems]];
+}
+
+- (NSString*) getSupportDirectoryFor: (NSSearchPathDirectory) directory pathComponents: (NSArray*) components  {
+    NSError* error;
+    NSFileManager* fm = [NSFileManager defaultManager];
+    NSURL* supportDir = [fm URLForDirectory:directory inDomain:NSUserDomainMask appropriateForURL:nil create:YES error:&error];
+    if (supportDir == nil) {
+        NSLog(@"unable to get support directory: %@", error);
+        return nil;
+    }
 
+    NSString* bundleID = [[NSBundle mainBundle] bundleIdentifier];
+    NSURL *dirPath = [supportDir URLByAppendingPathComponent:bundleID];
+    for (NSString* pathComponent in components) {
+        dirPath = [dirPath URLByAppendingPathComponent:pathComponent];
+    }
+
+    if (![fm fileExistsAtPath:dirPath.path]) {
+        if (![fm createDirectoryAtURL:dirPath withIntermediateDirectories:YES attributes:nil error:&error]) {
+            NSLog(@"unable to create support directory: %@", error);
+            return nil;
+        }
+    }
+    return dirPath.path;
 }
 
+
 - (CDVFilesystemURL *)fileSystemURLforArg:(NSString *)urlArg
 {
     CDVFilesystemURL* ret = nil;
@@ -446,7 +417,7 @@ - (void)requestFileSystem:(CDVInvokedUrlCommand*)command
     } else {
         NSString* fullPath = @"/";
         // check for avail space for size request
-        NSNumber* pNumAvail = [self checkFreeDiskSpace:self.rootDocsPath];
+        NSNumber* pNumAvail = [self checkFreeDiskSpace:self.appSupportPath];
         // NSLog(@"Free space: %@", [NSString stringWithFormat:@"%qu", [ pNumAvail unsignedLongLongValue ]]);
         if (pNumAvail && ([pNumAvail unsignedLongLongValue] < size)) {
             result = [CDVPluginResult resultWithStatus:CDVCommandStatus_IO_EXCEPTION messageAsInt:QUOTA_EXCEEDED_ERR];
@@ -480,28 +451,14 @@ - (void)requestAllFileSystems:(CDVInvokedUrlCommand*)command
 
 - (void)requestAllPaths:(CDVInvokedUrlCommand*)command
 {
-    NSString* libPath = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES)[0];
-    NSString* libPathSync = [libPath stringByAppendingPathComponent:@"Cloud"];
-    NSString* libPathNoSync = [libPath stringByAppendingPathComponent:@"NoCloud"];
-    NSString* docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
-    NSString* storagePath = [libPath stringByDeletingLastPathComponent];
-    NSString* cachePath = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES)[0];
-
-    // Create the directories if necessary.
-    [[NSFileManager defaultManager] createDirectoryAtPath:libPathSync withIntermediateDirectories:YES attributes:nil error:nil];
-    [[NSFileManager defaultManager] createDirectoryAtPath:libPathNoSync withIntermediateDirectories:YES attributes:nil error:nil];
-    // Mark NoSync as non-iCloud.
-    [[NSURL fileURLWithPath:libPathNoSync] setResourceValue: [NSNumber numberWithBool: YES]
-                                                     forKey: NSURLIsExcludedFromBackupKey error:nil];
-
     NSDictionary* ret = @{
         @"applicationDirectory": [[NSURL fileURLWithPath:[[NSBundle mainBundle] bundlePath]] absoluteString],
-        @"applicationStorageDirectory": [[NSURL fileURLWithPath:storagePath] absoluteString],
-        @"dataDirectory": [[NSURL fileURLWithPath:libPathNoSync] absoluteString],
-        @"syncedDataDirectory": [[NSURL fileURLWithPath:libPathSync] absoluteString],
-        @"documentsDirectory": [[NSURL fileURLWithPath:docPath] absoluteString],
-        @"cacheDirectory": [[NSURL fileURLWithPath:cachePath] absoluteString],
-        @"tempDirectory": [[NSURL fileURLWithPath:NSTemporaryDirectory()] absoluteString]
+        @"applicationStorageDirectory": [[NSURL fileURLWithPath:self.appSupportPath] absoluteString],
+        @"dataDirectory": [[NSURL fileURLWithPath:self.appDataPath] absoluteString],
+        @"documentsDirectory": [[NSURL fileURLWithPath:self.appDocsPath] absoluteString],
+        @"cacheDirectory": [[NSURL fileURLWithPath:self.appCachePath] absoluteString],
+        @"tempDirectory":[[NSURL fileURLWithPath:self.appTempPath] absoluteString],
+        @"rootDirectory": @"file:///",
     };
 
     CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:ret];
diff --git a/tests/tests.js b/tests/tests.js
@@ -3302,6 +3302,8 @@ exports.defineAutoTests = function () {
                     expectedPaths.push('externalRootDirectory', 'sharedDirectory');
                 } else if (cordova.platformId == 'ios') {
                     expectedPaths.push('syncedDataDirectory', 'documentsDirectory', 'tempDirectory');
+                } else if (cordova.platformId == 'osx') {
+                    expectedPaths.push('documentsDirectory', 'tempDirectory', 'rootDirectory');
                 } else {
                     console.log('Skipping test due on unsupported platform.');
                     return;
