OC-2459: Ask for pincode, when click on an instant upload notification

[pub/Android/ownCloud.git] / 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 87be849..937d45d 100644 (file)
--- a/src/com/owncloud/android/ui/activity/FileActivity.java
+++ b/src/com/owncloud/android/ui/activity/FileActivity.java
@@ -23,31 +23,31 @@ import android.accounts.AccountManager;
 import android.accounts.AccountManagerCallback;
 import android.accounts.AccountManagerFuture;
 import android.accounts.OperationCanceledException;
 import android.accounts.AccountManagerCallback;
 import android.accounts.AccountManagerFuture;
 import android.accounts.OperationCanceledException;

-import android.content.ActivityNotFoundException;

 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
 import android.webkit.MimeTypeMap;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
 import android.webkit.MimeTypeMap;

-import android.widget.Toast;

 
 import com.actionbarsherlock.app.SherlockFragmentActivity;
 
 import com.actionbarsherlock.app.SherlockFragmentActivity;

-import com.owncloud.android.AccountUtils;
-import com.owncloud.android.Log_OC;
-import com.owncloud.android.authentication.AccountAuthenticator;
+import com.owncloud.android.MainApp;
+import com.owncloud.android.R;
+import com.owncloud.android.authentication.AccountUtils;

 import com.owncloud.android.datamodel.OCFile;
 import com.owncloud.android.datamodel.OCFile;

-import com.owncloud.android.files.FileHandler;
+import com.owncloud.android.oc_framework.network.webdav.WebdavUtils;
+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
  */
 
 /**
  * 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 implements FileHandler {
+public abstract class FileActivity extends SherlockFragmentActivity {

 
     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_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(); 
     


@@ -61,62 +61,126 @@ public abstract class FileActivity extends SherlockFragmentActivity implements F
     /** 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 that the activity will is finishing to enforce the creation of an ownCloud {@link Account} */
     private boolean mRedirectingToSetupAccount = false;
     

-    private FileHandlerImpl mFileHandler;
+    /** 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;

 
     
 
     

+    /**
+     * 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 
+     * is requested to create a new one.
+     */

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

-        
-        /// Load of saved instance state: keep this always before initDataFromCurrentAccount()
+
+        Account account;

         if(savedInstanceState != null) {
         if(savedInstanceState != null) {

+            account = savedInstanceState.getParcelable(FileActivity.EXTRA_ACCOUNT);

             mFile = savedInstanceState.getParcelable(FileActivity.EXTRA_FILE);
             mFile = savedInstanceState.getParcelable(FileActivity.EXTRA_FILE);

-            mAccount = savedInstanceState.getParcelable(FileActivity.EXTRA_ACCOUNT);
+            mFromNotification = savedInstanceState.getBoolean(FileActivity.EXTRA_FROM_NOTIFICATION);

         } else {
         } else {

-            mAccount = getIntent().getParcelableExtra(FileActivity.EXTRA_ACCOUNT);
+            account = getIntent().getParcelableExtra(FileActivity.EXTRA_ACCOUNT);

             mFile = getIntent().getParcelableExtra(FileActivity.EXTRA_FILE);
             mFile = getIntent().getParcelableExtra(FileActivity.EXTRA_FILE);

+            mFromNotification = getIntent().getBooleanExtra(FileActivity.EXTRA_FROM_NOTIFICATION, false);

         }
         }

-        
-        if (mAccount != null && AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), mAccount.name)) {
-            onAccountChanged();
-        }
-        
-        mFileHandler = new FileHandlerImpl();
+
+        setAccount(account, savedInstanceState != null);

     }
 
     
     /**
     }
 
     
     /**

-     * Validate the ownCloud {@link Account} associated to the Activity any time it is 
-     * started, and if not valid tries to move to a different Account.
+     *  Since ownCloud {@link Account}s can be managed from the system setting menu, 
+     *  the existence of the {@link Account} associated to the instance must be checked 
+     *  every time it is restarted.

      */
     @Override
      */
     @Override

