Package apple.fileprovider

Class NSFileProviderExtension

  • All Implemented Interfaces:
    NSObject
    public class NSFileProviderExtension
extends NSObject

    • Constructor Detail

      • NSFileProviderExtension

        protected NSFileProviderExtension​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • URLForItemWithPersistentIdentifier

        public NSURL URLForItemWithPersistentIdentifier​(java.lang.String identifier)
        Should return the URL corresponding to a specific identifier. Fail if it's not a subpath of documentStorageURL. This is a static mapping; each identifier must always return a path corresponding to the same file. By default, this returns the path relative to the path returned by documentStorageURL.

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static java.lang.Object allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        public static org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • documentStorageURL

        public NSURL documentStorageURL()
        The root URL for provided documents. This URL is derived by consulting the NSExtensionFileProviderDocumentGroup property on your extension. The document storage URL is the folder "File Provider Storage" in the corresponding container.

      • hash_static

        public static long hash_static()

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • itemChangedAtURL

        public void itemChangedAtURL​(NSURL url)
        Called at some point after the file has changed; the provider may then trigger an upload.

      • itemForIdentifierError

        public NSFileProviderItem itemForIdentifierError​(java.lang.String identifier,
                                                 org.moe.natj.general.ptr.Ptr<NSError> error)

      • keyPathsForValuesAffectingValueForKey

        public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(java.lang.String key)

      • new_objc

        public static java.lang.Object new_objc()

      • persistentIdentifierForItemAtURL

        public java.lang.String persistentIdentifierForItemAtURL​(NSURL url)

      • placeholderURLForURL

        public static NSURL placeholderURLForURL​(NSURL url)
        Returns the designated placeholder URL for a given URL. This placeholder will be consulted before falling back to your app extension to enhance performance. To write out a placeholder, use the writePlaceHolderAtURL: method above.

      • providePlaceholderAtURLCompletionHandler

        public void providePlaceholderAtURLCompletionHandler​(NSURL url,
                                                     NSFileProviderExtension.Block_providePlaceholderAtURLCompletionHandler completionHandler)
        This method is called when a placeholder URL should be provided for the item at the given URL. The implementation of this method should call +[NSFileProviderManager writePlaceholderAtURL:withMetadata:error:] with the URL returned by +[NSFileProviderManager placeholderURLForURL:], then call the completion handler.

      • providerIdentifier

        public java.lang.String providerIdentifier()
        An identifier unique to this provider. When modifying the files stored in the directory returned by documentStorageURL, you should pass this identifier to your file coordinator's setPurposeIdentifier: method.

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • stopProvidingItemAtURL

        public void stopProvidingItemAtURL​(NSURL url)
        Called after the last claim to the file has been released. At this point, it is safe for the file provider to remove the content file. Care should be taken that the corresponding placeholder file stays behind after the content file has been deleted.

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • version_static

        public static long version_static()

      • writePlaceholderAtURLWithMetadataError

        public static boolean writePlaceholderAtURLWithMetadataError​(NSURL placeholderURL,
                                                             NSDictionary<java.lang.String,​?> metadata,
                                                             org.moe.natj.general.ptr.Ptr<NSError> error)
        Writes out a placeholder at the specified URL. The URL should be one returned by placeholderURLForURL:; if URL resource values are requested, the system will consult the placeholder before consulting your app extension. Metadata contains NSURLNameKey, NSURLFileSizeKey, NSURLIsPackageKey.

      • createDirectoryWithNameInParentItemIdentifierCompletionHandler

        public void createDirectoryWithNameInParentItemIdentifierCompletionHandler​(java.lang.String directoryName,
                                                                           java.lang.String parentItemIdentifier,
                                                                           NSFileProviderExtension.Block_createDirectoryWithNameInParentItemIdentifierCompletionHandler completionHandler)
        Create a directory. This is expected to complete before doing any network. In the completion block, createdDirectoryItem should have these properties set: - itemIdentifier - parentItemIdentifier (to the value passed in to this method) - filename (to directoryName) - creationDate (to the current date and time) - typeIdentifier (to "public.folder") - childItemCount (to 0) - capabilities Errors (including collision errors) are handled as documented for the import method above. Directory creation is gated by the capabilities of the destination directory, with NSFileProviderItemCapabilitiesAllowsAddingSubItems.

      • deleteItemWithIdentifierCompletionHandler

        public void deleteItemWithIdentifierCompletionHandler​(java.lang.String itemIdentifier,
                                                      NSFileProviderExtension.Block_deleteItemWithIdentifierCompletionHandler completionHandler)
        Delete an item forever. This is called when the user deletes an item that was already in the Trash and the item should no longer appear there after this call. This call should remove the item from the working set. Delete is gated by the capabilities of the removed item with NSFileProviderItemCapabilitiesAllowsDeleting.

      • enumeratorForContainerItemIdentifierError

        public NSFileProviderEnumerator enumeratorForContainerItemIdentifierError​(java.lang.String containerItemIdentifier,
                                                                          org.moe.natj.general.ptr.Ptr<NSError> error)
        Create an enumerator for an item. When the user opens the browse tab of the UIDocumentsBrowserViewController and selects a file provider, this is called with NSFileProviderRootContainerItemIdentifier, and -[NSFileProviderEnumerator enumerateItemsForObserver:startingAtPage:] is immediately called to list the first items available under at the root level of the file provider. As the user navigates down into directories, new enumerators are created with this method, passing in the itemIdentifier of those directories. Past enumerators are then invalidated. This method is also called with NSFileProviderWorkingSetContainerItemIdentifier, which is enumerated with -[NSFileProviderEnumerator enumerateChangesForObserver:fromSyncAnchor:]. That enumeration is special in that it isn't driven by the UIDocumentsBrowserViewController. It happens in the background to sync the working set down to the device. This is also used to subscribe to live updates for a single document. In that case, -[NSFileProviderEnumerator enumerateChangesToObserver:fromSyncAnchor:] will be called and the enumeration results shouldn't include items other than the very item that the enumeration was started on. If returning nil, you must set the error out parameter.

      • fetchThumbnailsForItemIdentifiersRequestedSizePerThumbnailCompletionHandlerCompletionHandler

        public NSProgress fetchThumbnailsForItemIdentifiersRequestedSizePerThumbnailCompletionHandlerCompletionHandler​(NSArray<java.lang.String> itemIdentifiers,
                                                                                                               CGSize size,
                                                                                                               NSFileProviderExtension.Block_fetchThumbnailsForItemIdentifiersRequestedSizePerThumbnailCompletionHandlerCompletionHandler_2 perThumbnailCompletionHandler,
                                                                                                               NSFileProviderExtension.Block_fetchThumbnailsForItemIdentifiersRequestedSizePerThumbnailCompletionHandlerCompletionHandler_3 completionHandler)
        The system calls this method to fetch thumbnails. The @p perThumbnailCompletionHandler should be called for each thumbnail, and [@p] completionHandler only after all the per thumbnail completion blocks. In the event of a global error, the implementation is allowed to skip calling the @p perThumbnailCompletionHandler for individual thumbnails. In that case, the @p completionHandler's error parameter would apply to all item identifiers for which @p perThumbnailCompletionHandler had not been called. If there is no thumbnail for a given item, the @p perThumbnailCompletionHandler should be called with its @p imageData and @p error parameters both set to nil. If the system decides that an in-flight thumbnail request is not needed anymore, it will call the returned @p NSProgress object's @p -cancel method, at which time the implementation should clean up any held resources. The system will cache the thumbnail for the item, and the cache will be invalidated when itemVersion.contentVersion changes.

      • importDocumentAtURLToParentItemIdentifierCompletionHandler

        public void importDocumentAtURLToParentItemIdentifierCompletionHandler​(NSURL fileURL,
                                                                       java.lang.String parentItemIdentifier,
                                                                       NSFileProviderExtension.Block_importDocumentAtURLToParentItemIdentifierCompletionHandler completionHandler)
        Import a document. The file or package at fileURL should be moved on disk into the file provider's own storage, where it will later be uploaded. The completion block should be executed after the move on disk, but before the upload. Before doing any network, actually. In the completion block, importedDocumentItem should have these properties set: - itemIdentifier - parentItemIdentifier (to the value passed in to this method) - filename (to fileURL's resource value for key NSURLNameKey) - creationDate (to NSURLCreationDateKey) - contentModificationDate (to NSURLContentModificationDateKey) - typeIdentifier (to NSURLTypeIdentifierKey) - documentSize (to NSURLTotalFileSizeKey on a flat file, or to the sum of the files sizes for a package) - capabilities [fileURL startAccessingSecurityScopedResource] needs to be called prior to accessing this security scoped URL, and stopAccessingSecurityScopedResource needs to be called when done. Note that itemIdentifier should be set with no network call. It doesn't have to be the final identifier. If the identifier changes after talking to the server then the file provider should send a delete for the temporary, local identifier immediately followed by an add with the final identifier. A reasonable way of organizing files in the file provider storage is: //. If the item identifier was to change, you should move the file on disk to update its path, under coordination with NSFileCoordinatorWritingForMoving. This is expected to work offline even if there might be a collision (another item with the same filename and parentItemIdentifier) only detected when later syncing up this change to the server. In that case, it is suggested that a follow up update to the item change its filename to something unique. This wouldn't be considered an error to import. If however you can tell right away, with no communication to your server, that there is a collision then this call should fail with error code NSFileProviderErrorFilenameCollision generated with this method: -[NSError (NSFileProviderError) fileProviderErrorForCollisionWithItem:]. The existing item set in this error will be used to handle the collision, and ask the user if she or he would like to replace the existing item. This takes into account the existing item's capabilities (particularly NSFileProviderItemCapabilitiesAllowsTrashing and AllowsDeleting.) Collision checks should be case insensitive even if the filesystem or file provider might allow two coexisting filenames differing only by their case. Upload errors (such as NSFileProviderErrorInsufficientQuota) should be handled with a subsequent update to the item, setting its uploadingError property. Upload errors should not prevent creating or importing a document, because they can be resolved at a later date (for example, when the user has quota again.) Other errors will be presented to the user, but are unexpected. If you want to prevent imports in a given directory, then the directory item's capacities should exclude NSFileProviderItemCapabilitiesAllowsAddingSubItems.

      • renameItemWithIdentifierToNameCompletionHandler

        public void renameItemWithIdentifierToNameCompletionHandler​(java.lang.String itemIdentifier,
                                                            java.lang.String itemName,
                                                            NSFileProviderExtension.Block_renameItemWithIdentifierToNameCompletionHandler completionHandler)
        Rename a document or a directory. This is expected to complete before doing any network. itemName is the full file or directory name, complete with its file extension. In the completion block, property renamedItem.filename should change to itemName. Property renamedItem.displayName should also be updated if you chose to overwrite that method. Errors (including collision errors) are handled as documented for the import method above. Renames are gated by the capabilities of the renamed item, with NSFileProviderItemCapabilitiesAllowsRenaming.

      • reparentItemWithIdentifierToParentItemWithIdentifierNewNameCompletionHandler

        public void reparentItemWithIdentifierToParentItemWithIdentifierNewNameCompletionHandler​(java.lang.String itemIdentifier,
                                                                                         java.lang.String parentItemIdentifier,
                                                                                         java.lang.String newName,
                                                                                         NSFileProviderExtension.Block_reparentItemWithIdentifierToParentItemWithIdentifierNewNameCompletionHandler completionHandler)
        Move an item to a new directory. This is expected to complete before doing any network. If newName is non null, the moved item should be renamed to newName. Errors (including collision errors) are handled as documented for the import method above. Moves are gated by the capabilities of both the moved item with NSFileProviderItemCapabilitiesAllowsReparenting, and the destination directory with NSFileProviderItemCapabilitiesAllowsAddingSubItems.

      • setFavoriteRankForItemIdentifierCompletionHandler

        public void setFavoriteRankForItemIdentifierCompletionHandler​(NSNumber favoriteRank,
                                                              java.lang.String itemIdentifier,
                                                              NSFileProviderExtension.Block_setFavoriteRankForItemIdentifierCompletionHandler completionHandler)
        Mark a directory as favorite (or no longer favorite if favoriteRank is nil.) The favorite rank is used to represent the relative order of two favorite directories in the UI. It is a 64 bit unsigned integer. It needs to be synced. Favorite directories are relevant to the user and should be in the working set even if they haven't been used recently. The documents and directories in the favorite directory however don't all have to be in the working set, and don't all have to be made accessible offline. The file provider is asked to persist the new favorite rank on disk, then call the completion callback with the updated favorite rank. At a later point, the file provider should sync the new favorite rank to their server.

      • setLastUsedDateForItemIdentifierCompletionHandler

        public void setLastUsedDateForItemIdentifierCompletionHandler​(NSDate lastUsedDate,
                                                              java.lang.String itemIdentifier,
                                                              NSFileProviderExtension.Block_setLastUsedDateForItemIdentifierCompletionHandler completionHandler)
        Mark an item as recently used, or clear its lastUsedDate if nil. This last used date is the sort key for the recent lists. It is the primary hint that an item must belong to the working set cached and indexed on the user's device. The file provider is asked to persist the new last used date on disk, then call the completion callback with the updated last used date. At a later point, the file provider should sync the new last used date to their server. The error parameter is here for debugging purposes alone; it won't be presented to the user or otherwise handled, but it will be logged.

      • setTagDataForItemIdentifierCompletionHandler

        public void setTagDataForItemIdentifierCompletionHandler​(NSData tagData,
                                                         java.lang.String itemIdentifier,
                                                         NSFileProviderExtension.Block_setTagDataForItemIdentifierCompletionHandler completionHandler)
        Tag an item, or untag it if tagData is nil. The file provider is asked to persist the new tag data on disk, then call the completion callback with the updated tagged data. At a later point, the file provider should sync the new tag data to their server. Tagged items are relevant to the user and should be in the working set even if they haven't been used recently. If set, the error will be immediately presented to the user and the item just won't be tagged. On shared items, tags should sync across the devices of any one participant but shouldn't sync across users.

      • supportedServiceSourcesForItemIdentifierError

        public NSArray<?> supportedServiceSourcesForItemIdentifierError​(java.lang.String itemIdentifier,
                                                                org.moe.natj.general.ptr.Ptr<NSError> error)

      • trashItemWithIdentifierCompletionHandler

        public void trashItemWithIdentifierCompletionHandler​(java.lang.String itemIdentifier,
                                                     NSFileProviderExtension.Block_trashItemWithIdentifierCompletionHandler completionHandler)
        Move an item to the trash. In the completion block, property trashedItem.isTrashed should be set to YES. You should keep track of the original parentItemIdentifier of the item before it was moved to trash, so you can move the item back where it used to be in the untrash method. You could use the trashedItem.parentItemIdentifier property for that. The trashed item should continue to belong to the working set of documents cached on the device and visible offline to the user. But if it is a directory, then all of its children should be removed from the working set and the file provider extension should send deletion events to make sure that they no longer appear in the recent lists. It is also suggested that shared documents be unshared when trashed. Trash is gated by the capabilities of the trashed item with NSFileProviderItemCapabilitiesAllowsTrashing.

      • untrashItemWithIdentifierToParentItemIdentifierCompletionHandler

        public void untrashItemWithIdentifierToParentItemIdentifierCompletionHandler​(java.lang.String itemIdentifier,
                                                                             java.lang.String parentItemIdentifier,
                                                                             NSFileProviderExtension.Block_untrashItemWithIdentifierToParentItemIdentifierCompletionHandler completionHandler)
        Move an item out of the trash. If parentItemIdentifier is nil, the file provider should attempt to put the item back where it was when it was moved to the trash; otherwise it should move it to this new parent. If the item is a directory, then the file provider extension should enumerate the children and send addition events in the working set so that the documents in the now untrashed directory may be reindexed. Untrash is gated by the capabilities of the destination directory, with NSFileProviderItemCapabilitiesAllowsAddingSubItems.