Java tutorial
/* Viewer for Khan Academy Copyright (C) 2012 Concentric Sky, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ package com.concentricsky.android.khanacademy.data; import static com.concentricsky.android.khanacademy.Constants.ACTION_LIBRARY_UPDATE; import static com.concentricsky.android.khanacademy.Constants.ACTION_UPDATE_DOWNLOAD_STATUS; import static com.concentricsky.android.khanacademy.Constants.EXTRA_FORCE; import static com.concentricsky.android.khanacademy.Constants.EXTRA_ID; import static com.concentricsky.android.khanacademy.Constants.RESULT_CODE_FAILURE; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.sql.SQLException; import java.util.concurrent.Executor; import java.util.concurrent.Executors; import org.json.JSONException; import org.json.JSONObject; import android.app.DownloadManager; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.app.PendingIntent.CanceledException; import android.app.Service; import android.content.Context; import android.content.Intent; import android.database.Cursor; import android.os.AsyncTask; import android.os.Binder; import android.os.IBinder; import android.support.v4.app.NotificationCompat; import android.support.v4.content.LocalBroadcastManager; import com.concentricsky.android.khan.R; import com.concentricsky.android.khanacademy.Constants; import com.concentricsky.android.khanacademy.data.db.DatabaseHelper; import com.concentricsky.android.khanacademy.data.db.Topic; import com.concentricsky.android.khanacademy.data.db.Video; import com.concentricsky.android.khanacademy.data.remote.KAAPIAdapter; import com.concentricsky.android.khanacademy.data.remote.LibraryUpdaterTask; import com.concentricsky.android.khanacademy.util.CaptionManager; import com.concentricsky.android.khanacademy.util.Log; import com.concentricsky.android.khanacademy.util.ObjectCallback; import com.concentricsky.android.khanacademy.util.OfflineVideoManager; import com.concentricsky.android.khanacademy.util.ThumbnailManager; import com.j256.ormlite.android.apptools.OpenHelperManager; import com.j256.ormlite.dao.Dao; import com.j256.ormlite.stmt.PreparedQuery; import com.j256.ormlite.stmt.UpdateBuilder; /** * Manages all data for the application. * * This service holds a reference to a database Helper, the Khan Academy API adapter, * and a local storage adapter for downloaded videos. It also sets a default HTTP * response cache. * * We implement both onStartCommand and onBind. Activities should bind to this service * with bindService to use it as a persistent data backend. Meanwhile, we can call * startService to start long-running operations like video downloads and library * updates. * * @author austinlally * */ public class KADataService extends Service { public final String LOG_TAG = getClass().getSimpleName(); public static final int RESULT_SUCCESS = 0; public static final int RESULT_ERROR = 1; public static final int RESULT_CANCELLED = 2; private KADataBinder mBinder = new KADataBinder(this); private DatabaseHelper helper; private KAAPIAdapter api; private CaptionManager captionManager; private OfflineVideoManager offlineVideoManager; private ThumbnailManager thumbnailManager; private Executor libraryUpdateExecutor = Executors.newSingleThreadExecutor(); private NotificationManager notificationManager; /** * Passed as the IBinder parameter to ServiceConnection.onServiceConnected when a * consumer binds to this service. * * Must be static: * http://code.google.com/p/android/issues/detail?id=6426 */ public static class KADataBinder extends Binder { private KADataService dataService; public KADataBinder(KADataService dataService) { setDataService(dataService); } public KADataService getService() { return dataService; } public void setDataService(KADataService dataService) { this.dataService = dataService; } } /** * Thrown by Provider instances when the service is not (yet) available. */ public static class ServiceUnavailableException extends Exception { private static final long serialVersionUID = 581386365380491650L; public final boolean expected; public ServiceUnavailableException(boolean expected) { super(); this.expected = expected; } } /** * Simplified accessor interface. */ public interface Provider { public KADataService getDataService() throws ServiceUnavailableException; public boolean requestDataService(ObjectCallback<KADataService> callback); public boolean cancelDataServiceRequest(ObjectCallback<KADataService> callback); } @Override public void onCreate() { Log.d(LOG_TAG, "onCreate"); helper = OpenHelperManager.getHelper(this, DatabaseHelper.class); InputStream is = getResources().openRawResource(R.raw.oauth_credentials); byte[] buffer; try { buffer = new byte[is.available()]; while (is.read(buffer) != -1) ; String jsontext = new String(buffer); JSONObject oauthCredentials = new JSONObject(jsontext); String key = oauthCredentials.getString("OAUTH_CONSUMER_KEY"); String secret = oauthCredentials.getString("OAUTH_CONSUMER_SECRET"); api = new KAAPIAdapter(this, key, secret); } catch (IOException e) { e.printStackTrace(); } catch (JSONException e) { e.printStackTrace(); } captionManager = new CaptionManager(this); offlineVideoManager = new OfflineVideoManager(this); thumbnailManager = ThumbnailManager.getSharedInstance(this); notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); setupResponseCache(); } /** * Used for long-running operations including library updates and video downloads. * */ @Override public int onStartCommand(Intent intent, int flags, int startId) { Log.i("KADataService", "Received start id " + startId + ": " + intent); PendingIntent pendingIntent = null; if (intent.hasExtra(Intent.EXTRA_INTENT)) { // TODO : use this intent. It needs to be called with the results of requestLibraryUpdate (so far) pendingIntent = intent.getParcelableExtra(Intent.EXTRA_INTENT); } if (ACTION_LIBRARY_UPDATE.equals(intent.getAction())) { requestLibraryUpdate(startId, pendingIntent, intent.getBooleanExtra(EXTRA_FORCE, false)); return START_REDELIVER_INTENT; } if (ACTION_UPDATE_DOWNLOAD_STATUS.equals(intent.getAction())) { Log.d(LOG_TAG, "update download status"); updateDownloadStatus(intent, pendingIntent, startId); return START_REDELIVER_INTENT; } /* START_NOT_STICKY Do not recreate the service, unless there are pending intents to deliver. This is the safest option to avoid running your service when not necessary and when your application can simply restart any unfinished jobs. START_STICKY Recreate the service and call onStartCommand(), but do not redeliver the last intent. Instead, the system calls onStartCommand() with a null intent, unless there were pending intents to start the service, in which case, those intents are delivered. This is suitable for media players (or similar services) that are not executing commands, but running indefinitely and waiting for a job. START_REDELIVER_INTENT Recreate the service and call onStartCommand() with the last intent that was delivered to the service. Any pending intents are delivered in turn. This is suitable for services that are actively performing a job that should be immediately resumed, such as downloading a file. */ // If we reach this point, the intent has some unknown action, so just ignore it and stop. this.stopSelfResult(startId); return START_NOT_STICKY; } @Override public void onDestroy() { Log.d(LOG_TAG, "onDestroy"); api = null; captionManager = null; offlineVideoManager.destroy(); offlineVideoManager = null; thumbnailManager.destroy(); thumbnailManager = null; OpenHelperManager.releaseHelper(); flushResponseCache(); mBinder.setDataService(null); mBinder = null; notificationManager = null; super.onDestroy(); } /** * Used for maintaining a connection to this service to use it as a data backend. */ @Override public IBinder onBind(Intent intent) { Log.d(LOG_TAG, "onBind"); return mBinder; } @Override public boolean onUnbind(Intent intent) { Log.d(LOG_TAG, "onUnbind"); return super.onUnbind(intent); } /* * Database Access */ public DatabaseHelper getHelper() { return helper; } private void setupResponseCache() { // directly from http://developer.android.com/reference/android/net/http/HttpResponseCache.html try { File httpCacheDir = new File(getCacheDir(), "http"); long httpCacheSize = 10 * 1024 * 1024; // 10 MiB Class.forName("android.net.http.HttpResponseCache").getMethod("install", File.class, long.class) .invoke(null, httpCacheDir, httpCacheSize); } catch (Exception httpResponseCacheNotAvailable) { // TODO : set cache the old way httpResponseCacheNotAvailable.printStackTrace(); } } private void flushResponseCache() { // TODO : check if cache was set the old way, and flush that one. try { Class<?> cls = Class.forName("android.net.http.HttpResponseCache"); Object cache = cls.getMethod("getInstalled").invoke(null); if (cache != null) { cls.getMethod("flush").invoke(cache); } } catch (Exception e) { // Swallow. e.printStackTrace(); } } private void finish(int startId, PendingIntent pendingIntent, int result) { if (pendingIntent != null) { try { pendingIntent.send(result); } catch (CanceledException e) { // Ignore this. If they don't want their result, they don't get it. } } this.stopSelfResult(startId); } private void broadcastLibraryUpdateNotification() { Intent intent = new Intent(); intent.setAction(ACTION_LIBRARY_UPDATE); LocalBroadcastManager.getInstance(this).sendBroadcast(intent); } private void broadcastOfflineVideoSetChanged() { LocalBroadcastManager broadcastManager = LocalBroadcastManager.getInstance(this); Intent intent = new Intent(Constants.ACTION_OFFLINE_VIDEO_SET_CHANGED); broadcastManager.sendBroadcast(intent); } private void showUpdateNotification() { Notification notification = new NotificationCompat.Builder(this).setSmallIcon(R.drawable.icon_72) .setContentTitle("Khan Academy content update") .setContentText("Updating content for Viewer for Khan Academy").setOngoing(true).build(); notificationManager.notify(1, notification); } private void updateDownloadStatus(Intent intent, final PendingIntent pendingIntent, final int startId) { final long id = intent.getLongExtra(EXTRA_ID, -1); final DownloadManager mgr = (DownloadManager) getSystemService(Context.DOWNLOAD_SERVICE); final DownloadManager.Query q = new DownloadManager.Query(); q.setFilterById(id); new AsyncTask<Void, Void, Boolean>() { @Override protected Boolean doInBackground(Void... arg) { Cursor cursor = mgr.query(q); String youtubeId = null; int status = -1; if (cursor.moveToFirst()) { String filename = cursor .getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_FILENAME)); youtubeId = OfflineVideoManager.youtubeIdFromFilename(filename); status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS)); } cursor.close(); if (status == DownloadManager.STATUS_SUCCESSFUL && youtubeId != null) { try { Dao<Video, String> videoDao = helper.getVideoDao(); UpdateBuilder<Video, String> q = videoDao.updateBuilder(); q.where().eq("youtube_id", youtubeId); q.updateColumnValue("download_status", Video.DL_STATUS_COMPLETE); q.update(); return true; } catch (SQLException e) { e.printStackTrace(); } } return false; } @Override protected void onPostExecute(Boolean successful) { if (successful) { broadcastOfflineVideoSetChanged(); finish(startId, pendingIntent, RESULT_SUCCESS); } else { finish(startId, pendingIntent, RESULT_ERROR); } } }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); } private void cancelUpdateNotification() { notificationManager.cancel(1); } private void requestLibraryUpdate(final int startId, final PendingIntent pendingIntent, boolean force) { Log.d(LOG_TAG, "requestLibraryUpdate"); showUpdateNotification(); LibraryUpdaterTask task = new LibraryUpdaterTask(this) { @Override public void onPostExecute(Integer status) { if (status != RESULT_CODE_FAILURE) { try { helper.getDao(Topic.class).clearObjectCache(); helper.getDao(Video.class).clearObjectCache(); } catch (SQLException e) { e.printStackTrace(); } broadcastLibraryUpdateNotification(); } else { Log.w(LOG_TAG, "library update failure code"); } finish(startId, pendingIntent, RESULT_SUCCESS); cancelUpdateNotification(); } }; task.force = force; task.executeOnExecutor(libraryUpdateExecutor); Log.d(LOG_TAG, "Returning from requestLibraryUpdate"); } public KAAPIAdapter getAPIAdapter() { return api; } public CaptionManager getCaptionManager() { return captionManager; } public OfflineVideoManager getOfflineVideoManager() { return offlineVideoManager; } public ThumbnailManager getThumbnailManager() { return thumbnailManager; } /* * Data access */ public Topic getRootTopic() { Topic topic = null; try { Dao<Topic, String> topicDao = helper.getTopicDao(); PreparedQuery<Topic> q = topicDao.queryBuilder().where().isNull("parentTopic_id").prepare(); topic = topicDao.queryForFirst(q); } catch (SQLException e) { e.printStackTrace(); } return topic; } }