Caching the Data

Note:

Due to limitation on the emulator, you cannot determine the network connection state. For more information on other limitations, see Emulator Limitations in Using the Emulator at the Android Developer web site.
The delete tombstones for delta query support is not available on OData JSON format.

The Cache API is divided into two parts, one that stores a copy of the entries that you receive from the server called as "server copy " and the other is locally modified entries called as "local copy". You can also use this procedure for online scenarios.

Prerequisites

Use the Caching interface, which is implemented by the Cache class, to create an object to work with.

Initialize the Cache

To initialize all the elements required for a cache to work, use the initializeCache method:

try{
      	ILogger logger = new Logger();
	ICache cache =new Cache(getApplicationContext(),logger);
	cache.initializeCache();
	 
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

Cache can be used in persistable mode (database) and non-persistable mode (memory). By default, cache is persistable.

If you do not want to persist cache to the database, use the following API:

cache.setIsPersistable(false);

Merge to Cache

To incrementally update the cache for server entries with the latest state of server objects, use the mergeEntries method. Every online HTTP GET operation on a URL should be followed by a MergeEntries method to enable the server cache to be in-sync with the backend service. It is important to instate a server cache using the MergeEntries method for all operations to work after a successful online GET request for a URL at the initial stage. It is recommended to optimize GET operation with Delta support to avoid redundancies.

try{
	 ILogger logger = new Logger();
Parser parser = new Parser(pref, logger);
	 ICache cache =new Cache(getApplicationContext(),logger);
cache. initializeCache();
IODataFeed feed = parser.parseODataFeed(entriesdoc, collectionID, schema);
	cache.MergeEntries(feed, EntryURL);parameters.
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

Note: There is no overhead with the cache capabilities, when the parsed content is delivered for presentation, even before merging on to the cache, and when the merging operation is invoked on another thread. So, there is no wait time until the cache is being written.

Read Entry from Cache

You can read entries from the cache method either locally, or from the server.

Server entry – All server entries are stored against a URL key, which is the end-point that returns all the entries you want to cache. Use the readEntriesServer method to read server entries.
Local entry – Read the locally created, deleted, or modified entries based on the entity type (collection to which entry belongs to) and entry ID. Use the readEntriesLocal method to read local entries. Entity type and entry ID are optional parameters, but atleast one parameter must be given. Passing null to entry ID retrieves all the entries for a specified entity type. Passing null to entry type and passing entry Id will retrieve specific entry from cache.
The ODataEntry class of the parser has two member properties. The getIsLocal() property checks if the particular entry is local, and getCachestate () checks if the local entry is created, updated, or deleted on the client. The cache states are represented by the cacheState{Updated,Deleted,Inserted} enum.

You need to combine the server and local entries to display the latest version of data on your application.

/*Read entry from server.*/
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
cache.initializeCache();
	 List<IODataEntry> entries = cache.ReadEntriesServer(urlKey); // return all entries respective to the parameter.
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

/*Read entry from local*/
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
cache. initializeCache();
	 List<IODataEntry> entries = cache.ReadEntriesLocal(CollectionID,EntryID); // return all entries respective to  either of the 	parameters.
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

Managing Locally Modified Entries in Cache

Add Entry to Cache – Use the addEntry() method to create a new entry in the local cache. With Request library, perform an HTTP POST request on the backend to create an entry in backend. After POST is successful, perform an HTTP GET request to fetch the latest server state optimized with delta, and merge the result with server cache on the device. The addEntry() method adds an entry into the local cache. Since the entry ID is generated by the back end in most of the cases, creating a local entry generates a temporary entry ID with which you can manage the cache entry.
```
try{
      //Invoke the HTTP POST request
       ODataEntry entry = new ODataEntry();
       entry.putPropertyValue("<property_name>", "<property_value>");
       String postbody = Parser.buildODataEntryRequestBody(entry, "<collection_ID>", schema, IParser.FORMAT_XML);

	   ILogger logger = new Logger();
	   ICache cache =new Cache(getApplicationContext(),logger);
	   String generated_id =cache.addEntry(entry);
	 //Invoke the HTTP POST request
       BaseRequest post = new BaseRequest();
       post.setRequestMethod(BaseRequest.REQUEST_METHOD_POST);            
       post.setData(postbody.getBytes());
       reqMan.makeRequest(post);
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}
```
Update Entry to Cache – When you make changes that is stored locally on your device in offline mode, it must be cached and persisted locally to be updated in the backend when connectivity returns. This ensures the OData entries are cached to build an application that works with seamless offline-online experience. Use the updateEntry method to create a local copy of the updated entry in cache. With connectivity, perform an update on the back end using an HTTP PUT request. After the updates is successful, perform a HTTP GET request to fetch the latest server state optimized with delta, and merge the result with server cache on the device. The updateEntry method does not generate any temporary ID, as the entry is already associated with the ID generated by the back end.
```
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
cache. initializeCache();
         	cache.updateEntry(entry);
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}
```
Delete Entry from Cache – Use the deleteEntry method to delete a new entry with its ID in the local cache. With connectivity, perform a HTTP DELETE request on the backend to deleted the entry in back end. Post a successful delete on the backend, perform a HTTP GET request to fetch the latest server state optimized with delta, and merge the result with server cache on the device. The SDK reads the entry from the server cache, based on the entry ID, and updates the entry in the local cache by marking it as a local copy to be deleted. The deleteEntry method does not generate any temporary ID, as the entry is already associated with the ID generated by the back end.
```
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
            cache. initializeCache();
	  cache.deleteEntry(EntryID);

   }
catch(CacheException e){
	Log.e("",e.getMessage();
}
```
Co-relating Requests with Local Cache Entries – Each of the operations like add, update, and delete local cache entries are associated with entry IDs that are unique. These operations are also associated with requests. For example: Add corresponds to a POST request. To co-relate which request corresponds to which cached entry, there is a provision provided in the Request object interface to tag each of these requests with their respective entry IDs.
In case of request to a single endpoint, each request is associated with single cache entry ID.
Clearing Specific Data from the Local Cache – To clear locally created entries when all the cache instances are updated with the server version of the entry on which modifications were made, use the clearLocalEntryForEntryId method.
Note: Since the local cache is specific to the entry ID, the changes made to an entry from one of the cache instances (for example, URL1 + top 10) should be reflected on all cache instances in which the entry is present (for example URL1 + top 20). Do not delete the local entry until you have refreshed all caches that are relevant for this entry.
```
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
cache. initializeCache();
	 cache.clearLocalEntry(<EntryID>);

   }
catch(CacheException e){
	Log.e("",e.getMessage();
```

Store Document in Cache

To cache the service and metadata document (schema) for a particular service URL, use the storeDocument method . You can also define your own enum type and store the data for that enum type. The service document must be stored only after the metadata document is parsed.

//Service document
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
cache. initializeCache();
	 cache.storeDocument(serviceDocumentObject, DocumentType.ServiceDocument, serviceDocUrl);
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

//MetaData Document
try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
	cache.initializeCache();
	cache.storeDocument(serviceDocumentObject, DocumentType.MetaDocument, serviceDocUrl);
}
catch(CacheException e){
	Log.e("",e.getMessage();
}

Read Document from Cache

To read the service and metadata documents from cache, use the readDocumentForUrlKey method. This method returns the stored document in the cache. The application should pass the document type and the URL for which the document is relevant.

try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
     cache.initializeCache();
	 IODataServiceDocument serviceDocumentObject = (IODataServiceDocument )cache.readDocument(DocumentType.ServiceDocument, serviceDocUrl);
	 IODataSchema metadata = (IODataSchema)cache.readDocument(DocumentType.MetaDocument, serviceDocUrl);
   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

Clearing the Cache

Use the clearCache method to clear the cache and persistence of all the entries based on URL key. This method also deletes the delta token of any document stored against this URL. Hence it is recommended that you use this method only when the application does not support delta queries.

try{
	 ILogger logger = new Logger();
	 ICache cache =new Cache(getApplicationContext(),logger);
cache.initializeCache();
	 cache.clearCache(URLKey);

   }
catch(CacheException e){
	Log.e("",e.getMessage();
}

Using Delta Link

The delta link retrieves the delta changes to a particular URL, since the last time URL was called.

Note: You must pass the complete request URL as urlKey. For example, cache().mergeEntries(list, aRequest.getRequestUrl()).

The default option in cache is to get the delta link if OData entry supports delta link. In this case, once mergeEntries API of cache is called to save server entries into cache, the next GET the application fires, will internally be fired for delta link for the OData entry. So only delta changes will be available as the response and the application developer can call mergeEntries to merge the entries in the cache.

The application developer can disable default delta link handling by calling the following API:

requestObject.disableDeltaHandling(true);