import 'package:flutter/widgets.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await FMTCObjectBoxBackend().initialise(...);
// ...
runApp(MyApp());
}
// ...
await FMTCStore('mapStore').manage.create();
// ...
If it does not build successfully
If the error message seems to indicate that the "Android NDK" version needs to be higher, follow the instructions. Usually this involves the following change to your app-level build.gradle(.kts) config:android {
namespace = "*"
compileSdk = flutter.compileSdkVersion
- ndkVersion = flutter.ndkVersion
+ ndkVersion = <the version specified at the end of the error log>
...
}
<dict>
<key>com.apple.security.application-groups</key>
<array>
<string>FGDTDLOBXDJ.demo</string>
</array>
...
</dict>
Absorbed FMTCTileProviderSettings directly into FMTCTileProvider
The properties within have become properties directly in `FMTCTileProvider`. This also means the automatic global system (where the settings could be set once then used everywhere) has also been removed.
The simplifies the code internals and removes an unnecessary layer of abstraction.
Replaced maxStoreLength with property directly on stores
It has been replaced with a property on each store itself. It can be set at creation, or changed after, and read at any time:
```dart
await FMTCStore('storeName').manage.create(maxLength: 1000);
await FMTCStore('storeName').manage.setMaxLength(null); // Disable max length
final maxLength = await FMTCStore('storeName').manage.maxLength;
```
This is more suitable for providers now that more than one store may be used, potentially each with a different maximum length.
Replaced obscuredQueryParams with urlTransformer
It has been replaced on the `FMTCTileProvider` with a more flexible custom callback which may perform any processing logic required, and a utility method if the old behaviour is still desired.
To migrate directly, see the example setup: [Integrating With A Map](/usage/integrating-with-a-map#two-static-named-stores-with-a-url-transformer).
Renamed CacheBehavior with BrowseLoadingStrategy
This has been renamed to fit better with a newly introduced enumerable that work together to configure the tile provider's logic.
(And also, no more US/UK confusion :D)
startForeground now returns two streams
It now returns one stream of `DownloadProgress`s, and one of the new `TileEvent`s. This means that checks no longer have to be made to ensure a `TileEvent` is not a repeated event (except where using the new feature to retry failed tiles, discussed below), and also means they can be more easily listened to independently.
To migrate, listen to necessary streams seperately.
Renovated TileEvent completely
Properties in v9 were nullable dependent on whether they were available, and this could be checked with `.result` (`TileEventResult`).
`TileEvent` has been split into a tree of classes, which are sealed. This means that the available properties are fully safe and no null-checks need to be made. Switch-case statements and normal `is` checks can be used, which statically changes the type of the `TileEvent` to a subtype appropriately. Each subtype represents a specific outcome of the tile download, and mixes in certain types.
* `SuccessfulTileEvent` is emitted when a tile is successfully downloaded\
*Root subtype, mixes in `TileEventFetchResponse` (makes the raw fetch response from the server available) and `TileEventImage` (makes tile image available)*
* `SkippedTileEvent` (\*[^1])\
*Root subtype, mixes in `TileEventImage`*
* `ExistingTileEvent` is emitted when a tile is skipped because it already exists
* `SeaTileEvent` is emitted when a tile is skipped because it was a sea tile\
*Also mixes in `TileEventFetchResponse`*
* `FailedTileEvent` (\*[^1])\
*Root subtype*
* `NegativeResponseTileEvent` is emitted when a tile fails because the server did not respond with 200 OK\
*Mixes in `TileEventFetchResponse`*
* `FailedRequestTileEvent` is emitted when a tile fails because the request to the server was not made successfully (eligible for retry)
Renamed properties within DownloadProgress
Most are renamed obviously to improve clarity. Some may have had the exact included figures changed.
import 'package:flutter/widgets.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
try {
await FMTCObjectBoxBackend().initialise(...); // The default/built-in backend
} catch (error, stackTrace) {
// See below for error/exception handling
}
// ...
runApp(MyApp());
}
// final root = FMTCRoot;
final databaseSize = await FMTCRoot.stats.realSize;
// final store = FMTCStore('storeName');
await FMTCStore('storeName').manage.create(); // Creates the store
Customizing the interaction with otherStoresStrategy (if set)
The `useOtherStoresAsFallbackOnly` parameter concerns the behaviour of FMTC when a tile does not belong to any stores set in the `stores` mapping, but does belong to stores covered by `otherStoresStrategy`.
* If `false` (as default), then the tile will be used without attempting the fallback method.
* If `true`, then the tile will only be used if the fallback method fails.
This is not of concern if the strategy is `onlineFirst`, as if the always-attempted network fetch fails, the tile will always be used from the unspecified store.
Basic hits & misses statistics (recordHitsAndMisses)
By default, every tile attempted during browsing records either a hit or miss.
A hit is recorded when a tile is read from the cache without attempting the network in all stores in which the tile exists & were present in the `stores` mapping (and not explicitly set `null`), or in which the tile exists if `otherStoresStrategy` was set.
In every other case, a miss is recorded in all stores present in the `stores` mapping (and not explicitly set `null`), or in all stores if `otherStoresStrategy` was set.
This information may not be useful or used in many apps, and so it may be disabled by setting it `false`. This will also improve performance (reduce tile loading times and device memory/storage operations). Additionally, more detailed and advanced metrics may be obtained by setting up a `tileLoadingInterceptor` (as below).
Handle tile load failures (errorHandler)
*This feature is completely standalone to the `TileLayer`'s `errorImage`.*
By default, when a tile cannot be loaded, an `FMTCBrowsingError` is thrown containing some information about why the load failed. This is because *something* must be returned or thrown by internal `ImageProvider`.
However, it is possible to provide an error handler, which gets passed the failure as an argument, and may optionally return bytes (which must be decodable by Flutter). If it does return bytes, the error will not be thrown, and instead the bytes will be displayed in place of the tile image.
Intercept tile load events & info (tileLoadingInterceptor)
To track (eg. for debugging and logging) the internal tile loading mechanisms, an interceptor may be used.
For example, this could be used to debug why tiles aren't loading as expected (perhaps in combination with `TileLayer.tileBuilder` & `ValueListenableBuilder` as in the example app), or to perform more advanced monitoring and logging than the hit & miss statistics provide.
The interceptor consists of a `ValueNotifier`, which allows FMTC internals to notify & push updates of tile loads, and allows the owner to listen for changes as well as retrieve the latest update (`value`) immediately.\
The object within the `ValueNotifier` is a mapping of `TileCoordinates` to [`TileLoadingInterceptorResult`](https://pub.dev/documentation/flutter_map_tile_caching/10.0.0-dev.7/flutter_map_tile_caching/TileLoadingInterceptorResult-class.html)s.
final (:downloadProgress, :tileEvents) =
const FMTCStore('mapStore').download.startForeground(
...
);
the Land Tile
90% chance
the Sea Tile
10% chance
◉ 📲 Integrated Caching × Bulk Downloading | Get both dynamic browse caching that works automatically as the user browses the map, and bulk downloading to preload regions onto the user's device, all in one convenient, integrated API! | ||
◉ 🏃 Ultra-fast & Performant | No need to bore your users to death anymore! Bulk downloading is super-fast, and can even reach speeds of over 1000 tiles per second*. Existing cached tiles can be displayed on the map almost instantly. |
| |
◉ 🧩 Import & Export | Export and share stores, then import them later, or on other devices! You could even remote control your organization's devices, by pushing tiles to them, keeping your tile requests (& costs) low! | ||
◉ 💖 Quick To Implement & Easy To Experiment | A basic caching implementation can be setup in four quick steps, and shouldn't even take 5 minutes to set-up. Check out our /pages/ZLHYkAJpLD5h8yB2SNyt instructions. | Ready to experiment with bulk downloading, but don't want to make costly and slow tile requests? Check out the testing tile server included in the FMTC project: /pages/MwEjeVx1V910UW5bCitN! |
All I see are rectangles. I don't want rectangles.
Whether it's walking along a remote winding river using the [Line region](/v9/bulk-downloading/regions#poly-line), downloading all of central London ready for that weekend exploration using the [Circle region](/v9/bulk-downloading/regions#circle) (roaming fees + maps gets expensive fast!), or tracking your belongings across a vast, shapeless space using the [Custom Polygon region](/v9/bulk-downloading/regions#custom-polygon), FMTC has your user's back - but not all of their storage space!There's too much blue in my map. Can I avoid storing useless sea tiles?
With Sea Tile Skipping, you can avoid storing those unneccessary tiles of sea, then use the map client's functonality to just paint the spaces the same color as the sea. This also preserves sea tiles that aren't so empty after all - that boat path could come in handy. Just another way FMTC keeps your user's phone bloat free ;)I need to download something else for a moment. Do I really have to stop the entire download and start again?
Not with FMTC! Downloads can be paused and resumed at any time, and with Download Recovery, downloads that stopped unexpectedly can be started right from where they left off, without your user even knowing something went wrong.I wonder how much it costs the app developers?
FMTC supports bulk downloading from any tile server\*[^9], so you can choose whichever one suits you best. Our browse caching mechanism doesn't result in any extra requests to the tile server, and in fact can reduce costs by serving tiles to users from their local cache without cost. Or, if you're running your own server, you can reduce the strain on it, keeping it snappy with fewer resources! Downloads can be rate limited to avoid running up to the server's rate limit or excess fee. And with export/import functionality, user's can download regions just once, then keep the download themselves for another time. Or, you can provide a bundle of tiles to all your user's, while still allow it to be updated per-user in future!\*[^10]import 'package:flutter/widgets.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await FMTCObjectBoxBackend().initialise(...);
// ...
runApp(MyApp());
}
// ...
await FMTCStore('mapStore').manage.create();
// ...
import 'package:flutter_map/flutter_map.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
TileLayer(
urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
userAgentPackageName: 'com.example.app',
tileProvider: FMTCStore('mapStore').getTileProvider(),
// Other parameters as normal
),
Removed the FlutterMapTileCaching/FMTC object, in favour of direct usage of FMTCStore and FMTCRoot (which replace StoreDirectory & RootDirectory)
Much of the configuration and state management performed by the `FlutterMapTileCaching` top-level object singleton, and it's close relatives, were transferred to the backend, and as such, there is no longer a requirement for these objects.
Additionally, the name 'directory' has been outdated for a while. Therefore, these changes were merged into one.
To migrate, follow these patterns:
{% code title="Previous" %}
```dart
// Get a store directory
final StoreDirectory oldStore = FlutterMapTileCaching.instance('storeName'); // (or `FMTC.`)
// Access the root statistics
final RootDirectory oldRoot = FlutterMapTileCaching.instance.rootDirectory; // (or `FMTC.`)
final RootStats oldRootStats = oldRoot.stats;
```
{% endcode %}
// Get a store
final FMTCStore newStore = FMTCStore('storeName');
// Access the root statistics
final RootStats newRootStats = FMTCRoot.stats;
// `FMTCRoot` must now be used immediately, because it is not an object instance
Changed the method of initialisation & error handling
Due to the removal of the `FMTC` object, and introduction of multiple-backend support, initialisation is now performed directly on a backend. The backend then creates a link between itself and its implementation to the abstracted convienience methods and front. Additionally, error handling has been improved throughout FMTC, and is now more consitent and stable, doesn't rely on callbacks, and error `StackTrace`s include more useful information. For the default, built-in backend, migration is simple: {% code title="Previous" %} ```dart await FlutterMapTileCaching.initialise( errorHandler: (FMTCInitialisationException e) {}, ); ``` {% endcode %} {% code title="Migrated" %} ```dart try { await FMTCObjectBoxBackend().initialise(); } catch (error, stackTrace) { // Improved error handling } ``` {% endcode %} For more information, see [Initialisation](/v9/general/initialisation) & [Error Handling](/v9/general/error-handling).Removed support for synchronous operations (and renamed asynchronous operations to reflect this)
These were incompatible with the new `Isolate`d `FMTCObjectBoxBackend`, they've been removed, in favour of backends implementing their own `Isolate`ion as well. There is no direct migration instructions, as the correct new solution is case-dependent. In non-widget environments, use asynchronous techniques. In widget builds, make use of `FutureBuilder`s.\ However, the members have all been renamed in the same form: `*Async` is now just `*`.Refactored DownloadableRegion & removed RegionType
`DownloadableRegion` no longer contains the outline `points` of the `BaseRegion` it was formed from. It also no longer contains `parallelThreads`, `preventRedownload`, and `seaTileRemoval`: these are now configurable at download-time. `errorHandler` has been removed altogether.
Additionally, `DownloadableRegion` now makes use of sealed typing by using the type argument to contain the type of `BaseRegion`, so `RegionType` has become redundant and been removed.
Background downloading plugin deprecated without replacement
'package:fmtc\_plus\_background\_downloading' has been deprecated without replacment. It was becoming increasing unstable, and depended on unmaintained, unstable, and small packages. It also only supported Android, and did not properly work in many cases. Therefore, the plugin has been deprecated without replacement. The functionality may be re-introduced into the core at a later point.Sharing plugin deprecated, external replacement functionality introduced into core
'package:fmtc\_plus\_sharing' has been deprecated, and the importing/exporting functionality introduced into the core, as [External](/v9/external/introduction).
There is no replacement for the GUI/file picker functionality, to keep core dependencies minimized.
RootStats & StoreStats members are no longer prefixed with 'root' & 'store'/'cache'
These terms were redundant, and have been removed.
For example, `rootSize` is now just `size`, and `cacheHits` is now just `hits`.
Replaced RootStats.watchChanges with watchStores & watchRecovery
`watchStores` now watches for changes in statistics (which should change whenever tiles are changed), and changes in metadata in the specified stores. `watchRecovery` is now used to watch for changes to the recovery system.
This was done to simplify the APIs and allow for the removal of `StoreParts` (which has been removed without deprecation).
Removed FMTCSettings
`FMTCSettings` have been split apart. `databaseMaxSize` now has an equivalent in the configuration of the `FMTCObjectBoxBackend`, `databaseCompactCondition` has been removed without replacement, and `defaultTileProviderSettings` has been removed in favour of a singleton-ish `FMTCTileProviderSettings`.
`FMTCTileProviderSettings` may now be set as a global instance (which works the same as the old `FMTCSettings` option) just by constructing it. Alternatively, one can be constructed without setting the global instance by setting `setInstance` `false` in the arguments.
import 'package:flutter/widgets.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
try {
await FMTCObjectBoxBackend().initialise(...); // The default/built-in backend
} catch (error, stackTrace) {
// See below for error/exception handling
}
// ...
runApp(MyApp());
}
// final store = FMTCStore('storeName');
await FMTCStore('storeName').manage.create(); // Refers to the same store as above
Management: manage | Control the store: create it, delete it, rename it, etc. | /pages/ri5PBUsJHrSWfQvdWb6n |
Statistics: stats | Retrieve information about the store and its contents | /pages/WQ0maJmptG7ue7YiFbtN |
Metadata: metadata | Access simple persistent storage, with no direct influence on FMTC's functioning | /pages/X3FJe4OjIZh4wpucEFk1 |
Bulk Download: download | Prepare/plan, start, and manage bulk downloads | /pages/4bgyDv2CUBwkhbfFwaAJ |
Integrate With TileLayer | Generate a specialised TileProvider that allows flutter_map to access cached tiles | /pages/qr1Ja34BhspEihyVfR5I |
final mgmt = FMTCStore('storeName').manage;
await mgmt.ready; // Check whether the store exists
await mgmt.create(); // Create the store
await mgmt.delete(); // Empty tiles from the store, and delete it
await mgmt.reset(); // Empty tiles from the store, and reset hits & misses
await mgmt.rename('newStoreName'); // Change the name of the store
await mgmt.removeTilesOlderThan(DateTime.timestamp()); // Empty all tiles last modified before the specified timestamp
final stats = FMTCStore('storeName').stats;
await stats.all; // Retrieve the size, length, hits, and misses of this store
await stats.size; // Retrieve the total number of KiBs of all tiles' bytes (not 'real total' size)
await stats.length; // Retrieve the number of tiles belonging to this store
await stats.hits; // Retrieve the number of successful tile retrievals when browsing
await stats.misses; // Retrieve number of unsuccessful tile retrievals when browsing
await stats.tileImage(); // Retrieve the tile most recently modified in the specified store
await stats.watchChanges(); // Watch for changes to statistics (including tile events) and metadata
final md = FMTCStore('storeName').metadata;
await md.read; // Retrieve (all) the stored metadata
await md.set(); // Set a single key-value pair (overwriting any existing value for the key)
await md.setBulk(); // Set multiple key-value pairs (overwriting any existing value for each key)
await md.remove(); // Remove the specified key (and corresponding value)
await md.reset(); // Remove all keys (and values)
// final root = FMTCRoot;
final size = await FMTCRoot.stats.realSize;
Statistics: stats | Retrieve information about the store and its contents | /pages/UOIziKDB99IWWpU0pUid |
Recovery: recovery | Recovery from unexpectedly failed bulk downloads | /pages/QjStFkRCKXgLWD1lY19Q |
External: external | Export & import store archives | /pages/1fyswNKNfX7IotiQh9N8 |
final stats = FMTCRoot.stats;
await stats.storesAvailable; // List all the available/existing stores
await stats.realSize; // Retrieve the actual total size of the database in KiBs
await stats.size; // Retrieve the total number of KiBs of all tiles' bytes (not 'real total' size) from all stores
await stats.length; // Retrieve the total number of tiles in all stores
await stats.watchRecovery(); // Watch for changes to the recovery system
await stats.watchStores(); // Watch for changes in the specified (or all) stores
final rec = FMTCRoot.recovery;
await rec.recoverableRegions; // List all recoverable regions, and whether each one has failed
await rec.recoverableRegions.failedOnly; // List all failed downloads
await stats.getRecoverableRegion(); // Retrieve a specific recoverable region by ID
await stats.cancel(); // Safely remove the specified recoverable region
| Parameter | Description | Default |
|---|---|---|
behavior: CacheBehavior | Determine the logic used during handling storage and retrieval of browse caching | CacheBehavior.cacheFirst |
cachedValidDuration: Duration | Length of time a tile remains valid, after which it must be fetched again (ignored in onlineFirst mode) | const Duration(days: 16) |
maxStoreLength: int | Maximum number of tiles allowed in a cache store (deletes oldest tile) | 0: disabled |
obscuredQueryParams: List<String> | See #obscuring-query-parameters | []: empty |
| Value | Explanation |
|---|---|
cacheFirst | Get tiles from the local cache if possible. Only uses the Internet if it doesn't exist, or to update it if it has expired. |
onlineFirst | Get tiles from the Internet if possible. Updates every cached tile every time it is fetched (ignores expiry). |
cacheOnly | Only get tiles from the local cache, and throw an error if not found. Recommended for dedicated offline modes. |
https://tile.myserver.com/{z}/{x}/{y}?api_key=001239876&mode=dark
https://tile.myserver.com/{z}/{x}/{y}?&mode=dark
Memory Consumption
Avoid keeping a list of *all* emitted events. Instead, keep a 'circular buffer' of the useful subset of events. A single download can have many events, and storing them all will consume a lot of memory. It is easy to consume all of the remaining allocated memory, and crash the app.Data Loss
Avoid keeping track of required information internally through a `StreamBuilder` intended to display a UI. A `StreamBuilder` will not necessarily call the `builder` callback once per event, especially if the download has a high TPS. Therefore, events may be lost.Data Duplication
Avoid keeping track of events where the `latestTileEvent.isRepeat` property is `true`. These `TileEvents` are exact repeats of the previous event, usually due to the `maxReportInterval` functionality. Therefore, including both in a dataset would be erroneous.the Land Tile
90% chance
the Sea Tile
10% chance
◉ 📲 Caching × Downloading | Get both dynamic caching that works automatically as the user browses the map, and bulk downloading to preload regions onto the user's device, all in one convenient package! | ||
◉ 🏃 Ultra-fast & Performant | No need to bore your users to death anymore! Bulk downloading is super-fast, and can even reach speeds of over 600 tiles per second*. Existing cached tiles can be displayed on the map almost instantly. Don't even mention memory consumption: you won't realise there is any. |
| |
◉ 🧩 Import & Export | Using one of our official extension modules, allow your users to share* and backup their cached tiles! You could even remote control your organization's devices, by pushing tiles to them, keeping your tile requests (& costs) low! | ||
◉ 💖 Quick To Implement (& Quicker To Love) | A basic caching implementation can be setup in four quick steps, and shouldn't even take 5 minutes to set-up. Check out our /pages/ZLHYkAJpLD5h8yB2SNyt instructions. | When you've done this, you'll realise how great your app is with FMTC 😄 |
import 'package:flutter/widgets.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await FlutterMapTileCaching.initialise();
// ...
// runApp(MyApp());
}
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await FlutterMapTileCaching.initialise();
await FMTC.instance('mapStore').manage.createAsync();
// ...
// runApp(MyApp());
}
import 'package:flutter_map/flutter_map.dart';
TileLayer(
urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
userAgentPackageName: 'com.example.app',
tileProvider: FMTC.instance('mapStore').getTileProvider(),
// Other parameters as normal
),
flutter pub add flutter_map_tile_caching
flutter pub add fmtc_plus_background_downloading # OPTIONAL
flutter pub add fmtc_plus_sharing # OPTIONAL
dependency_overrides:
flutter_map_tile_caching:
git:
url: https://github.com/JaffaKetchup/flutter_map_tile_caching.git
fmtc_plus_background_downloading: # OPTIONAL
git:
url: https://github.com/JaffaKetchup/fmtc_plus_background_downloading.git
fmtc_plus_sharing: # OPTIONAL
git:
url: https://github.com/JaffaKetchup/fmtc_plus_sharing.git
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
import 'package:fmtc_plus_background_downloading/fmtc_plus_background_downloading.dart'; // OPTIONAL
import 'package:fmtc_plus_sharing/fmtc_plus_sharing.dart'; // OPTIONAL
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="packageName">
+ <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+ <uses-permission android:name="android.permission.WAKE_LOCK" />
+ <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
<application android:label="appName" android:icon="appIcon">
Pod::PICKER_MEDIA = false
Pod::PICKER_AUDIO = false
Pod::PICKER_DOCUMENT = false
import 'package:flutter/widgets.dart';
import 'package:flutter_map_tile_caching/flutter_map_tile_caching.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await FlutterMapTileCaching.initialise();
// FMTC.instance;
// Run your app and do all of that other stuff
}
final store = FlutterMapTileCaching.instance('storeName');
await store.manage.create(); // Create the store if necessary
manage | Roots, Stores | Control, modify, and configure an actual structure ('physical' directory or database) itself | /pages/ri5PBUsJHrSWfQvdWb6n |
stats | Roots, Stores | Retrieve statistics about a structure (Root or Store) itself | /pages/UOIziKDB99IWWpU0pUid |
recovery | Roots | Recover failed bulk downloads, and prepare them to restart | /pages/QjStFkRCKXgLWD1lY19Q |
migrator | Roots | Migrate the incompatible file/directory structure of a previous version | /spaces/etKuLqkz5OWV0AkZjLDp/pages/mWbONoysCtvaNu4GN4vq |
import | Roots, Module | Import and prepare a store from a previously exported archive file | /pages/dNNHdkCG2AVlQpTdqMT6 |
download | Stores | Prepare, start, and manage a store's bulk downloads | /pages/NL6IkXezlNFKRvn948DA |
metadata | Stores | A simple key-value pair store designed for storing simple, store related information | /pages/X3FJe4OjIZh4wpucEFk1 |
export | Stores, Module | Export a store to an archive file, for future importing | /pages/44zofqBvlqr0bRZoNJaJ |
| Parameter | Description | Default |
|---|---|---|
behavior: CacheBehavior | Determine the logic used during handling storage and retrieval of browse caching | CacheBehavior.cacheFirst |
cachedValidDuration: Duration | Length of time a tile remains valid, after which it must be fetched again (ignored in onlineFirst mode) | const Duration(days: 16) |
maxStoreLength: int | Maximum number of tiles allowed in a cache store (deletes oldest tile) | 0: disabled |
obscuredQueryParams: List<String> | See #obscuring-query-parameters | []: empty |
| Value | Explanation |
|---|---|
cacheFirst | Get tiles from the local cache if possible. Only uses the Internet if it doesn't exist, or to update it if it has expired. |
onlineFirst | Get tiles from the Internet if possible. Updates every cached tile every time it is fetched (ignores expiry). |
cacheOnly | Only get tiles from the local cache, and throw an error if not found. Recommended for dedicated offline modes. |
https://tile.myserver.com/{z}/{x}/{y}?api_key=001239876&mode=dark
https://tile.myserver.com/{z}/{x}/{y}?&mode=dark
| API Member | Explanation |
|---|---|
startForeground() | Start a download in the foreground |
startBackground() | Start a download in the background |
check() | Check the number of tiles in a certain region |
cancel() | Cancel any ongoing downloads |