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. */
/** 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
@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);
}
- Account oldAccount = mAccount;
- grantValidAccount();
- if (mAccount != null) {
- mAccountWasSet = true;
- mAccountWasRestored = (savedInstanceState != null && mAccount.equals(oldAccount));
- } else {
- mAccountWasSet = false;
- mAccountWasRestored = false;
- }
+ setAccount(account, savedInstanceState != null);
+
}
@Override
protected void onRestart() {
super.onRestart();
-
- Account oldAccount = mAccount;
- grantValidAccount();
- if (mAccount != null && !mAccount.equals(oldAccount)) {
- mAccountWasSet = true;
- mAccountWasRestored = false;
- } else {
- mAccountWasSet = false;
- mAccountWasRestored = false;
- }
- }
-
-
- /**
- * Validates the ownCloud {@link Account} associated to the Activity any time it is restarted.
- *
- * If not valid, tries to swap it for other valid and existing ownCloud {@link Account}.
- *
- * If no valid ownCloud {@link Account} exists, mAccount is set to NULL and the user is requested
- * to create a new ownCloud {@link Account}.
- */
- 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;
- }
+ swapToDefaultAccount();
}
+
}
-
+
@Override
protected void onStart() {
- // maybe better in onPostCreate() ?
super.onStart();
if (mAccountWasSet) {
onAccountSet(mAccountWasRestored);
/**
+ * 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}.
+ *
+ * @param account New {@link Account} to set.
+ * @param savedAccount When 'true', account was retrieved from a saved instance state.
+ */
+ 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,
super.onSaveInstanceState(outState);
outState.putParcelable(FileActivity.EXTRA_FILE, mFile);
outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount);
+ outState.putBoolean(FileActivity.EXTRA_FROM_NOTIFICATION, mFromNotification);
}
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.
@Override
public void run(AccountManagerFuture<Bundle> future) {
FileActivity.this.mRedirectingToSetupAccount = false;
+ boolean accountWasSet = false;
if (future != null) {
try {
Bundle result;
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.d(TAG, "Account creation canceled");
} else {
Log_OC.e(TAG, "Account creation callback with null bundle");
}
- if (mAccount == null) {
+ if (!accountWasSet) {
moveTaskToBack(true);
}
}
*
* 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();
}
}
projects / pub / Android / ownCloud.git / blobdiff