X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/c4ac05dee2f2714b1597fbb177c4e8d599e496e1..61f36d2a93063602b13e5ff6dbdeda348e90bc44:/src/com/owncloud/android/ui/activity/FileActivity.java diff --git a/src/com/owncloud/android/ui/activity/FileActivity.java b/src/com/owncloud/android/ui/activity/FileActivity.java index cfada45c..7bb984e1 100644 --- a/src/com/owncloud/android/ui/activity/FileActivity.java +++ b/src/com/owncloud/android/ui/activity/FileActivity.java @@ -24,31 +24,46 @@ import android.accounts.AccountManagerCallback; import android.accounts.AccountManagerFuture; import android.accounts.OperationCanceledException; import android.content.Intent; -import android.net.Uri; import android.os.Bundle; -import android.webkit.MimeTypeMap; +import android.os.Handler; +import android.support.v4.app.Fragment; +import android.support.v4.app.FragmentManager; +import android.support.v4.app.FragmentTransaction; +import android.widget.Toast; import com.actionbarsherlock.app.SherlockFragmentActivity; -import com.owncloud.android.Log_OC; +import com.owncloud.android.MainApp; import com.owncloud.android.R; -import com.owncloud.android.authentication.AccountAuthenticator; import com.owncloud.android.authentication.AccountUtils; +import com.owncloud.android.datamodel.FileDataStorageManager; import com.owncloud.android.datamodel.OCFile; +import com.owncloud.android.files.FileOperationsHelper; +import com.owncloud.android.lib.operations.common.OnRemoteOperationListener; +import com.owncloud.android.lib.operations.common.RemoteOperation; +import com.owncloud.android.lib.operations.common.RemoteOperationResult; +import com.owncloud.android.lib.operations.common.RemoteOperationResult.ResultCode; +import com.owncloud.android.operations.CreateShareOperation; +import com.owncloud.android.operations.UnshareLinkOperation; + +import com.owncloud.android.ui.dialog.LoadingDialog; +import com.owncloud.android.utils.Log_OC; -import eu.alefzero.webdav.WebdavUtils; /** * Activity with common behaviour for activities handling {@link OCFile}s in ownCloud {@link Account}s . * * @author David A. Velasco */ -public abstract class FileActivity extends SherlockFragmentActivity { +public class FileActivity extends SherlockFragmentActivity implements OnRemoteOperationListener { public static final String EXTRA_FILE = "com.owncloud.android.ui.activity.FILE"; public static final String EXTRA_ACCOUNT = "com.owncloud.android.ui.activity.ACCOUNT"; public static final String EXTRA_WAITING_TO_PREVIEW = "com.owncloud.android.ui.activity.WAITING_TO_PREVIEW"; + public static final String EXTRA_FROM_NOTIFICATION= "com.owncloud.android.ui.activity.FROM_NOTIFICATION"; + + public static final String TAG = FileActivity.class.getSimpleName(); - public static final String TAG = FileActivity.class.getSimpleName(); + private static final String DIALOG_WAIT_TAG = "DIALOG_WAIT"; /** OwnCloud {@link Account} where the main {@link OCFile} handled by the activity is located. */ @@ -60,9 +75,26 @@ public abstract class FileActivity extends SherlockFragmentActivity { /** Flag to signal that the activity will is finishing to enforce the creation of an ownCloud {@link Account} */ private boolean mRedirectingToSetupAccount = false; + /** Flag to signal when the value of mAccount was set */ + private boolean mAccountWasSet; + + /** Flag to signal when the value of mAccount was restored from a saved state */ + private boolean mAccountWasRestored; + + /** Flag to signal if the activity is launched by a notification */ + private boolean mFromNotification; + + /** Messages handler associated to the main thread and the life cycle of the activity */ + private Handler mHandler; + + /** Access point to the cached database for the current ownCloud {@link Account} */ + private FileDataStorageManager mStorageManager = null; + + private FileOperationsHelper mFileOperationsHelper; + /** - * Loads the cownCloud {@link Account} and main {@link OCFile} to be handled by the instance of + * Loads the ownCloud {@link Account} and main {@link OCFile} to be handled by the instance of * the {@link FileActivity}. * * Grants that a valid ownCloud {@link Account} is associated to the instance, or that the user @@ -71,19 +103,21 @@ public abstract class FileActivity extends SherlockFragmentActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - + mHandler = new Handler(); + mFileOperationsHelper = new FileOperationsHelper(); + Account account; if(savedInstanceState != null) { + account = savedInstanceState.getParcelable(FileActivity.EXTRA_ACCOUNT); mFile = savedInstanceState.getParcelable(FileActivity.EXTRA_FILE); - mAccount = savedInstanceState.getParcelable(FileActivity.EXTRA_ACCOUNT); + mFromNotification = savedInstanceState.getBoolean(FileActivity.EXTRA_FROM_NOTIFICATION); } else { - mAccount = getIntent().getParcelableExtra(FileActivity.EXTRA_ACCOUNT); + account = getIntent().getParcelableExtra(FileActivity.EXTRA_ACCOUNT); mFile = getIntent().getParcelableExtra(FileActivity.EXTRA_FILE); + mFromNotification = getIntent().getBooleanExtra(FileActivity.EXTRA_FROM_NOTIFICATION, false); } - grantValidAccount(); - if (mAccount != null) { - onAccountSet(savedInstanceState != null); - } + setAccount(account, savedInstanceState != null); + } @@ -95,44 +129,82 @@ public abstract class FileActivity extends SherlockFragmentActivity { @Override protected void onRestart() { super.onRestart(); + boolean validAccount = (mAccount != null && AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), mAccount.name)); + if (!validAccount) { + swapToDefaultAccount(); + } - Account oldAccount = mAccount; - grantValidAccount(); - if (mAccount != null && !mAccount.equals(oldAccount)) { - onAccountSet(false); + } + + + @Override + protected void onStart() { + super.onStart(); + if (mAccountWasSet) { + onAccountSet(mAccountWasRestored); } } - + /** - * Validates the ownCloud {@link Account} associated to the Activity any time it is restarted. + * Sets and validates the ownCloud {@link Account} associated to the Activity. * * If not valid, tries to swap it for other valid and existing ownCloud {@link Account}. + * + * POSTCONDITION: updates {@link #mAccountWasSet} and {@link #mAccountWasRestored}. * - * If no valid ownCloud {@link Account} exists, mAccount is set to NULL and the user is requested - * to create a new ownCloud {@link Account}. + * @param account New {@link Account} to set. + * @param savedAccount When 'true', account was retrieved from a saved instance state. */ - private void grantValidAccount() { - boolean validAccount = (mAccount != null && AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), mAccount.name)); - if (!validAccount) { - // get most recently used account as default account - mAccount = AccountUtils.getCurrentOwnCloudAccount(getApplicationContext()); - if (mAccount == null) { - /// no account available: force account creation - createFirstAccount(); - mRedirectingToSetupAccount = true; - } + private void setAccount(Account account, boolean savedAccount) { + Account oldAccount = mAccount; + boolean validAccount = (account != null && AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), account.name)); + if (validAccount) { + mAccount = account; + mAccountWasSet = true; + mAccountWasRestored = (savedAccount || mAccount.equals(oldAccount)); + + } else { + swapToDefaultAccount(); } } + - + /** + * Tries to swap the current ownCloud {@link Account} for other valid and existing. + * + * If no valid ownCloud {@link Account} exists, the the user is requested + * to create a new ownCloud {@link Account}. + * + * POSTCONDITION: updates {@link #mAccountWasSet} and {@link #mAccountWasRestored}. + * + * @return 'True' if the checked {@link Account} was valid. + */ + private void swapToDefaultAccount() { + // default to the most recently used account + Account newAccount = AccountUtils.getCurrentOwnCloudAccount(getApplicationContext()); + if (newAccount == null) { + /// no account available: force account creation + createFirstAccount(); + mRedirectingToSetupAccount = true; + mAccountWasSet = false; + mAccountWasRestored = false; + + } else { + mAccountWasSet = true; + mAccountWasRestored = (newAccount.equals(mAccount)); + mAccount = newAccount; + } + } + + /** * Launches the account creation activity. To use when no ownCloud account is available */ private void createFirstAccount() { AccountManager am = AccountManager.get(getApplicationContext()); - am.addAccount(AccountAuthenticator.ACCOUNT_TYPE, - AccountAuthenticator.AUTH_TOKEN_TYPE_PASSWORD, + am.addAccount(MainApp.getAccountType(), + null, null, null, this, @@ -149,6 +221,7 @@ public abstract class FileActivity extends SherlockFragmentActivity { super.onSaveInstanceState(outState); outState.putParcelable(FileActivity.EXTRA_FILE, mFile); outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount); + outState.putBoolean(FileActivity.EXTRA_FROM_NOTIFICATION, mFromNotification); } @@ -181,6 +254,12 @@ public abstract class FileActivity extends SherlockFragmentActivity { return mAccount; } + /** + * @return Value of mFromNotification: True if the Activity is launched by a notification + */ + public boolean fromNotification() { + return mFromNotification; + } /** * @return 'True' when the Activity is finishing to enforce the setup of a new account. @@ -203,6 +282,7 @@ public abstract class FileActivity extends SherlockFragmentActivity { @Override public void run(AccountManagerFuture future) { FileActivity.this.mRedirectingToSetupAccount = false; + boolean accountWasSet = false; if (future != null) { try { Bundle result; @@ -210,11 +290,11 @@ public abstract class FileActivity extends SherlockFragmentActivity { String name = result.getString(AccountManager.KEY_ACCOUNT_NAME); String type = result.getString(AccountManager.KEY_ACCOUNT_TYPE); if (AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), name)) { - FileActivity.this.mAccount = new Account(name, type); - FileActivity.this.onAccountSet(false); + setAccount(new Account(name, type), false); + accountWasSet = true; } } catch (OperationCanceledException e) { - Log_OC.e(TAG, "Account creation canceled"); + Log_OC.d(TAG, "Account creation canceled"); } catch (Exception e) { Log_OC.e(TAG, "Account creation finished in exception: ", e); @@ -223,8 +303,8 @@ public abstract class FileActivity extends SherlockFragmentActivity { } else { Log_OC.e(TAG, "Account creation callback with null bundle"); } - if (mAccount == null) { - finish(); + if (!accountWasSet) { + moveTaskToBack(true); } } @@ -236,40 +316,103 @@ public abstract class FileActivity extends SherlockFragmentActivity { * * Child classes must grant that state depending on the {@link Account} is updated. */ - protected abstract void onAccountSet(boolean stateWasRecovered); + protected void onAccountSet(boolean stateWasRecovered) { + if (getAccount() != null) { + mStorageManager = new FileDataStorageManager(getAccount(), getContentResolver()); + + } else { + Log_OC.wtf(TAG, "onAccountChanged was called with NULL account associated!"); + } + } + + + public FileDataStorageManager getStorageManager() { + return mStorageManager; + } + + + public OnRemoteOperationListener getRemoteOperationListener() { + return this; + } + + + public Handler getHandler() { + return mHandler; + } + public FileOperationsHelper getFileOperationsHelper() { + return mFileOperationsHelper; + } - - public void openFile(OCFile file) { - if (file != null) { - String storagePath = file.getStoragePath(); - String encodedStoragePath = WebdavUtils.encodePath(storagePath); - - Intent intentForSavedMimeType = new Intent(Intent.ACTION_VIEW); - intentForSavedMimeType.setDataAndType(Uri.parse("file://"+ encodedStoragePath), file.getMimetype()); - intentForSavedMimeType.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); - - Intent intentForGuessedMimeType = null; - if (storagePath.lastIndexOf('.') >= 0) { - String guessedMimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(storagePath.substring(storagePath.lastIndexOf('.') + 1)); - if (guessedMimeType != null && !guessedMimeType.equals(file.getMimetype())) { - intentForGuessedMimeType = new Intent(Intent.ACTION_VIEW); - intentForGuessedMimeType.setDataAndType(Uri.parse("file://"+ encodedStoragePath), guessedMimeType); - intentForGuessedMimeType.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); - } - } - - Intent chooserIntent = null; - if (intentForGuessedMimeType != null) { - chooserIntent = Intent.createChooser(intentForGuessedMimeType, getString(R.string.actionbar_open_with)); - } else { - chooserIntent = Intent.createChooser(intentForSavedMimeType, getString(R.string.actionbar_open_with)); - } + /** + * + * @param operation Removal operation performed. + * @param result Result of the removal. + */ + @Override + public void onRemoteOperationFinish(RemoteOperation operation, RemoteOperationResult result) { + Log_OC.d(TAG, "Received result of operation in FileActivity - common behaviour for all the FileActivities "); + if (operation instanceof CreateShareOperation) { + onCreateShareOperationFinish((CreateShareOperation) operation, result); - startActivity(chooserIntent); + } else if (operation instanceof UnshareLinkOperation) { + onUnshareLinkOperationFinish((UnshareLinkOperation)operation, result); + + } + } + + private void onCreateShareOperationFinish(CreateShareOperation operation, RemoteOperationResult result) { + dismissLoadingDialog(); + if (result.isSuccess()) { + Intent sendIntent = operation.getSendIntent(); + startActivity(sendIntent); - } else { - Log_OC.wtf(TAG, "Trying to open a NULL OCFile"); + } else if (result.getCode() == ResultCode.SHARE_NOT_FOUND) { // Error --> SHARE_NOT_FOUND + Toast t = Toast.makeText(this, getString(R.string.share_link_file_no_exist), Toast.LENGTH_LONG); + t.show(); + } else { // Generic error + // Show a Message, operation finished without success + Toast t = Toast.makeText(this, getString(R.string.share_link_file_error), Toast.LENGTH_LONG); + t.show(); + } + } + + + private void onUnshareLinkOperationFinish(UnshareLinkOperation operation, RemoteOperationResult result) { + dismissLoadingDialog(); + + if (result.getCode() == ResultCode.SHARE_NOT_FOUND) { // Error --> SHARE_NOT_FOUND + Toast t = Toast.makeText(this, getString(R.string.unshare_link_file_no_exist), Toast.LENGTH_LONG); + t.show(); + } else if (!result.isSuccess()){ // Generic error + // Show a Message, operation finished without success + Toast t = Toast.makeText(this, getString(R.string.unshare_link_file_error), Toast.LENGTH_LONG); + t.show(); + } + + } + + /** + * Show loading dialog + */ + public void showLoadingDialog() { + // Construct dialog + LoadingDialog loading = new LoadingDialog(getResources().getString(R.string.wait_a_moment)); + FragmentManager fm = getSupportFragmentManager(); + FragmentTransaction ft = fm.beginTransaction(); + loading.show(ft, DIALOG_WAIT_TAG); + + } + + + /** + * Dismiss loading dialog + */ + public void dismissLoadingDialog(){ + Fragment frag = getSupportFragmentManager().findFragmentByTag(DIALOG_WAIT_TAG); + if (frag != null) { + LoadingDialog loading = (LoadingDialog) frag; + loading.dismiss(); } }