/*
* Copyright (C) 2008 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.android.calendar;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.os.Handler;
import android.os.Process;
import android.provider.Calendar.BusyBits;
import android.util.Log;
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
public class EventLoader {
private Context mContext;
private Handler mHandler = new Handler();
private AtomicInteger mSequenceNumber = new AtomicInteger();
private LinkedBlockingQueue<LoadRequest> mLoaderQueue;
private LoaderThread mLoaderThread;
private ContentResolver mResolver;
private static interface LoadRequest {
public void processRequest(EventLoader eventLoader);
public void skipRequest(EventLoader eventLoader);
}
private static class ShutdownRequest implements LoadRequest {
public void processRequest(EventLoader eventLoader) {
}
public void skipRequest(EventLoader eventLoader) {
}
}
private static class LoadBusyBitsRequest implements LoadRequest {
public int startDay;
public int numDays;
public int[] busybits;
public int[] allDayCounts;
public Runnable uiCallback;
public LoadBusyBitsRequest(int startDay, int numDays, int[] busybits, int[] allDayCounts,
final Runnable uiCallback) {
this.startDay = startDay;
this.numDays = numDays;
this.busybits = busybits;
this.allDayCounts = allDayCounts;
this.uiCallback = uiCallback;
}
public void processRequest(EventLoader eventLoader) {
final Handler handler = eventLoader.mHandler;
ContentResolver cr = eventLoader.mResolver;
// Clear the busy bits and all-day counts
for (int dayIndex = 0; dayIndex < numDays; dayIndex++) {
busybits[dayIndex] = 0;
allDayCounts[dayIndex] = 0;
}
Cursor cursor = BusyBits.query(cr, startDay, numDays);
try {
int dayColumnIndex = cursor.getColumnIndexOrThrow(BusyBits.DAY);
int busybitColumnIndex = cursor.getColumnIndexOrThrow(BusyBits.BUSYBITS);
int allDayCountColumnIndex = cursor.getColumnIndexOrThrow(BusyBits.ALL_DAY_COUNT);
while (cursor.moveToNext()) {
int day = cursor.getInt(dayColumnIndex);
int dayIndex = day - startDay;
busybits[dayIndex] = cursor.getInt(busybitColumnIndex);
allDayCounts[dayIndex] = cursor.getInt(allDayCountColumnIndex);
}
} finally {
if (cursor != null) {
cursor.close();
}
}
handler.post(uiCallback);
}
public void skipRequest(EventLoader eventLoader) {
}
}
private static class LoadEventsRequest implements LoadRequest {
public int id;
public long startMillis;
public int numDays;
public ArrayList<Event> events;
public Runnable successCallback;
public Runnable cancelCallback;
public LoadEventsRequest(int id, long startMillis, int numDays, ArrayList<Event> events,
final Runnable successCallback, final Runnable cancelCallback) {
this.id = id;
this.startMillis = startMillis;
this.numDays = numDays;
this.events = events;
this.successCallback = successCallback;
this.cancelCallback = cancelCallback;
}
public void processRequest(EventLoader eventLoader) {
Event.loadEvents(eventLoader.mContext, events, startMillis,
numDays, id, eventLoader.mSequenceNumber);
// Check if we are still the most recent request.
if (id == eventLoader.mSequenceNumber.get()) {
eventLoader.mHandler.post(successCallback);
} else {
eventLoader.mHandler.post(cancelCallback);
}
}
public void skipRequest(EventLoader eventLoader) {
eventLoader.mHandler.post(cancelCallback);
}
}
private static class LoaderThread extends Thread {
LinkedBlockingQueue<LoadRequest> mQueue;
EventLoader mEventLoader;
public LoaderThread(LinkedBlockingQueue<LoadRequest> queue, EventLoader eventLoader) {
mQueue = queue;
mEventLoader = eventLoader;
}
public void shutdown() {
try {
mQueue.put(new ShutdownRequest());
} catch (InterruptedException ex) {
// The put() method fails with InterruptedException if the
// queue is full. This should never happen because the queue
// has no limit.
Log.e("Cal", "LoaderThread.shutdown() interrupted!");
}
}
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
while (true) {
try {
// Wait for the next request
LoadRequest request = mQueue.take();
// If there are a bunch of requests already waiting, then
// skip all but the most recent request.
while (!mQueue.isEmpty()) {
// Let the request know that it was skipped
request.skipRequest(mEventLoader);
// Skip to the next request
request = mQueue.take();
}
if (request instanceof ShutdownRequest) {
return;
}
request.processRequest(mEventLoader);
} catch (InterruptedException ex) {
Log.e("Cal", "background LoaderThread interrupted!");
}
}
}
}
public EventLoader(Context context) {
mContext = context;
mLoaderQueue = new LinkedBlockingQueue<LoadRequest>();
mResolver = context.getContentResolver();
}
/**
* Call this from the activity's onResume()
*/
public void startBackgroundThread() {
mLoaderThread = new LoaderThread(mLoaderQueue, this);
mLoaderThread.start();
}
/**
* Call this from the activity's onPause()
*/
public void stopBackgroundThread() {
mLoaderThread.shutdown();
}
/**
* Loads "numDays" days worth of events, starting at start, into events.
* Posts uiCallback to the {@link Handler} for this view, which will run in the UI thread.
* Reuses an existing background thread, if events were already being loaded in the background.
* NOTE: events and uiCallback are not used if an existing background thread gets reused --
* the ones that were passed in on the call that results in the background thread getting
* created are used, and the most recent call's worth of data is loaded into events and posted
* via the uiCallback.
*/
void loadEventsInBackground(final int numDays, final ArrayList<Event> events,
long start, final Runnable successCallback, final Runnable cancelCallback) {
// Increment the sequence number for requests. We don't care if the
// sequence numbers wrap around because we test for equality with the
// latest one.
int id = mSequenceNumber.incrementAndGet();
// Send the load request to the background thread
LoadEventsRequest request = new LoadEventsRequest(id, start, numDays,
events, successCallback, cancelCallback);
try {
mLoaderQueue.put(request);
} catch (InterruptedException ex) {
// The put() method fails with InterruptedException if the
// queue is full. This should never happen because the queue
// has no limit.
Log.e("Cal", "loadEventsInBackground() interrupted!");
}
}
void loadBusyBitsInBackground(int startDay, int numDays, int[] busybits, int[] allDayCounts,
final Runnable uiCallback) {
// Send the load request to the background thread
LoadBusyBitsRequest request = new LoadBusyBitsRequest(startDay, numDays, busybits,
allDayCounts, uiCallback);
try {
mLoaderQueue.put(request);
} catch (InterruptedException ex) {
// The put() method fails with InterruptedException if the
// queue is full. This should never happen because the queue
// has no limit.
Log.e("Cal", "loadBusyBitsInBackground() interrupted!");
}
}
}
|
