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 ed5ea11..937d45d 100644 (file)
--- a/src/com/owncloud/android/ui/activity/FileActivity.java
+++ b/src/com/owncloud/android/ui/activity/FileActivity.java
@@ -24,13 +24,18 @@ import android.accounts.AccountManagerCallback;
 import android.accounts.AccountManagerFuture;
 import android.accounts.OperationCanceledException;
 import android.content.Intent;
 import android.accounts.AccountManagerFuture;
 import android.accounts.OperationCanceledException;
 import android.content.Intent;

+import android.net.Uri;

 import android.os.Bundle;
 import android.os.Bundle;

+import android.webkit.MimeTypeMap;

 
 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.oc_framework.network.webdav.WebdavUtils;
+import com.owncloud.android.utils.Log_OC;
+

 
 /**
  * Activity with common behaviour for activities handling {@link OCFile}s in ownCloud {@link Account}s .
 
 /**
  * Activity with common behaviour for activities handling {@link OCFile}s in ownCloud {@link Account}s .


@@ -41,6 +46,8 @@ 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(); 
     


@@ -53,64 +60,127 @@ 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 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;

 
     
 
     

+    /**
+     * 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
     @Override

-    public void onCreate(Bundle savedInstanceState) {
+    protected void onCreate(Bundle savedInstanceState) {

         super.onCreate(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();
-        }
+
+        setAccount(account, savedInstanceState != null);

     }
 
     
     }
 
     

+    /**
+     *  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

-    public void onStart() {
-        Log_OC.e(TAG, "onStart en FileActivity");
+    protected void onRestart() {
+        super.onRestart();
+        boolean validAccount = (mAccount != null && AccountUtils.setCurrentOwnCloudAccount(getApplicationContext(), mAccount.name));
+        if (!validAccount) {
+            swapToDefaultAccount();
+        }
+        
+    }
+
+    
+    @Override 
+    protected void onStart() {

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

         }
     }
     
         }
     }
     

-        
+    

     /**
     /**

-     * Launches the account creation activity. To use when no ownCloud account is available
+     *  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 createFirstAccountOldStyle() {
-        Intent intent = new Intent(android.provider.Settings.ACTION_ADD_ACCOUNT);
-        intent.putExtra(android.provider.Settings.EXTRA_AUTHORITIES, new String[] { AccountAuthenticator.AUTHORITY });
-        startActivity(intent); 
-        
-        finish();
+    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());
     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, 


@@ -119,11 +189,15 @@ public abstract class FileActivity extends SherlockFragmentActivity {
     }
 
     
     }
 
     

+    /**
+     * {@inheritDoc}
+     */

     @Override
     protected void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
         outState.putParcelable(FileActivity.EXTRA_FILE, mFile);
         outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount);
     @Override
     protected void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
         outState.putParcelable(FileActivity.EXTRA_FILE, mFile);
         outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount);

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

     }
     
     
     }
     
     


@@ -156,6 +230,12 @@ public abstract class FileActivity extends SherlockFragmentActivity {
         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.


@@ -178,6 +258,7 @@ public abstract class FileActivity extends SherlockFragmentActivity {
         @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;


@@ -185,11 +266,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)) {
                     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);


@@ -198,18 +279,54 @@ public abstract class FileActivity extends SherlockFragmentActivity {
             } 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);

             }
         }
         
     }
             }
         }
         
     }

-
-
+    
+    

     /**
      *  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 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));
+            }
+            
+            startActivity(chooserIntent);
+            
+        } else {
+            Log_OC.wtf(TAG, "Trying to open a NULL OCFile");
+        }
+    }
+    

 }
 }