/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.cooliris.media;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import com.cooliris.cache.CacheService;
import android.util.Log;
public final class DiskCache {
private static final String TAG = "DiskCache";
private static final int CHUNK_SIZE = 1048576; // 1MB.
private static final int INDEX_HEADER_MAGIC = 0xcafe;
private static final int INDEX_HEADER_VERSION = 2;
private static final String INDEX_FILE_NAME = "index";
private static final String CHUNK_FILE_PREFIX = "chunk_";
private final String mCacheDirectoryPath;
private LongSparseArray<Record> mIndexMap;
private final LongSparseArray<RandomAccessFile> mChunkFiles = new LongSparseArray<RandomAccessFile>();
private int mTailChunk = 0;
private int mNumInsertions = 0;
public DiskCache(String cacheDirectoryName) {
String cacheDirectoryPath = CacheService.getCachePath(cacheDirectoryName);
// Create the cache directory if needed.
File cacheDirectory = new File(cacheDirectoryPath);
if (!cacheDirectory.isDirectory() && !cacheDirectory.mkdirs()) {
Log.e(TAG, "Unable to create cache directory " + cacheDirectoryPath);
}
mCacheDirectoryPath = cacheDirectoryPath;
loadIndex();
}
@Override
public void finalize() {
shutdown();
}
public byte[] get(long key, long timestamp) {
// Look up the record for the given key.
Record record = null;
synchronized (mIndexMap) {
record = mIndexMap.get(key);
}
if (record != null) {
// Read the chunk from the file.
if (record.timestamp < timestamp) {
Log.i(TAG, "File has been updated to " + timestamp + " since the last time " + record.timestamp
+ " stored in cache.");
return null;
}
try {
RandomAccessFile chunkFile = getChunkFile(record.chunk);
if (chunkFile != null) {
byte[] data = new byte[record.size];
chunkFile.seek(record.offset);
chunkFile.readFully(data);
return data;
}
} catch (Exception e) {
Log.e(TAG, "Unable to read from chunk file");
}
}
return null;
}
public boolean isDataAvailable(long key, long timestamp) {
Record record = null;
synchronized (mIndexMap) {
record = mIndexMap.get(key);
}
if (record == null) {
return false;
}
if (record.timestamp < timestamp) {
return false;
}
if (record.size == 0)
return false;
return true;
}
public void put(long key, byte[] data, long timestamp) {
// Check to see if the record already exists.
Record record = null;
synchronized (mIndexMap) {
record = mIndexMap.get(key);
}
if (record != null && data.length <= record.sizeOnDisk) {
// We just replace the chunk.
int currentChunk = record.chunk;
try {
RandomAccessFile chunkFile = getChunkFile(record.chunk);
if (chunkFile != null) {
chunkFile.seek(record.offset);
chunkFile.write(data);
synchronized (mIndexMap) {
mIndexMap.put(key, new Record(currentChunk, record.offset, data.length, record.sizeOnDisk, timestamp));
}
if (++mNumInsertions == 32) { // CR: 32 => constant
// Flush the index file at a regular interval. To avoid
// writing the entire
// index each time the format could be changed to an
// append-only journal with
// a snapshot generated on exit.
flush();
}
return;
}
} catch (Exception e) {
Log.e(TAG, "Unable to read from chunk file");
}
}
// Append a new chunk to the current chunk.
final int chunk = mTailChunk;
final RandomAccessFile chunkFile = getChunkFile(chunk);
if (chunkFile != null) {
try {
final int offset = (int) chunkFile.length();
chunkFile.seek(offset);
chunkFile.write(data);
synchronized (mIndexMap) {
mIndexMap.put(key, new Record(chunk, offset, data.length, data.length, timestamp));
}
if (offset + data.length > CHUNK_SIZE) {
++mTailChunk;
}
if (++mNumInsertions == 32) { // CR: 32 => constant
// Flush the index file at a regular interval. To avoid
// writing the entire
// index each time the format could be changed to an
// append-only journal with
// a snapshot generated on exit.
flush();
}
} catch (IOException e) {
Log.e(TAG, "Unable to write new entry to chunk file");
}
} else {
Log.e(TAG, "getChunkFile() returned null");
}
}
public void delete(long key) {
synchronized (mIndexMap) {
mIndexMap.remove(key);
}
}
public void deleteAll() {
// Close all open files and clear data structures.
shutdown();
// Delete all cache files.
File cacheDirectory = new File(mCacheDirectoryPath);
String[] cacheFiles = cacheDirectory.list();
if (cacheFiles == null)
return;
for (String cacheFile : cacheFiles) {
new File(cacheDirectory, cacheFile).delete();
}
}
public void flush() {
if (mNumInsertions != 0) {
mNumInsertions = 0;
writeIndex();
}
}
public void close() {
writeIndex();
shutdown();
}
private void shutdown() {
synchronized (mChunkFiles) {
for (int i = 0, size = mChunkFiles.size(); i < size; ++i) {
try {
mChunkFiles.valueAt(i).close();
} catch (Exception e) {
Log.e(TAG, "Unable to close chunk file");
}
}
mChunkFiles.clear();
}
if (mIndexMap != null) {
synchronized (mIndexMap) {
if (mIndexMap != null) {
mIndexMap.clear();
}
}
}
}
private String getIndexFilePath() {
return mCacheDirectoryPath + INDEX_FILE_NAME;
}
private void loadIndex() {
final String indexFilePath = getIndexFilePath();
try {
// Open the input stream.
final FileInputStream fileInput = new FileInputStream(indexFilePath);
final BufferedInputStream bufferedInput = new BufferedInputStream(fileInput, 1024);
final DataInputStream dataInput = new DataInputStream(bufferedInput);
// Read the header.
final int magic = dataInput.readInt();
final int version = dataInput.readInt();
boolean valid = true;
if (magic != INDEX_HEADER_MAGIC) {
Log.e(TAG, "Index file appears to be corrupt (" + magic + " != " + INDEX_HEADER_MAGIC + "), " + indexFilePath);
valid = false;
}
if (valid && version != INDEX_HEADER_VERSION) {
// Future versions can implement upgrade in this case.
Log.e(TAG, "Index file version " + version + " not supported");
valid = false;
}
if (valid) {
mTailChunk = dataInput.readShort();
}
// Read the entries.
if (valid) {
// Parse the index file body into the in-memory map.
final int numEntries = dataInput.readInt();
mIndexMap = new LongSparseArray<Record>(numEntries);
synchronized (mIndexMap) {
for (int i = 0; i < numEntries; ++i) {
final long key = dataInput.readLong();
final int chunk = dataInput.readShort();
final int offset = dataInput.readInt();
final int size = dataInput.readInt();
final int sizeOnDisk = dataInput.readInt();
final long timestamp = dataInput.readLong();
mIndexMap.append(key, new Record(chunk, offset, size, sizeOnDisk, timestamp));
}
}
}
dataInput.close();
if (!valid) {
deleteAll();
}
} catch (FileNotFoundException e) {
// If the file does not exist the cache is empty, so just continue.
} catch (IOException e) {
Log.e(TAG, "Unable to read the index file " + indexFilePath);
} finally {
if (mIndexMap == null) {
mIndexMap = new LongSparseArray<Record>();
}
}
}
private void writeIndex() {
File tempFile = null;
final String tempFilePath = mCacheDirectoryPath;
final String indexFilePath = getIndexFilePath();
try {
tempFile = File.createTempFile("DiskCache", null, new File(tempFilePath));
} catch (Exception e) {
Log.e(TAG, "Unable to create or tempFile " + tempFilePath);
return;
}
try {
final FileOutputStream fileOutput = new FileOutputStream(tempFile);
final BufferedOutputStream bufferedOutput = new BufferedOutputStream(fileOutput, 1024);
final DataOutputStream dataOutput = new DataOutputStream(bufferedOutput);
// Write the index header.
final int numRecords = mIndexMap.size();
dataOutput.writeInt(INDEX_HEADER_MAGIC);
dataOutput.writeInt(INDEX_HEADER_VERSION);
dataOutput.writeShort(mTailChunk);
dataOutput.writeInt(numRecords);
// Write the records.
for (int i = 0; i < numRecords; ++i) {
final long key = mIndexMap.keyAt(i);
final Record record = mIndexMap.valueAt(i);
dataOutput.writeLong(key);
dataOutput.writeShort(record.chunk);
dataOutput.writeInt(record.offset);
dataOutput.writeInt(record.size);
dataOutput.writeInt(record.sizeOnDisk);
dataOutput.writeLong(record.timestamp);
}
// Close the file.
dataOutput.close();
// Log.d(TAG, "Wrote index with " + numRecords + " records.");
// Atomically overwrite the old index file.
tempFile.renameTo(new File(indexFilePath));
} catch (Exception e) {
// Was unable to perform the operation, we delete the temp file
Log.e(TAG, "Unable to write the index file " + indexFilePath);
tempFile.delete();
}
}
private RandomAccessFile getChunkFile(int chunk) {
RandomAccessFile chunkFile = null;
synchronized (mChunkFiles) {
chunkFile = mChunkFiles.get(chunk);
}
if (chunkFile == null) {
final String chunkFilePath = mCacheDirectoryPath + CHUNK_FILE_PREFIX + chunk;
try {
chunkFile = new RandomAccessFile(chunkFilePath, "rw");
} catch (FileNotFoundException e) {
Log.e(TAG, "Unable to create or open the chunk file " + chunkFilePath);
}
synchronized (mChunkFiles) {
mChunkFiles.put(chunk, chunkFile);
}
}
return chunkFile;
}
private static final class Record {
public Record(int chunk, int offset, int size, int sizeOnDisk, long timestamp) {
this.chunk = chunk;
this.offset = offset;
this.size = size;
this.timestamp = timestamp;
this.sizeOnDisk = sizeOnDisk;
}
public final long timestamp;
public final int chunk;
public final int offset;
public final int size;
public final int sizeOnDisk;
}
}