+    protected void onRestart() {
+        super.onRestart();
+        boolean validAccount = (mAccount != null && AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), mAccount.name));
+        if (!validAccount) {
+            swapToDefaultAccount();
+        }
+        
+    }
+
+    
+    @Override 

     protected void onStart() {
     protected void onStart() {

-        Log_OC.e(TAG, "onStart en FileActivity");

         super.onStart();
         super.onStart();

-        /// Validate account, and try to fix if wrong
-        if (mAccount == null || !AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), mAccount.name)) {
-            if (!AccountUtils.accountsAreSetup(getApplicationContext())) {
-                /// no account available: force account creation
-                mAccount = null;
-                createFirstAccount();
-                mRedirectingToSetupAccount = true;
-                
-            } else {
-                /// get 'last current account' as default account
-                mAccount = AccountUtils.getCurrentOwnCloudAccount(getApplicationContext());
-                onAccountChanged();
-            }
+        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());
     /**
      * 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, 
                         null, 
                         null, 
                         this, 


@@ -133,6 +197,7 @@ public abstract class FileActivity extends SherlockFragmentActivity implements F
         super.onSaveInstanceState(outState);
         outState.putParcelable(FileActivity.EXTRA_FILE, mFile);
         outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount);
         super.onSaveInstanceState(outState);
         outState.putParcelable(FileActivity.EXTRA_FILE, mFile);
         outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount);

+        outState.putBoolean(FileActivity.EXTRA_FROM_NOTIFICATION, mFromNotification);

     }
     
     
     }
     
     


@@ -165,6 +230,12 @@ public abstract class FileActivity extends SherlockFragmentActivity implements F
         return mAccount;
     }
 
         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.
     
     /**
      * @return  'True' when the Activity is finishing to enforce the setup of a new account.


@@ -187,6 +258,7 @@ public abstract class FileActivity extends SherlockFragmentActivity implements F
         @Override
         public void run(AccountManagerFuture<Bundle> future) {
             FileActivity.this.mRedirectingToSetupAccount = false;
         @Override
         public void run(AccountManagerFuture<Bundle> future) {
             FileActivity.this.mRedirectingToSetupAccount = false;

+            boolean accountWasSet = false;

             if (future != null) {
                 try {
                     Bundle result;
             if (future != null) {
                 try {
                     Bundle result;


@@ -194,11 +266,11 @@ public abstract class FileActivity extends SherlockFragmentActivity implements F
                     String name = result.getString(AccountManager.KEY_ACCOUNT_NAME);
                     String type = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
                     if (AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), name)) {
                     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.onAccountChanged();
+                        setAccount(new Account(name, type), false);
+                        accountWasSet = true;

                     }
                 } catch (OperationCanceledException e) {
                     }
                 } 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);
                     
                 } catch (Exception e) {
                     Log_OC.e(TAG, "Account creation finished in exception: ", e);


@@ -207,76 +279,54 @@ public abstract class FileActivity extends SherlockFragmentActivity implements F
             } else {
                 Log_OC.e(TAG, "Account creation callback with null bundle");
             }
             } else {
                 Log_OC.e(TAG, "Account creation callback with null bundle");
             }

-            if (mAccount == null) {
-                finish();
+            if (!accountWasSet) {
+                moveTaskToBack(true);

             }
         }
         
     }
     
     
             }
         }
         
     }
     
     

-    public void openFile(OCFile file) {
-        mFileHandler.openFile(file);
-    }
-
-

     /**
      *  Called when the ownCloud {@link Account} associated to the Activity was just updated.
      * 
      *  Child classes must grant that state depending on the {@link Account} is updated.
      */
     /**
      *  Called when the ownCloud {@link Account} associated to the Activity was just updated.
      * 
      *  Child classes must grant that state depending on the {@link Account} is updated.
      */

-    protected abstract void onAccountChanged();
+    protected abstract void onAccountSet(boolean stateWasRecovered);

     
     
     
     

-    public class FileHandlerImpl implements FileHandler {
-        
-        public void openFile(OCFile file) {
-            if (file != null) {
-                String storagePath = file.getStoragePath();
-                String encodedStoragePath = WebdavUtils.encodePath(storagePath);
-                try {
-                    Intent i = new Intent(Intent.ACTION_VIEW);
-                    i.setDataAndType(Uri.parse("file://"+ encodedStoragePath), file.getMimetype());
-                    i.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
-                    startActivity(i);
-                    
-                } catch (Throwable t) {
-                    Log_OC.e(TAG, "Fail when trying to open with the mimeType provided from the ownCloud server: " + file.getMimetype());
-                    boolean toastIt = true; 
-                    String mimeType = "";
-                    try {
-                        Intent i = new Intent(Intent.ACTION_VIEW);
-                        mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(storagePath.substring(storagePath.lastIndexOf('.') + 1));
-                        if (mimeType == null || !mimeType.equals(file.getMimetype())) {
-                            if (mimeType != null) {
-                                i.setDataAndType(Uri.parse("file://"+ encodedStoragePath), mimeType);
-                            } else {
-                                // desperate try
-                                i.setDataAndType(Uri.parse("file://"+ encodedStoragePath), "*/*");
-                            }
-                            i.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
-                            startActivity(i);
-                            toastIt = false;
-                        }
-                        
-                    } catch (IndexOutOfBoundsException e) {
-                        Log_OC.e(TAG, "Trying to find out MIME type of a file without extension: " + storagePath);
-                        
-                    } catch (ActivityNotFoundException e) {
-                        Log_OC.e(TAG, "No activity found to handle: " + storagePath + " with MIME type " + mimeType + " obtained from extension");
-                        
-                    } catch (Throwable th) {
-                        Log_OC.e(TAG, "Unexpected problem when opening: " + storagePath, th);
-                        
-                    } finally {
-                        if (toastIt) {
-                            Toast.makeText(FileActivity.this, "There is no application to handle file " + file.getFileName(), Toast.LENGTH_SHORT).show();
-                        }
-                    }
+
+    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 {
             } else {

-                Log_OC.wtf(TAG, "Trying to open a NULL OCFile");
+                chooserIntent = Intent.createChooser(intentForSavedMimeType, getString(R.string.actionbar_open_with));

             }
             }

+            
+            startActivity(chooserIntent);
+            
+        } else {
+            Log_OC.wtf(TAG, "Trying to open a NULL OCFile");

         }
     }
         }
     }

+    

 }
 }