Clear cache on Mac manually. All the caches created by your apps by default are stored in the system Library or user Library folders. Thus, to clear cache on Mac, you should delete the contents of the following directories in Finder.
Repeat steps 1–4, but use the path /Library/Caches/ (which opens the system cache) in step 2 instead. Enter/Exit Safe Mode. Booting into Safe Mode can help remove redundant or obsolete system-related files on your Mac. To do that, start by turning off your Mac. On my Mac running Big Sur, the files are located in /System/Library/dyld/, dyldsharedcachearm64e, dyldsharedcachex8664 and dyldsharedcachex8664h are 2 GB large each, so I understand that you would like to get rid of them, but, as pointed out by @nohillside, they are part of macOS and can't (and most importantly, shouldn't) be.
Mac: /.nuget/packages & /.local/share/NuGet; Delete it all! Now all your packages will be re-downloaded. Android Library Cache. When you install a support package or google play service previously, a ton of files had to be downloaded. Cleaning CloudKit cache on Mac. Some users ask if it is safe to delete CloudKit folder in Caches. The CloudKit folder is needed for macOS to know which files to upload to the iCloud. They keep the history so syncing happens faster. If the CloudKit folder is too big, the best way to approach is to change caching parameters in System Preferences.
You might want to add a local cache of CloudKit records to your app to support offline use of your app or to improve performance. Or you may already have a data store for your app and you'd like to add support for persisting that data in CloudKit as well.
The General Workflow
After you configure your app to maintain a local cache, here is the general flow your app will follow:
When your app launches for the first time on a new device it will subscribe to changes in the user's private and shared databases.
When a user modifies their data locally on Device A your app will send those changes to CloudKit.
Your app will receive a push notification on the same user's Device B notifying it that there was a change made on the server.
Your app on Device B will ask the server for the changes that occurred since the last time it spoke with the server and then update its local cache with those changes.
Initializating the Container
Your app's initialization logic should run whenever your app launches. Your app should cache locally regardless of whether you've already created your zone(s) and subscriptions so that you aren't issuing unnecessary requests upon every launch.
First the code defines items to be used throughout this example.
Creating Custom Zone(s)
To use the change tracking functionality of CloudKit, you need to store your app data in a custom zone in the user's private database. You can create a custom zone by instantiating a CKModifyRecordZonesOperation object as shown below.
Subscribing to Change Notifications
Your app needs to subscribe to changes made from other devices. Subscriptions tell CloudKit which data you care about so that it can send push notifications to your app when that data changes.
Your app will need to create two subscriptions to database changes (CKDatabaseSubscription objects), one for the private database and one for the shared database.
These subscriptions tell CloudKit to send a push notification to your app on this device any time a record or zone is added, modified, or deleted within the database you created the subscription in.
You likely want to configure your subscriptions to send silent push notifications. These notifications wake your app so that it can fetch changes, but the app will not present an alert to the user.
Listening for Push Notifications
As part of configuring your app to use CloudKit, you will need to configure your app to listen for remote notifications.
Use CKNotification(fromRemoteNotificationDictionary: dict) on the userInfo dictionary to determine whether the remote notification your app receives was triggered by a CKSubscription.
Fetching Changes
After app launch or the receipt of a push, your app uses CKFetchDatabaseChangesOperation and then CKFetchRecordZoneChangesOperation to ask the server for only the changes since the last time it updated.
The key to these operations is the previousServerChangeToken object, which tells the server when your app last spoke to the server, allowing the server to return only the items that were changed since that time.
First your app will use a CKFetchDatabaseChangesOperation to find out which zones have changed and:
Collect the IDs for the new and updated zones.
Clean up local data from zones that were deleted.
Here is some example code to fetch the database changes:
Next your app uses a CKFetchRecordZoneChangesOperation object with the set of zone IDs you just collected to do the following:
Create and update any changed records
Delete any records that no longer exist
Update the zone change tokens
Here is some example code to fetch the zone changes:
The code above has several comments about writing changes to memory and then later flushing those changes to disk. The general flow is as follows.
For databases:
When told about a zone deletion, write that into memory.
When told about a new change token for a database, write that token into memory, then either:
persist all in-memory zone changes to disk (deleting deleted zones, and recording a list of zones that need changes fetched), or
persist zone deletions to disk, and fetch changes for all modified record zones.
Note: When you are fetching database changes, you need to persist all of the per-zone callbacks you received before getting the database change token.
Finally, flush the updated database change token to disk
Similarly, for zones:
When told about a record change in a zone, write that into memory.
When told about a new change token for a zone, commit all in-memory record changes in that zone as well as the updated change token for that zone to disk.
Storing Record Metadata
To relate records in your local data store to records on the server, you will likely need to store the metadata for your records (record name, zone ID, change tag, creation date, and so on). There is a handy method on CKRecord, encodeSystemFieldsWithCoder, that helps you do this for system fields. You will still have to handle your own custom fields separately.
Here is an example of how your app can read the metadata in order to store it locally:
When sending changes to CloudKit based on your local data, you can read the local cache back into CloudKit objects and manipulate them for storage in CloudKit:
Advanced Local Caching
A user can delete your app's data on the CloudKit servers through iCloud Settings->Manage Storage. Your app needs to handle this gracefully and re-create the zone and subscriptions on the server again if they don't exist. The specific error returned in this case is userDeletedZone.
The operation dependency system outlined in the Advanced NSOperations talk from WWDC2015 is a great way to manage your CloudKit operations so that account and network statuses are checked and zones and subscriptions are created at the right time.
The network connection may disappear at any time, so make sure to properly handle networkUnavailable errors from any operation.
Watch for network reachability, and retry the operation when the network becomes available again.
Mac Can I Delete Library Caches
See Also
Mac Caches Delete
Learn more about local caching in the WWDC 2016 CloudKit Best Practices video.
Clear Library Cache Mac
Copyright © 2017 Apple Inc. All Rights Reserved. Terms of Use | Privacy Policy | Updated: 2017-09-19