X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/89b37b750836b661e33875cad8ac00c3027e958c..e610046e0d91445cec74a875e5a55df14a93edcf:/src/com/owncloud/android/files/services/FileObserverService.java diff --git a/src/com/owncloud/android/files/services/FileObserverService.java b/src/com/owncloud/android/files/services/FileObserverService.java index 7aa3fa9a..a602f8cf 100644 --- a/src/com/owncloud/android/files/services/FileObserverService.java +++ b/src/com/owncloud/android/files/services/FileObserverService.java @@ -20,107 +20,152 @@ package com.owncloud.android.files.services; import java.io.File; import java.util.HashMap; +import java.util.Iterator; import java.util.Map; -import com.owncloud.android.Log_OC; -import com.owncloud.android.datamodel.FileDataStorageManager; -import com.owncloud.android.datamodel.OCFile; -import com.owncloud.android.db.ProviderMeta.ProviderTableMeta; -import com.owncloud.android.files.OwnCloudFileObserver; -import com.owncloud.android.operations.SynchronizeFileOperation; -import com.owncloud.android.utils.FileStorageUtils; - - import android.accounts.Account; -import android.accounts.AccountManager; import android.app.Service; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.database.Cursor; -import android.os.Binder; +import android.os.FileObserver; import android.os.IBinder; +import com.owncloud.android.MainApp; +import com.owncloud.android.authentication.AccountUtils; +import com.owncloud.android.datamodel.OCFile; +import com.owncloud.android.db.ProviderMeta.ProviderTableMeta; +import com.owncloud.android.files.OwnCloudFolderObserver; +import com.owncloud.android.operations.SynchronizeFileOperation; +import com.owncloud.android.utils.FileStorageUtils; +import com.owncloud.android.utils.Log_OC; + + +/** + * Service keeping a list of {@link FileObserver} instances that watch for local + * changes in favorite files (formerly known as kept-in-sync files) and try to + * synchronize them with the OC server as soon as possible. + * + * Tries to be alive as long as possible; that is the reason why stopSelf() is + * never called. + * + * It is expected that the system eventually kills the service when runs low of + * memory. To minimize the impact of this, the service always returns + * Service.START_STICKY, and the later restart of the service is explicitly + * considered in {@link FileObserverService#onStartCommand(Intent, int, int)}. + * + * @author David A. Velasco + */ public class FileObserverService extends Service { - public final static int CMD_INIT_OBSERVED_LIST = 1; - public final static int CMD_ADD_OBSERVED_FILE = 2; - public final static int CMD_DEL_OBSERVED_FILE = 3; + public final static String MY_NAME = FileObserverService.class.getCanonicalName(); + public final static String ACTION_START_OBSERVE = MY_NAME + ".action.START_OBSERVATION"; + public final static String ACTION_ADD_OBSERVED_FILE = MY_NAME + ".action.ADD_OBSERVED_FILE"; + public final static String ACTION_DEL_OBSERVED_FILE = MY_NAME + ".action.DEL_OBSERVED_FILE"; - public final static String KEY_FILE_CMD = "KEY_FILE_CMD"; - public final static String KEY_CMD_ARG_FILE = "KEY_CMD_ARG_FILE"; - public final static String KEY_CMD_ARG_ACCOUNT = "KEY_CMD_ARG_ACCOUNT"; + private final static String ARG_FILE = "ARG_FILE"; + private final static String ARG_ACCOUNT = "ARG_ACCOUNT"; private static String TAG = FileObserverService.class.getSimpleName(); - private static Map mObserversMap; - private static DownloadCompletedReceiverBis mDownloadReceiver; - private IBinder mBinder = new LocalBinder(); - - public class LocalBinder extends Binder { - FileObserverService getService() { - return FileObserverService.this; - } + private Map mFolderObserversMap; + private DownloadCompletedReceiver mDownloadReceiver; + + /** + * Factory method to create intents that allow to start an + * ACTION_START_OBSERVE command. + * + * @param context Android context of the caller component. + * @return Intent that starts a command ACTION_START_OBSERVE when + * {@link Context#startService(Intent)} is called. + */ + public static Intent makeInitIntent(Context context) { + Intent i = new Intent(context, FileObserverService.class); + i.setAction(ACTION_START_OBSERVE); + return i; } - + + /** + * Factory method to create intents that allow to start or stop the + * observance of a file. + * + * @param context Android context of the caller component. + * @param file OCFile to start or stop to watch. + * @param account OC account containing file. + * @param watchIt 'True' creates an intent to watch, 'false' an intent to + * stop watching. + * @return Intent to start or stop the observance of a file through a call + * to {@link Context#startService(Intent)}. + */ + public static Intent makeObservedFileIntent( + Context context, OCFile file, Account account, boolean watchIt) { + Intent intent = new Intent(context, FileObserverService.class); + intent.setAction(watchIt ? FileObserverService.ACTION_ADD_OBSERVED_FILE + : FileObserverService.ACTION_DEL_OBSERVED_FILE); + intent.putExtra(FileObserverService.ARG_FILE, file); + intent.putExtra(FileObserverService.ARG_ACCOUNT, account); + return intent; + } + @Override public void onCreate() { + Log_OC.d(TAG, "onCreate"); super.onCreate(); - mDownloadReceiver = new DownloadCompletedReceiverBis(); - + + mDownloadReceiver = new DownloadCompletedReceiver(); IntentFilter filter = new IntentFilter(); filter.addAction(FileDownloader.getDownloadAddedMessage()); - filter.addAction(FileDownloader.getDownloadFinishMessage()); + filter.addAction(FileDownloader.getDownloadFinishMessage()); registerReceiver(mDownloadReceiver, filter); - - mObserversMap = new HashMap(); - //initializeObservedList(); + + mFolderObserversMap = new HashMap(); } - - + @Override public void onDestroy() { - super.onDestroy(); + Log_OC.d(TAG, "onDestroy - finishing observation of favourite files"); + unregisterReceiver(mDownloadReceiver); - mObserversMap = null; // TODO study carefully the life cycle of Services to grant the best possible observance - Log_OC.d(TAG, "Bye, bye"); + + Iterator itOCFolder = mFolderObserversMap.values().iterator(); + while (itOCFolder.hasNext()) { + itOCFolder.next().stopWatching(); + } + mFolderObserversMap.clear(); + mFolderObserversMap = null; + + super.onDestroy(); } - - + @Override public IBinder onBind(Intent intent) { - return mBinder; + // this service cannot be bound + return null; } @Override public int onStartCommand(Intent intent, int flags, int startId) { - // this occurs when system tries to restart - // service, so we need to reinitialize observers - if (intent == null) { - initializeObservedList(); - return Service.START_STICKY; - } - - if (!intent.hasExtra(KEY_FILE_CMD)) { - Log_OC.e(TAG, "No KEY_FILE_CMD argument given"); + Log_OC.d(TAG, "Starting command " + intent); + + if (intent == null || ACTION_START_OBSERVE.equals(intent.getAction())) { + // NULL occurs when system tries to restart the service after its + // process was killed + startObservation(); return Service.START_STICKY; - } - switch (intent.getIntExtra(KEY_FILE_CMD, -1)) { - case CMD_INIT_OBSERVED_LIST: - initializeObservedList(); - break; - case CMD_ADD_OBSERVED_FILE: - addObservedFile( (OCFile)intent.getParcelableExtra(KEY_CMD_ARG_FILE), - (Account)intent.getParcelableExtra(KEY_CMD_ARG_ACCOUNT)); - break; - case CMD_DEL_OBSERVED_FILE: - removeObservedFile( (OCFile)intent.getParcelableExtra(KEY_CMD_ARG_FILE), - (Account)intent.getParcelableExtra(KEY_CMD_ARG_ACCOUNT)); - break; - default: - Log_OC.wtf(TAG, "Incorrect key given"); + } else if (ACTION_ADD_OBSERVED_FILE.equals(intent.getAction())) { + OCFile file = (OCFile) intent.getParcelableExtra(ARG_FILE); + Account account = (Account) intent.getParcelableExtra(ARG_ACCOUNT); + addObservedFile(file, account); + + } else if (ACTION_DEL_OBSERVED_FILE.equals(intent.getAction())) { + removeObservedFile((OCFile) intent.getParcelableExtra(ARG_FILE), + (Account) intent.getParcelableExtra(ARG_ACCOUNT)); + + } else { + Log_OC.e(TAG, "Unknown action recieved; ignoring it: " + intent.getAction()); } return Service.START_STICKY; @@ -128,151 +173,196 @@ public class FileObserverService extends Service { /** - * Read from the local database the list of files that must to be kept synchronized and - * starts file observers to monitor local changes on them + * Read from the local database the list of files that must to be kept + * synchronized and starts observers to monitor local changes on them */ - private void initializeObservedList() { - mObserversMap.clear(); - Cursor c = getContentResolver().query( - ProviderTableMeta.CONTENT_URI, + private void startObservation() { + Log_OC.d(TAG, "Loading all kept-in-sync files from database to start watching them"); + + // query for any favorite file in any OC account + Cursor cursorOnKeptInSync = getContentResolver().query( + ProviderTableMeta.CONTENT_URI, null, - ProviderTableMeta.FILE_KEEP_IN_SYNC + " = ?", - new String[] {String.valueOf(1)}, - null); - if (c == null || !c.moveToFirst()) return; - AccountManager acm = AccountManager.get(this); - Account[] accounts = acm.getAccounts(); - do { - Account account = null; - for (Account a : accounts) - if (a.name.equals(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_ACCOUNT_OWNER)))) { - account = a; - break; - } + ProviderTableMeta.FILE_KEEP_IN_SYNC + " = ?", + new String[] { String.valueOf(1) }, + null + ); + + if (cursorOnKeptInSync != null) { + + if (cursorOnKeptInSync.moveToFirst()) { + + String localPath = ""; + // String remotePath = ""; + String accountName = ""; + Account account = null; + do { + localPath = cursorOnKeptInSync.getString(cursorOnKeptInSync + .getColumnIndex(ProviderTableMeta.FILE_STORAGE_PATH)); + accountName = cursorOnKeptInSync.getString(cursorOnKeptInSync + .getColumnIndex(ProviderTableMeta.FILE_ACCOUNT_OWNER)); + /* + * remotePath = cursorOnKeptInSync.getString( + * cursorOnKeptInSync + * .getColumnIndex(ProviderTableMeta.FILE_PATH) ); + */ + + account = new Account(accountName, MainApp.getAccountType()); + if (!AccountUtils.exists(account, this) || localPath == null || localPath.length() <= 0) { + continue; + } + + addObservedFile(localPath, account); + + } while (cursorOnKeptInSync.moveToNext()); - if (account == null) continue; - FileDataStorageManager storage = - new FileDataStorageManager(account, getContentResolver()); - if (!storage.fileExists(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PATH)))) - continue; - - String path = c.getString(c.getColumnIndex(ProviderTableMeta.FILE_STORAGE_PATH)); - if (path == null || path.length() <= 0) - continue; - OwnCloudFileObserver observer = - new OwnCloudFileObserver( path, - account, - getApplicationContext(), - OwnCloudFileObserver.CHANGES_ONLY); - mObserversMap.put(path, observer); - if (new File(path).exists()) { - observer.startWatching(); - Log_OC.d(TAG, "Started watching file " + path); } - - } while (c.moveToNext()); - c.close(); + cursorOnKeptInSync.close(); + } + + // service does not stopSelf() ; that way it tries to be alive forever + } - + /** - * Registers the local copy of a remote file to be observed for local changes, - * an automatically updated in the ownCloud server. + * Registers the local copy of a remote file to be observed for local + * changes, an automatically updated in the ownCloud server. * - * This method does NOT perform a {@link SynchronizeFileOperation} over the file. - * - * TODO We are ignoring that, currently, a local file can be linked to different files - * in ownCloud if it's uploaded several times. That's something pending to update: we - * will avoid that the same local file is linked to different remote files. + * This method does NOT perform a {@link SynchronizeFileOperation} over the + * file. * - * @param file Object representing a remote file which local copy must be observed. - * @param account OwnCloud account containing file. + * @param file Object representing a remote file which local copy must be + * observed. + * @param account OwnCloud account containing file. */ private void addObservedFile(OCFile file, Account account) { + Log_OC.v(TAG, "Adding a file to be watched"); + if (file == null) { Log_OC.e(TAG, "Trying to add a NULL file to observer"); return; } + if (account == null) { + Log_OC.e(TAG, "Trying to add a file with a NULL account to observer"); + return; + } + String localPath = file.getStoragePath(); - if (localPath == null || localPath.length() <= 0) { // file downloading / to be download for the first time + if (localPath == null || localPath.length() <= 0) { + // file downloading or to be downloaded for the first time localPath = FileStorageUtils.getDefaultSavePathFor(account.name, file); } - OwnCloudFileObserver observer = mObserversMap.get(localPath); - if (observer == null) { - /// the local file was never registered to observe before - observer = new OwnCloudFileObserver( localPath, - account, - getApplicationContext(), - OwnCloudFileObserver.CHANGES_ONLY); - mObserversMap.put(localPath, observer); - Log_OC.d(TAG, "Observer added for path " + localPath); - if (file.isDown()) { - observer.startWatching(); - Log_OC.d(TAG, "Started watching " + localPath); - } // else - the observance can't be started on a file not already down; mDownloadReceiver will get noticed when the download of the file finishes + addObservedFile(localPath, account); + + } + + + + + /** + * Registers the folder to be observed in which there are changes inside any + * file + * + * @param account OwnCloud account containing file. + */ + private void addObservedFile(String localPath, Account account) { + File file = new File(localPath); + String parentPath = file.getParent(); + OwnCloudFolderObserver observer = mFolderObserversMap.get(parentPath); + if (observer == null) { + observer = new OwnCloudFolderObserver(parentPath, account, getApplicationContext()); + mFolderObserversMap.put(parentPath, observer); + Log_OC.d(TAG, "Observer added for parent folder " + parentPath + "/"); } + observer.startWatching(file.getName()); + Log_OC.d(TAG, "Added " + localPath + " to list of observed children"); } /** - * Unregisters the local copy of a remote file to be observed for local changes. - * + * Unregisters the local copy of a remote file to be observed for local + * changes. + * * Starts to watch it, if the file has a local copy to watch. * - * TODO We are ignoring that, currently, a local file can be linked to different files - * in ownCloud if it's uploaded several times. That's something pending to update: we - * will avoid that the same local file is linked to different remote files. - * - * @param file Object representing a remote file which local copy must be not observed longer. - * @param account OwnCloud account containing file. + * @param file Object representing a remote file which local copy must be + * not observed longer. + * @param account OwnCloud account containing file. */ private void removeObservedFile(OCFile file, Account account) { + Log_OC.v(TAG, "Removing a file from being watched"); + if (file == null) { Log_OC.e(TAG, "Trying to remove a NULL file"); return; } + if (account == null) { + Log_OC.e(TAG, "Trying to add a file with a NULL account to observer"); + return; + } + String localPath = file.getStoragePath(); if (localPath == null || localPath.length() <= 0) { localPath = FileStorageUtils.getDefaultSavePathFor(account.name, file); } - - OwnCloudFileObserver observer = mObserversMap.get(localPath); + + removeObservedFile(localPath); + } + + + private void removeObservedFile(String localPath) { + File file = new File(localPath); + String parentPath = file.getParent(); + OwnCloudFolderObserver observer = mFolderObserversMap.get(parentPath); if (observer != null) { - observer.stopWatching(); - mObserversMap.remove(observer); - Log_OC.d(TAG, "Stopped watching " + localPath); - } + observer.stopWatching(file.getName()); + if (observer.isEmpty()) { + mFolderObserversMap.remove(parentPath); + Log_OC.d(TAG, "Observer removed for parent folder " + parentPath + "/"); + } + } else { + Log_OC.d(TAG, "No observer to remove for path " + localPath); + } } - + /** - * Private receiver listening to events broadcast by the FileDownloader service. + * Private receiver listening to events broadcasted by the FileDownloader service. * - * Starts and stops the observance on registered files when they are being download, - * in order to avoid to start unnecessary synchronizations. + * Pauses and resumes the observance on registered files while being download, + * in order to avoid to unnecessary synchronizations. */ - private class DownloadCompletedReceiverBis extends BroadcastReceiver { - + private class DownloadCompletedReceiver extends BroadcastReceiver { + @Override public void onReceive(Context context, Intent intent) { - String downloadPath = intent.getStringExtra(FileDownloader.EXTRA_FILE_PATH); - OwnCloudFileObserver observer = mObserversMap.get(downloadPath); + Log_OC.d(TAG, "Received broadcast intent " + intent); + + File downloadedFile = new File(intent.getStringExtra(FileDownloader.EXTRA_FILE_PATH)); + String parentPath = downloadedFile.getParent(); + OwnCloudFolderObserver observer = mFolderObserversMap.get(parentPath); if (observer != null) { - if (intent.getAction().equals(FileDownloader.getDownloadFinishMessage()) && - new File(downloadPath).exists()) { // the download could be successful. not; in both cases, the file could be down, due to a former download or upload - observer.startWatching(); - Log_OC.d(TAG, "Watching again " + downloadPath); - + if (intent.getAction().equals(FileDownloader.getDownloadFinishMessage()) + && downloadedFile.exists()) { + // no matter if the download was be successful or not; the + // file could be down anyway due to a former download or upload + observer.startWatching(downloadedFile.getName()); + Log_OC.d(TAG, "Resuming observance of " + downloadedFile.getAbsolutePath()); + } else if (intent.getAction().equals(FileDownloader.getDownloadAddedMessage())) { - observer.stopWatching(); - Log_OC.d(TAG, "Disabling observance of " + downloadPath); - } + observer.stopWatching(downloadedFile.getName()); + Log_OC.d(TAG, "Pausing observance of " + downloadedFile.getAbsolutePath()); + } + + } else { + Log_OC.d(TAG, "No observer for path " + downloadedFile.getAbsolutePath()); } } - + } - + }