SimpleCache

SimpleCache(cacheDir: File!, evictor: CacheEvictor!)

Constructs the cache. The cache will delete any unrecognized files from the directory. Hence the directory cannot be used to store other files.

SimpleCache(
    cacheDir: File!,
    evictor: CacheEvictor!,
    databaseProvider: DatabaseProvider!
)

Constructs the cache. The cache will delete any unrecognized files from the directory. Hence the directory cannot be used to store other files.

SimpleCache(
    cacheDir: File!,
    evictor: CacheEvictor!,
    databaseProvider: DatabaseProvider?,
    legacyIndexSecretKey: ByteArray?,
    legacyIndexEncrypt: Boolean,
    preferLegacyIndex: Boolean
)

Constructs the cache. The cache will delete any unrecognized files from the cache directory. Hence the directory cannot be used to store other files.

synchronized fun addListener(key: String!, listener: Cache.Listener!): NavigableSet<CacheSpan!>!

Registers a listener to listen for changes to a given resource.

No guarantees are made about the thread or threads on which the listener is called, but it is guaranteed that listener methods will be called in a serial fashion (i.e. one at a time) and in the same order as events occurred.

synchronized fun applyContentMetadataMutations(
    key: String!,
    mutations: ContentMetadataMutations!
): Unit

Applies mutations to the ContentMetadata for the given resource. A new is added if there isn't one already for the resource.

This method may be slow and shouldn't normally be called on the main thread.

synchronized fun checkInitialization(): Unit

Checks whether the cache was initialized successfully.

synchronized fun commitFile(file: File!, length: Long): Unit

Commits a file into the cache. Must only be called when holding a corresponding hole obtained from startReadWrite.

This method may be slow and shouldn't normally be called on the main thread.

@WorkerThread
java-static fun delete(cacheDir: File!, databaseProvider: DatabaseProvider?): Unit

Deletes all content belonging to a cache instance.

This method may be slow and shouldn't normally be called on the main thread.

synchronized fun getCacheSpace(): Long

Returns the total disk space in bytes used by the cache.

synchronized fun getCachedBytes(key: String!, position: Long, length: Long): Long

Returns the total number of cached bytes between position (inclusive) and (position + length) (exclusive) of a resource.

synchronized fun getCachedLength(key: String!, position: Long, length: Long): Long

Returns the length of continuously cached data starting from position, up to a maximum of maxLength, of a resource. If position isn't cached then -holeLength is returned, where holeLength is the length of continuously uncached data starting from position, up to a maximum of maxLength.

synchronized fun getCachedSpans(key: String!): NavigableSet<CacheSpan!>!

Returns the cached spans for a given resource.

synchronized fun getContentMetadata(key: String!): ContentMetadata!

Returns a ContentMetadata for the given resource.

synchronized fun getKeys(): (Mutable)Set<String!>!

Returns the cache keys of all of the resources that are at least partially cached.

synchronized java-static fun isCacheFolderLocked(cacheFolder: File!): Boolean

Returns whether cacheFolder is locked by a SimpleCache instance. To unlock the folder the SimpleCache instance should be released.

synchronized fun isCached(key: String!, position: Long, length: Long): Boolean

Returns whether the specified range of data in a resource is fully cached.

synchronized fun release(): Unit

Releases the cache. This method must be called when the cache is no longer required. The cache must not be used after calling this method.

This method may be slow and shouldn't normally be called on the main thread.

synchronized fun releaseHoleSpan(holeSpan: CacheSpan!): Unit

Releases a CacheSpan obtained from startReadWrite which corresponded to a hole in the cache.

synchronized fun removeListener(key: String!, listener: Cache.Listener!): Unit

Unregisters a listener.

synchronized fun removeResource(key: String!): Unit

Removes all CacheSpans for a resource, deleting the underlying files.

synchronized fun removeSpan(span: CacheSpan!): Unit

Removes a cached CacheSpan from the cache, deleting the underlying file.

This method may be slow and shouldn't normally be called on the main thread.

synchronized fun startFile(key: String!, position: Long, length: Long): File!

Obtains a cache file into which data can be written. Must only be called when holding a corresponding hole CacheSpan obtained from startReadWrite.

This method may be slow and shouldn't normally be called on the main thread.

synchronized fun startReadWrite(key: String!, position: Long, length: Long): CacheSpan!

A caller should invoke this method when they require data starting from a given position in a given resource.

If there is a cache entry that overlaps the position, then the returned CacheSpan defines the file in which the data is stored. isCached is true. The caller may read from the cache file, but does not acquire any locks.

If there is no cache entry overlapping position, then the returned CacheSpan defines a hole in the cache starting at position into which the caller may write as it obtains the data from some other source. The returned CacheSpan serves as a lock. Whilst the caller holds the lock it may write data into the hole. It may split data into multiple files. When the caller has finished writing a file it should commit it to the cache by calling commitFile. When the caller has finished writing, it must release the lock by calling releaseHoleSpan.

This method may be slow and shouldn't normally be called on the main thread.

synchronized fun startReadWriteNonBlocking(key: String!, position: Long, length: Long): CacheSpan?

Same as startReadWrite. However, if the cache entry is locked, then instead of blocking, this method will return null as the CacheSpan.

This method may be slow and shouldn't normally be called on the main thread.

val uid: Long