src/com/owncloud/android/datamodel/FileDataStorageManager.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012  Bartek Przybylski
   3  *   Copyright (C) 2012-2014 ownCloud Inc.
   4  *
   5  *   This program is free software: you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License version 2,
   7  *   as published by the Free Software Foundation.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details.
  13  *
  14  *   You should have received a copy of the GNU General Public License
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  */
  18
  19 package com.owncloud.android.datamodel;
  20
  21 import java.io.File;
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.Iterator;
  26 import java.util.Vector;
  27
  28 import com.owncloud.android.MainApp;
  29 import com.owncloud.android.db.ProviderMeta.ProviderTableMeta;
  30 import com.owncloud.android.lib.resources.shares.OCShare;
  31 import com.owncloud.android.lib.resources.shares.ShareType;
  32 import com.owncloud.android.lib.resources.files.FileUtils;
  33 import com.owncloud.android.utils.FileStorageUtils;
  34 import com.owncloud.android.utils.Log_OC;
  35
  36
  37 import android.accounts.Account;
  38 import android.content.ContentProviderClient;
  39 import android.content.ContentProviderOperation;
  40 import android.content.ContentProviderResult;
  41 import android.content.ContentResolver;
  42 import android.content.ContentUris;
  43 import android.content.ContentValues;
  44 import android.content.Intent;
  45 import android.content.OperationApplicationException;
  46 import android.database.Cursor;
  47 import android.net.Uri;
  48 import android.os.RemoteException;
  49
  50 public class FileDataStorageManager {
  51
  52     public static final int ROOT_PARENT_ID = 0;
  53
  54     private ContentResolver mContentResolver;
  55     private ContentProviderClient mContentProviderClient;
  56     private Account mAccount;
  57
  58     private static String TAG = FileDataStorageManager.class.getSimpleName();
  59
  60
  61     public FileDataStorageManager(Account account, ContentResolver cr) {
  62         mContentProviderClient = null;
  63         mContentResolver = cr;
  64         mAccount = account;
  65     }
  66
  67     public FileDataStorageManager(Account account, ContentProviderClient cp) {
  68         mContentProviderClient = cp;
  69         mContentResolver = null;
  70         mAccount = account;
  71     }
  72
  73
  74     public void setAccount(Account account) {
  75         mAccount = account;
  76     }
  77
  78     public Account getAccount() {
  79         return mAccount;
  80     }
  81
  82     public void setContentResolver(ContentResolver cr) {
  83         mContentResolver = cr;
  84     }
  85
  86     public ContentResolver getContentResolver() {
  87         return mContentResolver;
  88     }
  89
  90     public void setContentProviderClient(ContentProviderClient cp) {
  91         mContentProviderClient = cp;
  92     }
  93
  94     public ContentProviderClient getContentProviderClient() {
  95         return mContentProviderClient;
  96     }
  97
  98
  99     public OCFile getFileByPath(String path) {
 100         Cursor c = getCursorForValue(ProviderTableMeta.FILE_PATH, path);
 101         OCFile file = null;
 102         if (c.moveToFirst()) {
 103             file = createFileInstance(c);
 104         }
 105         c.close();
 106         if (file == null && OCFile.ROOT_PATH.equals(path)) {
 107             return createRootDir(); // root should always exist
 108         }
 109         return file;
 110     }
 111
 112
 113     public OCFile getFileById(long id) {
 114         Cursor c = getCursorForValue(ProviderTableMeta._ID, String.valueOf(id));
 115         OCFile file = null;
 116         if (c.moveToFirst()) {
 117             file = createFileInstance(c);
 118         }
 119         c.close();
 120         return file;
 121     }
 122
 123     public OCFile getFileByLocalPath(String path) {
 124         Cursor c = getCursorForValue(ProviderTableMeta.FILE_STORAGE_PATH, path);
 125         OCFile file = null;
 126         if (c.moveToFirst()) {
 127             file = createFileInstance(c);
 128         }
 129         c.close();
 130         return file;
 131     }
 132
 133     public boolean fileExists(long id) {
 134         return fileExists(ProviderTableMeta._ID, String.valueOf(id));
 135     }
 136
 137     public boolean fileExists(String path) {
 138         return fileExists(ProviderTableMeta.FILE_PATH, path);
 139     }
 140
 141
 142     public Vector<OCFile> getFolderContent(OCFile f) {
 143         if (f != null && f.isFolder() && f.getFileId() != -1) {
 144             return getFolderContent(f.getFileId());
 145
 146         } else {
 147             return new Vector<OCFile>();
 148         }
 149     }
 150
 151
 152     public Vector<OCFile> getFolderImages(OCFile folder) {
 153         Vector<OCFile> ret = new Vector<OCFile>();
 154         if (folder != null) {
 155             // TODO better implementation, filtering in the access to database (if possible) instead of here
 156             Vector<OCFile> tmp = getFolderContent(folder);
 157             OCFile current = null;
 158             for (int i=0; i<tmp.size(); i++) {
 159                 current = tmp.get(i);
 160                 if (current.isImage()) {
 161                     ret.add(current);
 162                 }
 163             }
 164         }
 165         return ret;
 166     }
 167
 168
 169     public boolean saveFile(OCFile file) {
 170         boolean overriden = false;
 171         ContentValues cv = new ContentValues();
 172         cv.put(ProviderTableMeta.FILE_MODIFIED, file.getModificationTimestamp());
 173         cv.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA, file.getModificationTimestampAtLastSyncForData());
 174         cv.put(ProviderTableMeta.FILE_CREATION, file.getCreationTimestamp());
 175         cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, file.getFileLength());
 176         cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, file.getMimetype());
 177         cv.put(ProviderTableMeta.FILE_NAME, file.getFileName());
 178         //if (file.getParentId() != DataStorageManager.ROOT_PARENT_ID)
 179             cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
 180         cv.put(ProviderTableMeta.FILE_PATH, file.getRemotePath());
 181         if (!file.isFolder())
 182             cv.put(ProviderTableMeta.FILE_STORAGE_PATH, file.getStoragePath());
 183         cv.put(ProviderTableMeta.FILE_ACCOUNT_OWNER, mAccount.name);
 184         cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, file.getLastSyncDateForProperties());
 185         cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, file.getLastSyncDateForData());
 186         cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, file.keepInSync() ? 1 : 0);
 187         cv.put(ProviderTableMeta.FILE_ETAG, file.getEtag());
 188         cv.put(ProviderTableMeta.FILE_SHARE_BY_LINK, file.isShareByLink() ? 1 : 0);
 189         cv.put(ProviderTableMeta.FILE_PUBLIC_LINK, file.getPublicLink());
 190         cv.put(ProviderTableMeta.FILE_PERMISSIONS, file.getPermissions());
 191         cv.put(ProviderTableMeta.FILE_REMOTE_ID, file.getRemoteId());
 192
 193         boolean sameRemotePath = fileExists(file.getRemotePath());
 194         if (sameRemotePath ||
 195                 fileExists(file.getFileId())        ) {           // for renamed files; no more delete and create
 196
 197             OCFile oldFile = null;
 198             if (sameRemotePath) {
 199                 oldFile = getFileByPath(file.getRemotePath());
 200                 file.setFileId(oldFile.getFileId());
 201             } else {
 202                 oldFile = getFileById(file.getFileId());
 203             }
 204
 205             overriden = true;
 206             if (getContentResolver() != null) {
 207                 getContentResolver().update(ProviderTableMeta.CONTENT_URI, cv,
 208                         ProviderTableMeta._ID + "=?",
 209                         new String[] { String.valueOf(file.getFileId()) });
 210             } else {
 211                 try {
 212                     getContentProviderClient().update(ProviderTableMeta.CONTENT_URI,
 213                             cv, ProviderTableMeta._ID + "=?",
 214                             new String[] { String.valueOf(file.getFileId()) });
 215                 } catch (RemoteException e) {
 216                     Log_OC.e(TAG,
 217                             "Fail to insert insert file to database "
 218                                     + e.getMessage());
 219                 }
 220             }
 221         } else {
 222             Uri result_uri = null;
 223             if (getContentResolver() != null) {
 224                 result_uri = getContentResolver().insert(
 225                         ProviderTableMeta.CONTENT_URI_FILE, cv);
 226             } else {
 227                 try {
 228                     result_uri = getContentProviderClient().insert(
 229                             ProviderTableMeta.CONTENT_URI_FILE, cv);
 230                 } catch (RemoteException e) {
 231                     Log_OC.e(TAG,
 232                             "Fail to insert insert file to database "
 233                                     + e.getMessage());
 234                 }
 235             }
 236             if (result_uri != null) {
 237                 long new_id = Long.parseLong(result_uri.getPathSegments()
 238                         .get(1));
 239                 file.setFileId(new_id);
 240             }
 241         }
 242
 243 //        if (file.isFolder()) {
 244 //            updateFolderSize(file.getFileId());
 245 //        } else {
 246 //            updateFolderSize(file.getParentId());
 247 //        }
 248
 249         return overriden;
 250     }
 251
 252
 253     /**
 254      * Inserts or updates the list of files contained in a given folder.
 255      *
 256      * CALLER IS THE RESPONSIBLE FOR GRANTING RIGHT UPDATE OF INFORMATION, NOT THIS METHOD.
 257      * HERE ONLY DATA CONSISTENCY SHOULD BE GRANTED
 258      *
 259      * @param folder
 260      * @param files
 261      * @param removeNotUpdated
 262      */
 263     public void saveFolder(OCFile folder, Collection<OCFile> updatedFiles, Collection<OCFile> filesToRemove) {
 264
 265         Log_OC.d(TAG,  "Saving folder " + folder.getRemotePath() + " with " + updatedFiles.size() + " children and " + filesToRemove.size() + " files to remove");
 266
 267         ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(updatedFiles.size());
 268
 269         // prepare operations to insert or update files to save in the given folder
 270         for (OCFile file : updatedFiles) {
 271             ContentValues cv = new ContentValues();
 272             cv.put(ProviderTableMeta.FILE_MODIFIED, file.getModificationTimestamp());
 273             cv.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA, file.getModificationTimestampAtLastSyncForData());
 274             cv.put(ProviderTableMeta.FILE_CREATION, file.getCreationTimestamp());
 275             cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, file.getFileLength());
 276             cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, file.getMimetype());
 277             cv.put(ProviderTableMeta.FILE_NAME, file.getFileName());
 278             //cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
 279             cv.put(ProviderTableMeta.FILE_PARENT, folder.getFileId());
 280             cv.put(ProviderTableMeta.FILE_PATH, file.getRemotePath());
 281             if (!file.isFolder()) {
 282                 cv.put(ProviderTableMeta.FILE_STORAGE_PATH, file.getStoragePath());
 283             }
 284             cv.put(ProviderTableMeta.FILE_ACCOUNT_OWNER, mAccount.name);
 285             cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, file.getLastSyncDateForProperties());
 286             cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, file.getLastSyncDateForData());
 287             cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, file.keepInSync() ? 1 : 0);
 288             cv.put(ProviderTableMeta.FILE_ETAG, file.getEtag());
 289             cv.put(ProviderTableMeta.FILE_SHARE_BY_LINK, file.isShareByLink() ? 1 : 0);
 290             cv.put(ProviderTableMeta.FILE_PUBLIC_LINK, file.getPublicLink());
 291             cv.put(ProviderTableMeta.FILE_PERMISSIONS, file.getPermissions());
 292             cv.put(ProviderTableMeta.FILE_REMOTE_ID, file.getRemoteId());
 293
 294             boolean existsByPath = fileExists(file.getRemotePath());
 295             if (existsByPath || fileExists(file.getFileId())) {
 296                 // updating an existing file
 297                 operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
 298                         withValues(cv).
 299                         withSelection(  ProviderTableMeta._ID + "=?",
 300                                 new String[] { String.valueOf(file.getFileId()) })
 301                                 .build());
 302
 303             } else {
 304                 // adding a new file
 305                 operations.add(ContentProviderOperation.newInsert(ProviderTableMeta.CONTENT_URI).withValues(cv).build());
 306             }
 307         }
 308
 309         // prepare operations to remove files in the given folder
 310         String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
 311         String [] whereArgs = null;
 312         for (OCFile file : filesToRemove) {
 313             if (file.getParentId() == folder.getFileId()) {
 314                 whereArgs = new String[]{mAccount.name, file.getRemotePath()};
 315                 //Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, "" + file.getFileId());
 316                 if (file.isFolder()) {
 317                     operations.add(ContentProviderOperation
 318                                     .newDelete(ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_DIR, file.getFileId())).withSelection(where, whereArgs)
 319                                         .build());
 320                     // TODO remove local folder
 321                 } else {
 322                     operations.add(ContentProviderOperation
 323                                     .newDelete(ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, file.getFileId())).withSelection(where, whereArgs)
 324                                         .build());
 325                     if (file.isDown()) {
 326                         new File(file.getStoragePath()).delete();
 327                         // TODO move the deletion of local contents after success of deletions
 328                     }
 329                 }
 330             }
 331         }
 332
 333         // update metadata of folder
 334         ContentValues cv = new ContentValues();
 335         cv.put(ProviderTableMeta.FILE_MODIFIED, folder.getModificationTimestamp());
 336         cv.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA, folder.getModificationTimestampAtLastSyncForData());
 337         cv.put(ProviderTableMeta.FILE_CREATION, folder.getCreationTimestamp());
 338         cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, 0);   // FileContentProvider calculates the right size
 339         cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, folder.getMimetype());
 340         cv.put(ProviderTableMeta.FILE_NAME, folder.getFileName());
 341         cv.put(ProviderTableMeta.FILE_PARENT, folder.getParentId());
 342         cv.put(ProviderTableMeta.FILE_PATH, folder.getRemotePath());
 343         cv.put(ProviderTableMeta.FILE_ACCOUNT_OWNER, mAccount.name);
 344         cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, folder.getLastSyncDateForProperties());
 345         cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, folder.getLastSyncDateForData());
 346         cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, folder.keepInSync() ? 1 : 0);
 347         cv.put(ProviderTableMeta.FILE_ETAG, folder.getEtag());
 348         cv.put(ProviderTableMeta.FILE_SHARE_BY_LINK, folder.isShareByLink() ? 1 : 0);
 349         cv.put(ProviderTableMeta.FILE_PUBLIC_LINK, folder.getPublicLink());
 350         cv.put(ProviderTableMeta.FILE_PERMISSIONS, folder.getPermissions());
 351         cv.put(ProviderTableMeta.FILE_REMOTE_ID, folder.getRemoteId());
 352
 353         operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
 354                 withValues(cv).
 355                 withSelection(  ProviderTableMeta._ID + "=?",
 356                         new String[] { String.valueOf(folder.getFileId()) })
 357                         .build());
 358
 359         // apply operations in batch
 360         ContentProviderResult[] results = null;
 361         Log_OC.d(TAG, "Sending " + operations.size() + " operations to FileContentProvider");
 362         try {
 363             if (getContentResolver() != null) {
 364                 results = getContentResolver().applyBatch(MainApp.getAuthority(), operations);
 365
 366             } else {
 367                 results = getContentProviderClient().applyBatch(operations);
 368             }
 369
 370         } catch (OperationApplicationException e) {
 371             Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
 372
 373         } catch (RemoteException e) {
 374             Log_OC.e(TAG, "Exception in batch of operations  " + e.getMessage());
 375         }
 376
 377         // update new id in file objects for insertions
 378         if (results != null) {
 379             long newId;
 380             Iterator<OCFile> filesIt = updatedFiles.iterator();
 381             OCFile file = null;
 382             for (int i=0; i<results.length; i++) {
 383                 if (filesIt.hasNext()) {
 384                     file = filesIt.next();
 385                 } else {
 386                     file = null;
 387                 }
 388                 if (results[i].uri != null) {
 389                     newId = Long.parseLong(results[i].uri.getPathSegments().get(1));
 390                     //updatedFiles.get(i).setFileId(newId);
 391                     if (file != null) {
 392                         file.setFileId(newId);
 393                     }
 394                 }
 395             }
 396         }
 397
 398         //updateFolderSize(folder.getFileId());
 399
 400     }
 401
 402
 403 //    /**
 404 //     *
 405 //     * @param id
 406 //     */
 407 //    private void updateFolderSize(long id) {
 408 //        if (id > FileDataStorageManager.ROOT_PARENT_ID) {
 409 //            Log_OC.d(TAG, "Updating size of " + id);
 410 //            if (getContentResolver() != null) {
 411 //                getContentResolver().update(ProviderTableMeta.CONTENT_URI_DIR,
 412 //                        new ContentValues(),    // won't be used, but cannot be null; crashes in KLP
 413 //                        ProviderTableMeta._ID + "=?",
 414 //                        new String[] { String.valueOf(id) });
 415 //            } else {
 416 //                try {
 417 //                    getContentProviderClient().update(ProviderTableMeta.CONTENT_URI_DIR,
 418 //                            new ContentValues(),    // won't be used, but cannot be null; crashes in KLP
 419 //                            ProviderTableMeta._ID + "=?",
 420 //                            new String[] { String.valueOf(id) });
 421 //
 422 //                } catch (RemoteException e) {
 423 //                    Log_OC.e(TAG, "Exception in update of folder size through compatibility patch " + e.getMessage());
 424 //                }
 425 //            }
 426 //        } else {
 427 //            Log_OC.e(TAG,  "not updating size for folder " + id);
 428 //        }
 429 //    }
 430
 431
 432     public boolean removeFile(OCFile file, boolean removeDBData, boolean removeLocalCopy) {
 433         boolean success = true;
 434         if (file != null) {
 435             if (file.isFolder()) {
 436                 success = removeFolder(file, removeDBData, removeLocalCopy);
 437
 438             } else {
 439                 if (removeDBData) {
 440                     //Uri file_uri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, ""+file.getFileId());
 441                     Uri file_uri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, file.getFileId());
 442                     String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
 443                     String [] whereArgs = new String[]{mAccount.name, file.getRemotePath()};
 444                     int deleted = 0;
 445                     if (getContentProviderClient() != null) {
 446                         try {
 447                             deleted = getContentProviderClient().delete(file_uri, where, whereArgs);
 448                         } catch (RemoteException e) {
 449                             e.printStackTrace();
 450                         }
 451                     } else {
 452                         deleted = getContentResolver().delete(file_uri, where, whereArgs);
 453                     }
 454                     success &= (deleted > 0);
 455                 }
 456                 if (removeLocalCopy && file.isDown() && file.getStoragePath() != null && success) {
 457                     success = new File(file.getStoragePath()).delete();
 458                     if (!removeDBData && success) {
 459                         // maybe unnecessary, but should be checked TODO remove if unnecessary
 460                         file.setStoragePath(null);
 461                         saveFile(file);
 462                     }
 463                 }
 464             }
 465         }
 466         return success;
 467     }
 468
 469
 470     public boolean removeFolder(OCFile folder, boolean removeDBData, boolean removeLocalContent) {
 471         boolean success = true;
 472         if (folder != null && folder.isFolder()) {
 473             if (removeDBData &&  folder.getFileId() != -1) {
 474                 success = removeFolderInDb(folder);
 475             }
 476             if (removeLocalContent && success) {
 477                 success = removeLocalFolder(folder);
 478             }
 479         }
 480         return success;
 481     }
 482
 483     private boolean removeFolderInDb(OCFile folder) {
 484         Uri folder_uri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_DIR, ""+ folder.getFileId());   // URI for recursive deletion
 485         String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
 486         String [] whereArgs = new String[]{mAccount.name, folder.getRemotePath()};
 487         int deleted = 0;
 488         if (getContentProviderClient() != null) {
 489             try {
 490                 deleted = getContentProviderClient().delete(folder_uri, where, whereArgs);
 491             } catch (RemoteException e) {
 492                 e.printStackTrace();
 493             }
 494         } else {
 495             deleted = getContentResolver().delete(folder_uri, where, whereArgs);
 496         }
 497         return deleted > 0;
 498     }
 499
 500     private boolean removeLocalFolder(OCFile folder) {
 501         boolean success = true;
 502         File localFolder = new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, folder));
 503         if (localFolder.exists()) {
 504             // stage 1: remove the local files already registered in the files database
 505             Vector<OCFile> files = getFolderContent(folder.getFileId());
 506             if (files != null) {
 507                 for (OCFile file : files) {
 508                     if (file.isFolder()) {
 509                         success &= removeLocalFolder(file);
 510                     } else {
 511                         if (file.isDown()) {
 512                             File localFile = new File(file.getStoragePath());
 513                             success &= localFile.delete();
 514                             if (success) {
 515                                 file.setStoragePath(null);
 516                                 saveFile(file);
 517                             }
 518                         }
 519                     }
 520                 }
 521             }
 522
 523             // stage 2: remove the folder itself and any local file inside out of sync;
 524             //          for instance, after clearing the app cache or reinstalling
 525             success &= removeLocalFolder(localFolder);
 526         }
 527         return success;
 528     }
 529
 530     private boolean removeLocalFolder(File localFolder) {
 531         boolean success = true;
 532         File[] localFiles = localFolder.listFiles();
 533         if (localFiles != null) {
 534             for (File localFile : localFiles) {
 535                 if (localFile.isDirectory()) {
 536                     success &= removeLocalFolder(localFile);
 537                 } else {
 538                     success &= localFile.delete();
 539                 }
 540             }
 541         }
 542         success &= localFolder.delete();
 543         return success;
 544     }
 545
 546     /**
 547      * Updates database for a folder that was moved to a different location.
 548      *
 549      * TODO explore better (faster) implementations
 550      * TODO throw exceptions up !
 551      */
 552     public void moveFolder(OCFile folder, String newPath) {
 553         // TODO check newPath
 554
 555         if (folder != null && folder.isFolder() && folder.fileExists() && !OCFile.ROOT_PATH.equals(folder.getFileName())) {
 556             /// 1. get all the descendants of 'dir' in a single QUERY (including 'dir')
 557             Cursor c = null;
 558             if (getContentProviderClient() != null) {
 559                 try {
 560                     c = getContentProviderClient().query(ProviderTableMeta.CONTENT_URI,
 561                             null,
 562                             ProviderTableMeta.FILE_ACCOUNT_OWNER + "=? AND " + ProviderTableMeta.FILE_PATH + " LIKE ? ",
 563                             new String[] { mAccount.name, folder.getRemotePath() + "%"  }, ProviderTableMeta.FILE_PATH + " ASC ");
 564                 } catch (RemoteException e) {
 565                     Log_OC.e(TAG, e.getMessage());
 566                 }
 567             } else {
 568                 c = getContentResolver().query(ProviderTableMeta.CONTENT_URI,
 569                         null,
 570                         ProviderTableMeta.FILE_ACCOUNT_OWNER + "=? AND " + ProviderTableMeta.FILE_PATH + " LIKE ? ",
 571                         new String[] { mAccount.name, folder.getRemotePath() + "%"  }, ProviderTableMeta.FILE_PATH + " ASC ");
 572             }
 573
 574             /// 2. prepare a batch of update operations to change all the descendants
 575             ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(c.getCount());
 576             int lengthOfOldPath = folder.getRemotePath().length();
 577             String defaultSavePath = FileStorageUtils.getSavePath(mAccount.name);
 578             int lengthOfOldStoragePath = defaultSavePath.length() + lengthOfOldPath;
 579             if (c.moveToFirst()) {
 580                 do {
 581                     ContentValues cv = new ContentValues(); // don't take the constructor out of the loop and clear the object
 582                     OCFile child = createFileInstance(c);
 583                     cv.put(ProviderTableMeta.FILE_PATH, newPath + child.getRemotePath().substring(lengthOfOldPath));
 584                     if (child.getStoragePath() != null && child.getStoragePath().startsWith(defaultSavePath)) {
 585                         cv.put(ProviderTableMeta.FILE_STORAGE_PATH, defaultSavePath + newPath + child.getStoragePath().substring(lengthOfOldStoragePath));
 586                     }
 587                     operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
 588                             withValues(cv).
 589                             withSelection(  ProviderTableMeta._ID + "=?",
 590                                     new String[] { String.valueOf(child.getFileId()) })
 591                                     .build());
 592                 } while (c.moveToNext());
 593             }
 594             c.close();
 595
 596             /// 3. apply updates in batch
 597             try {
 598                 if (getContentResolver() != null) {
 599                     getContentResolver().applyBatch(MainApp.getAuthority(), operations);
 600
 601                 } else {
 602                     getContentProviderClient().applyBatch(operations);
 603                 }
 604
 605             } catch (OperationApplicationException e) {
 606                 Log_OC.e(TAG, "Fail to update descendants of " + folder.getFileId() + " in database", e);
 607
 608             } catch (RemoteException e) {
 609                 Log_OC.e(TAG, "Fail to update desendants of " + folder.getFileId() + " in database", e);
 610             }
 611
 612         }
 613     }
 614
 615
 616     //public void moveFolder(OCFile folder, String newPath) {
 617     public void moveLocalFile(OCFile file, String targetPath) {
 618         // TODO check newPath
 619         if (file != null && file.fileExists()) {
 620
 621             if (//file.isFolder() && // should work for regular files!!
 622                 !OCFile.ROOT_PATH.equals(file.getFileName())) {
 623
 624                 /// 0. move in local file system
 625
 626                 /// 1. get all the descendants in a single QUERY (including the folder)
 627                 Cursor c = null;
 628                 if (getContentProviderClient() != null) {
 629                     try {
 630                         c = getContentProviderClient().query(
 631                             ProviderTableMeta.CONTENT_URI,
 632                             null,
 633                             ProviderTableMeta.FILE_ACCOUNT_OWNER + "=? AND " +
 634                                     ProviderTableMeta.FILE_PATH + " LIKE ? ",
 635                             new String[] {
 636                                     mAccount.name,
 637                                     file.getRemotePath() + "%"
 638                             },
 639                             ProviderTableMeta.FILE_PATH + " ASC "
 640                         );
 641                     } catch (RemoteException e) {
 642                         Log_OC.e(TAG, e.getMessage());
 643                     }
 644
 645                 } else {
 646                     c = getContentResolver().query(
 647                         ProviderTableMeta.CONTENT_URI,
 648                         null,
 649                         ProviderTableMeta.FILE_ACCOUNT_OWNER + "=? AND " +
 650                                 ProviderTableMeta.FILE_PATH + " LIKE ? ",
 651                         new String[] {
 652                                 mAccount.name,
 653                                 file.getRemotePath() + "%"
 654                         },
 655                         ProviderTableMeta.FILE_PATH + " ASC "
 656                     );
 657                 }
 658
 659                 /// 2. prepare a batch of update operations to change all the descendants
 660                 ArrayList<ContentProviderOperation> operations =
 661                         new ArrayList<ContentProviderOperation>(c.getCount());
 662                 if (c.moveToFirst()) {
 663                     int lengthOfOldPath = file.getRemotePath().length();
 664                     String defaultSavePath = FileStorageUtils.getSavePath(mAccount.name);
 665                     int lengthOfOldStoragePath = defaultSavePath.length() + lengthOfOldPath;
 666                     do {
 667                         ContentValues cv = new ContentValues(); // keep construction in the loop
 668                         OCFile child = createFileInstance(c);
 669                         cv.put(
 670                             ProviderTableMeta.FILE_PATH,
 671                             targetPath + child.getRemotePath().substring(lengthOfOldPath)
 672                         );
 673                         if (child.getStoragePath() != null &&
 674                                 child.getStoragePath().startsWith(defaultSavePath)) {
 675                             // update link to downloaded content - but local move is not done here!
 676                             cv.put(
 677                                 ProviderTableMeta.FILE_STORAGE_PATH,
 678                                 defaultSavePath + targetPath +
 679                                     child.getStoragePath().substring(lengthOfOldStoragePath)
 680                             );
 681                         }
 682                         operations.add(
 683                             ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
 684                                 withValues(cv).
 685                                 withSelection(
 686                                         ProviderTableMeta._ID + "=?",
 687                                         new String[] { String.valueOf(child.getFileId()) }
 688                                         )
 689                                 .build());
 690
 691                     } while (c.moveToNext());
 692                 }
 693                 c.close();
 694
 695                 /// 3. apply updates in batch
 696                 try {
 697                     if (getContentResolver() != null) {
 698                         getContentResolver().applyBatch(MainApp.getAuthority(), operations);
 699
 700                     } else {
 701                         getContentProviderClient().applyBatch(operations);
 702                     }
 703
 704                 } catch (Exception e) {
 705                     Log_OC.e(
 706                         TAG,
 707                         "Fail to update " + file.getFileId() + " and descendants in database",
 708                         e
 709                     );
 710                 }
 711
 712             }
 713         }
 714
 715         /*
 716         private void saveLocalDirectory() {
 717              * TODO implement local movement of folder
 718             getStorageManager().moveFolder(mFile, mNewPath);
 719             String localPath = FileStorageUtils.getDefaultSavePathFor(mAccount.name, mFile);
 720             File localDir = new File(localPath);
 721             if (localDir.exists()) {
 722                 localDir.renameTo(new File(FileStorageUtils.getSavePath(mAccount.name) + mNewPath));
 723                 // TODO - if renameTo fails, children files that are already down will result unlinked
 724             }
 725         }
 726         */
 727
 728         /*
 729         private void saveLocalFile() {
 730             mFile.setRFileName(mNewName);   <<< NO >
 731
 732             // try to move the local copy of the file
 733             if (mFile.isDown()) {
 734                 File f = new File(mFile.getStoragePath());
 735                 String parentStoragePath = f.getParent();
 736                 if (!parentStoragePath.endsWith(File.separator))
 737                     parentStoragePath += File.separator;
 738                 if (f.renameTo(new File())) {
 739                     mFile.setStoragePath(parentStoragePath + mNewName);
 740                 }
 741                 // else - NOTHING: the link to the local file is kept although the local name can't be updated
 742                 // TODO - study conditions when this could be a problem
 743             }
 744
 745             getStorageManager().saveFile(mFile);
 746         }
 747         */
 748
 749     }
 750
 751
 752     private Vector<OCFile> getFolderContent(long parentId) {
 753
 754         Vector<OCFile> ret = new Vector<OCFile>();
 755
 756         Uri req_uri = Uri.withAppendedPath(
 757                 ProviderTableMeta.CONTENT_URI_DIR,
 758                 String.valueOf(parentId));
 759         Cursor c = null;
 760
 761         if (getContentProviderClient() != null) {
 762             try {
 763                 c = getContentProviderClient().query(req_uri, null,
 764                         ProviderTableMeta.FILE_PARENT + "=?" ,
 765                         new String[] { String.valueOf(parentId)}, null);
 766             } catch (RemoteException e) {
 767                 Log_OC.e(TAG, e.getMessage());
 768                 return ret;
 769             }
 770         } else {
 771             c = getContentResolver().query(req_uri, null,
 772                     ProviderTableMeta.FILE_PARENT + "=?" ,
 773                     new String[] { String.valueOf(parentId)}, null);
 774         }
 775
 776         if (c.moveToFirst()) {
 777             do {
 778                 OCFile child = createFileInstance(c);
 779                 ret.add(child);
 780             } while (c.moveToNext());
 781         }
 782
 783         c.close();
 784
 785         Collections.sort(ret);
 786
 787         return ret;
 788     }
 789
 790
 791     private OCFile createRootDir() {
 792         OCFile file = new OCFile(OCFile.ROOT_PATH);
 793         file.setMimetype("DIR");
 794         file.setParentId(FileDataStorageManager.ROOT_PARENT_ID);
 795         saveFile(file);
 796         return file;
 797     }
 798
 799     private boolean fileExists(String cmp_key, String value) {
 800         Cursor c;
 801         if (getContentResolver() != null) {
 802             c = getContentResolver()
 803                     .query(ProviderTableMeta.CONTENT_URI,
 804                             null,
 805                             cmp_key + "=? AND "
 806                                     + ProviderTableMeta.FILE_ACCOUNT_OWNER
 807                                     + "=?",
 808                                     new String[] { value, mAccount.name }, null);
 809         } else {
 810             try {
 811                 c = getContentProviderClient().query(
 812                         ProviderTableMeta.CONTENT_URI,
 813                         null,
 814                         cmp_key + "=? AND "
 815                                 + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?",
 816                                 new String[] { value, mAccount.name }, null);
 817             } catch (RemoteException e) {
 818                 Log_OC.e(TAG,
 819                         "Couldn't determine file existance, assuming non existance: "
 820                                 + e.getMessage());
 821                 return false;
 822             }
 823         }
 824         boolean retval = c.moveToFirst();
 825         c.close();
 826         return retval;
 827     }
 828
 829     private Cursor getCursorForValue(String key, String value) {
 830         Cursor c = null;
 831         if (getContentResolver() != null) {
 832             c = getContentResolver()
 833                     .query(ProviderTableMeta.CONTENT_URI,
 834                             null,
 835                             key + "=? AND "
 836                                     + ProviderTableMeta.FILE_ACCOUNT_OWNER
 837                                     + "=?",
 838                                     new String[] { value, mAccount.name }, null);
 839         } else {
 840             try {
 841                 c = getContentProviderClient().query(
 842                         ProviderTableMeta.CONTENT_URI,
 843                         null,
 844                         key + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER
 845                         + "=?", new String[] { value, mAccount.name },
 846                         null);
 847             } catch (RemoteException e) {
 848                 Log_OC.e(TAG, "Could not get file details: " + e.getMessage());
 849                 c = null;
 850             }
 851         }
 852         return c;
 853     }
 854
 855
 856     private OCFile createFileInstance(Cursor c) {
 857         OCFile file = null;
 858         if (c != null) {
 859             file = new OCFile(c.getString(c
 860                     .getColumnIndex(ProviderTableMeta.FILE_PATH)));
 861             file.setFileId(c.getLong(c.getColumnIndex(ProviderTableMeta._ID)));
 862             file.setParentId(c.getLong(c
 863                     .getColumnIndex(ProviderTableMeta.FILE_PARENT)));
 864             file.setMimetype(c.getString(c
 865                     .getColumnIndex(ProviderTableMeta.FILE_CONTENT_TYPE)));
 866             if (!file.isFolder()) {
 867                 file.setStoragePath(c.getString(c
 868                         .getColumnIndex(ProviderTableMeta.FILE_STORAGE_PATH)));
 869                 if (file.getStoragePath() == null) {
 870                     // try to find existing file and bind it with current account; - with the current update of SynchronizeFolderOperation, this won't be necessary anymore after a full synchronization of the account
 871                     File f = new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, file));
 872                     if (f.exists()) {
 873                         file.setStoragePath(f.getAbsolutePath());
 874                         file.setLastSyncDateForData(f.lastModified());
 875                     }
 876                 }
 877             }
 878             file.setFileLength(c.getLong(c
 879                     .getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH)));
 880             file.setCreationTimestamp(c.getLong(c
 881                     .getColumnIndex(ProviderTableMeta.FILE_CREATION)));
 882             file.setModificationTimestamp(c.getLong(c
 883                     .getColumnIndex(ProviderTableMeta.FILE_MODIFIED)));
 884             file.setModificationTimestampAtLastSyncForData(c.getLong(c
 885                     .getColumnIndex(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA)));
 886             file.setLastSyncDateForProperties(c.getLong(c
 887                     .getColumnIndex(ProviderTableMeta.FILE_LAST_SYNC_DATE)));
 888             file.setLastSyncDateForData(c.getLong(c.
 889                     getColumnIndex(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA)));
 890             file.setKeepInSync(c.getInt(
 891                     c.getColumnIndex(ProviderTableMeta.FILE_KEEP_IN_SYNC)) == 1 ? true : false);
 892             file.setEtag(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_ETAG)));
 893             file.setShareByLink(c.getInt(
 894                     c.getColumnIndex(ProviderTableMeta.FILE_SHARE_BY_LINK)) == 1 ? true : false);
 895             file.setPublicLink(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PUBLIC_LINK)));
 896             file.setPermissions(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PERMISSIONS)));
 897             file.setRemoteId(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_REMOTE_ID)));
 898
 899         }
 900         return file;
 901     }
 902
 903     /**
 904      * Returns if the file/folder is shared by link or not
 905      * @param path  Path of the file/folder
 906      * @return
 907      */
 908     public boolean isShareByLink(String path) {
 909         Cursor c = getCursorForValue(ProviderTableMeta.FILE_STORAGE_PATH, path);
 910         OCFile file = null;
 911         if (c.moveToFirst()) {
 912             file = createFileInstance(c);
 913         }
 914         c.close();
 915         return file.isShareByLink();
 916     }
 917
 918     /**
 919      * Returns the public link of the file/folder
 920      * @param path  Path of the file/folder
 921      * @return
 922      */
 923     public String getPublicLink(String path) {
 924         Cursor c = getCursorForValue(ProviderTableMeta.FILE_STORAGE_PATH, path);
 925         OCFile file = null;
 926         if (c.moveToFirst()) {
 927             file = createFileInstance(c);
 928         }
 929         c.close();
 930         return file.getPublicLink();
 931     }
 932
 933
 934     // Methods for Shares
 935     public boolean saveShare(OCShare share) {
 936         boolean overriden = false;
 937         ContentValues cv = new ContentValues();
 938         cv.put(ProviderTableMeta.OCSHARES_FILE_SOURCE, share.getFileSource());
 939         cv.put(ProviderTableMeta.OCSHARES_ITEM_SOURCE, share.getItemSource());
 940         cv.put(ProviderTableMeta.OCSHARES_SHARE_TYPE, share.getShareType().getValue());
 941         cv.put(ProviderTableMeta.OCSHARES_SHARE_WITH, share.getShareWith());
 942         cv.put(ProviderTableMeta.OCSHARES_PATH, share.getPath());
 943         cv.put(ProviderTableMeta.OCSHARES_PERMISSIONS, share.getPermissions());
 944         cv.put(ProviderTableMeta.OCSHARES_SHARED_DATE, share.getSharedDate());
 945         cv.put(ProviderTableMeta.OCSHARES_EXPIRATION_DATE, share.getExpirationDate());
 946         cv.put(ProviderTableMeta.OCSHARES_TOKEN, share.getToken());
 947         cv.put(ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME, share.getSharedWithDisplayName());
 948         cv.put(ProviderTableMeta.OCSHARES_IS_DIRECTORY, share.isFolder() ? 1 : 0);
 949         cv.put(ProviderTableMeta.OCSHARES_USER_ID, share.getUserId());
 950         cv.put(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED, share.getIdRemoteShared());
 951         cv.put(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER, mAccount.name);
 952
 953         if (shareExists(share.getIdRemoteShared())) {           // for renamed files; no more delete and create
 954
 955             overriden = true;
 956             if (getContentResolver() != null) {
 957                 getContentResolver().update(ProviderTableMeta.CONTENT_URI_SHARE, cv,
 958                         ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + "=?",
 959                         new String[] { String.valueOf(share.getIdRemoteShared()) });
 960             } else {
 961                 try {
 962                     getContentProviderClient().update(ProviderTableMeta.CONTENT_URI_SHARE,
 963                             cv, ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + "=?",
 964                             new String[] { String.valueOf(share.getIdRemoteShared()) });
 965                 } catch (RemoteException e) {
 966                     Log_OC.e(TAG,
 967                             "Fail to insert insert file to database "
 968                                     + e.getMessage());
 969                 }
 970             }
 971         } else {
 972             Uri result_uri = null;
 973             if (getContentResolver() != null) {
 974                 result_uri = getContentResolver().insert(
 975                         ProviderTableMeta.CONTENT_URI_SHARE, cv);
 976             } else {
 977                 try {
 978                     result_uri = getContentProviderClient().insert(
 979                             ProviderTableMeta.CONTENT_URI_SHARE, cv);
 980                 } catch (RemoteException e) {
 981                     Log_OC.e(TAG,
 982                             "Fail to insert insert file to database "
 983                                     + e.getMessage());
 984                 }
 985             }
 986             if (result_uri != null) {
 987                 long new_id = Long.parseLong(result_uri.getPathSegments()
 988                         .get(1));
 989                 share.setId(new_id);
 990             }
 991         }
 992
 993         return overriden;
 994     }
 995
 996
 997     public OCShare getFirstShareByPathAndType(String path, ShareType type) {
 998         Cursor c = null;
 999         if (getContentResolver() != null) {
1000             c = getContentResolver().query(
1001                     ProviderTableMeta.CONTENT_URI_SHARE,
1002                     null,
1003                     ProviderTableMeta.OCSHARES_PATH + "=? AND "
1004                             + ProviderTableMeta.OCSHARES_SHARE_TYPE + "=? AND "
1005                             + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?",
1006                     new String[] { path, Integer.toString(type.getValue()), mAccount.name },
1007                     null);
1008         } else {
1009             try {
1010                 c = getContentProviderClient().query(
1011                         ProviderTableMeta.CONTENT_URI_SHARE,
1012                         null,
1013                         ProviderTableMeta.OCSHARES_PATH + "=? AND "
1014                                 + ProviderTableMeta.OCSHARES_SHARE_TYPE + "=? AND "
1015                                 + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?",
1016                         new String[] { path, Integer.toString(type.getValue()), mAccount.name },
1017                         null);
1018
1019             } catch (RemoteException e) {
1020                 Log_OC.e(TAG, "Could not get file details: " + e.getMessage());
1021                 c = null;
1022             }
1023         }
1024         OCShare share = null;
1025         if (c.moveToFirst()) {
1026             share = createShareInstance(c);
1027         }
1028         c.close();
1029         return share;
1030     }
1031
1032     private OCShare createShareInstance(Cursor c) {
1033         OCShare share = null;
1034         if (c != null) {
1035             share = new OCShare(c.getString(c
1036                     .getColumnIndex(ProviderTableMeta.OCSHARES_PATH)));
1037             share.setId(c.getLong(c.getColumnIndex(ProviderTableMeta._ID)));
1038             share.setFileSource(c.getLong(c
1039                     .getColumnIndex(ProviderTableMeta.OCSHARES_ITEM_SOURCE)));
1040             share.setShareType(ShareType.fromValue(c.getInt(c
1041                     .getColumnIndex(ProviderTableMeta.OCSHARES_SHARE_TYPE))));
1042             share.setPermissions(c.getInt(c
1043                     .getColumnIndex(ProviderTableMeta.OCSHARES_PERMISSIONS)));
1044             share.setSharedDate(c.getLong(c
1045                     .getColumnIndex(ProviderTableMeta.OCSHARES_SHARED_DATE)));
1046             share.setExpirationDate(c.getLong(c
1047                     .getColumnIndex(ProviderTableMeta.OCSHARES_EXPIRATION_DATE)));
1048             share.setToken(c.getString(c
1049                     .getColumnIndex(ProviderTableMeta.OCSHARES_TOKEN)));
1050             share.setSharedWithDisplayName(c.getString(c
1051                     .getColumnIndex(ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME)));
1052             share.setIsFolder(c.getInt(
1053                     c.getColumnIndex(ProviderTableMeta.OCSHARES_IS_DIRECTORY)) == 1 ? true : false);
1054             share.setUserId(c.getLong(c.getColumnIndex(ProviderTableMeta.OCSHARES_USER_ID)));
1055             share.setIdRemoteShared(c.getLong(c.getColumnIndex(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED)));
1056
1057         }
1058         return share;
1059     }
1060
1061     private boolean shareExists(String cmp_key, String value) {
1062         Cursor c;
1063         if (getContentResolver() != null) {
1064             c = getContentResolver()
1065                     .query(ProviderTableMeta.CONTENT_URI_SHARE,
1066                             null,
1067                             cmp_key + "=? AND "
1068                                     + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER
1069                                     + "=?",
1070                                     new String[] { value, mAccount.name }, null);
1071         } else {
1072             try {
1073                 c = getContentProviderClient().query(
1074                         ProviderTableMeta.CONTENT_URI_SHARE,
1075                         null,
1076                         cmp_key + "=? AND "
1077                                 + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?",
1078                                 new String[] { value, mAccount.name }, null);
1079             } catch (RemoteException e) {
1080                 Log_OC.e(TAG,
1081                         "Couldn't determine file existance, assuming non existance: "
1082                                 + e.getMessage());
1083                 return false;
1084             }
1085         }
1086         boolean retval = c.moveToFirst();
1087         c.close();
1088         return retval;
1089     }
1090
1091     private boolean shareExists(long remoteId) {
1092         return shareExists(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED, String.valueOf(remoteId));
1093     }
1094
1095     private void cleanSharedFiles() {
1096         ContentValues cv = new ContentValues();
1097         cv.put(ProviderTableMeta.FILE_SHARE_BY_LINK, false);
1098         cv.put(ProviderTableMeta.FILE_PUBLIC_LINK, "");
1099         String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
1100         String [] whereArgs = new String[]{mAccount.name};
1101
1102         if (getContentResolver() != null) {
1103             getContentResolver().update(ProviderTableMeta.CONTENT_URI, cv, where, whereArgs);
1104
1105         } else {
1106             try {
1107                 getContentProviderClient().update(ProviderTableMeta.CONTENT_URI, cv, where, whereArgs);
1108
1109             } catch (RemoteException e) {
1110                 Log_OC.e(TAG, "Exception in cleanSharedFiles" + e.getMessage());
1111             }
1112         }
1113     }
1114
1115     private void cleanSharedFilesInFolder(OCFile folder) {
1116         ContentValues cv = new ContentValues();
1117         cv.put(ProviderTableMeta.FILE_SHARE_BY_LINK, false);
1118         cv.put(ProviderTableMeta.FILE_PUBLIC_LINK, "");
1119         String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=? AND " + ProviderTableMeta.FILE_PARENT + "=?";
1120         String [] whereArgs = new String[] { mAccount.name , String.valueOf(folder.getFileId()) };
1121
1122         if (getContentResolver() != null) {
1123             getContentResolver().update(ProviderTableMeta.CONTENT_URI, cv, where, whereArgs);
1124
1125         } else {
1126             try {
1127                 getContentProviderClient().update(ProviderTableMeta.CONTENT_URI, cv, where, whereArgs);
1128
1129             } catch (RemoteException e) {
1130                 Log_OC.e(TAG, "Exception in cleanSharedFilesInFolder " + e.getMessage());
1131             }
1132         }
1133     }
1134
1135     private void cleanShares() {
1136         String where = ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?";
1137         String [] whereArgs = new String[]{mAccount.name};
1138
1139         if (getContentResolver() != null) {
1140             getContentResolver().delete(ProviderTableMeta.CONTENT_URI_SHARE, where, whereArgs);
1141
1142         } else {
1143             try {
1144                 getContentProviderClient().delete(ProviderTableMeta.CONTENT_URI_SHARE, where, whereArgs);
1145
1146             } catch (RemoteException e) {
1147                 Log_OC.e(TAG, "Exception in cleanShares" + e.getMessage());
1148             }
1149         }
1150     }
1151
1152     public void saveShares(Collection<OCShare> shares) {
1153         cleanShares();
1154         if (shares != null) {
1155             ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(shares.size());
1156
1157             // prepare operations to insert or update files to save in the given folder
1158             for (OCShare share : shares) {
1159                 ContentValues cv = new ContentValues();
1160                 cv.put(ProviderTableMeta.OCSHARES_FILE_SOURCE, share.getFileSource());
1161                 cv.put(ProviderTableMeta.OCSHARES_ITEM_SOURCE, share.getItemSource());
1162                 cv.put(ProviderTableMeta.OCSHARES_SHARE_TYPE, share.getShareType().getValue());
1163                 cv.put(ProviderTableMeta.OCSHARES_SHARE_WITH, share.getShareWith());
1164                 cv.put(ProviderTableMeta.OCSHARES_PATH, share.getPath());
1165                 cv.put(ProviderTableMeta.OCSHARES_PERMISSIONS, share.getPermissions());
1166                 cv.put(ProviderTableMeta.OCSHARES_SHARED_DATE, share.getSharedDate());
1167                 cv.put(ProviderTableMeta.OCSHARES_EXPIRATION_DATE, share.getExpirationDate());
1168                 cv.put(ProviderTableMeta.OCSHARES_TOKEN, share.getToken());
1169                 cv.put(ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME, share.getSharedWithDisplayName());
1170                 cv.put(ProviderTableMeta.OCSHARES_IS_DIRECTORY, share.isFolder() ? 1 : 0);
1171                 cv.put(ProviderTableMeta.OCSHARES_USER_ID, share.getUserId());
1172                 cv.put(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED, share.getIdRemoteShared());
1173                 cv.put(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER, mAccount.name);
1174
1175                 if (shareExists(share.getIdRemoteShared())) {
1176                     // updating an existing file
1177                     operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI_SHARE).
1178                             withValues(cv).
1179                             withSelection(  ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + "=?",
1180                                     new String[] { String.valueOf(share.getIdRemoteShared()) })
1181                                     .build());
1182
1183                 } else {
1184                     // adding a new file
1185                     operations.add(ContentProviderOperation.newInsert(ProviderTableMeta.CONTENT_URI_SHARE).withValues(cv).build());
1186                 }
1187             }
1188
1189             // apply operations in batch
1190             if (operations.size() > 0) {
1191                 @SuppressWarnings("unused")
1192                 ContentProviderResult[] results = null;
1193                 Log_OC.d(TAG, "Sending " + operations.size() + " operations to FileContentProvider");
1194                 try {
1195                     if (getContentResolver() != null) {
1196                         results = getContentResolver().applyBatch(MainApp.getAuthority(), operations);
1197
1198                     } else {
1199                         results = getContentProviderClient().applyBatch(operations);
1200                     }
1201
1202                 } catch (OperationApplicationException e) {
1203                     Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
1204
1205                 } catch (RemoteException e) {
1206                     Log_OC.e(TAG, "Exception in batch of operations  " + e.getMessage());
1207                 }
1208             }
1209         }
1210
1211     }
1212
1213     public void updateSharedFiles(Collection<OCFile> sharedFiles) {
1214         cleanSharedFiles();
1215
1216         if (sharedFiles != null) {
1217             ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(sharedFiles.size());
1218
1219             // prepare operations to insert or update files to save in the given folder
1220             for (OCFile file : sharedFiles) {
1221                 ContentValues cv = new ContentValues();
1222                 cv.put(ProviderTableMeta.FILE_MODIFIED, file.getModificationTimestamp());
1223                 cv.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA, file.getModificationTimestampAtLastSyncForData());
1224                 cv.put(ProviderTableMeta.FILE_CREATION, file.getCreationTimestamp());
1225                 cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, file.getFileLength());
1226                 cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, file.getMimetype());
1227                 cv.put(ProviderTableMeta.FILE_NAME, file.getFileName());
1228                 cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
1229                 cv.put(ProviderTableMeta.FILE_PATH, file.getRemotePath());
1230                 if (!file.isFolder()) {
1231                     cv.put(ProviderTableMeta.FILE_STORAGE_PATH, file.getStoragePath());
1232                 }
1233                 cv.put(ProviderTableMeta.FILE_ACCOUNT_OWNER, mAccount.name);
1234                 cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, file.getLastSyncDateForProperties());
1235                 cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, file.getLastSyncDateForData());
1236                 cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, file.keepInSync() ? 1 : 0);
1237                 cv.put(ProviderTableMeta.FILE_ETAG, file.getEtag());
1238                 cv.put(ProviderTableMeta.FILE_SHARE_BY_LINK, file.isShareByLink() ? 1 : 0);
1239                 cv.put(ProviderTableMeta.FILE_PUBLIC_LINK, file.getPublicLink());
1240                 cv.put(ProviderTableMeta.FILE_PERMISSIONS, file.getPermissions());
1241                 cv.put(ProviderTableMeta.FILE_REMOTE_ID, file.getRemoteId());
1242
1243                 boolean existsByPath = fileExists(file.getRemotePath());
1244                 if (existsByPath || fileExists(file.getFileId())) {
1245                     // updating an existing file
1246                     operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
1247                             withValues(cv).
1248                             withSelection(  ProviderTableMeta._ID + "=?",
1249                                     new String[] { String.valueOf(file.getFileId()) })
1250                                     .build());
1251
1252                 } else {
1253                     // adding a new file
1254                     operations.add(ContentProviderOperation.newInsert(ProviderTableMeta.CONTENT_URI).withValues(cv).build());
1255                 }
1256             }
1257
1258             // apply operations in batch
1259             if (operations.size() > 0) {
1260                 @SuppressWarnings("unused")
1261                 ContentProviderResult[] results = null;
1262                 Log_OC.d(TAG, "Sending " + operations.size() + " operations to FileContentProvider");
1263                 try {
1264                     if (getContentResolver() != null) {
1265                         results = getContentResolver().applyBatch(MainApp.getAuthority(), operations);
1266
1267                     } else {
1268                         results = getContentProviderClient().applyBatch(operations);
1269                     }
1270
1271                 } catch (OperationApplicationException e) {
1272                     Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
1273
1274                 } catch (RemoteException e) {
1275                     Log_OC.e(TAG, "Exception in batch of operations  " + e.getMessage());
1276                 }
1277             }
1278         }
1279
1280     }
1281
1282     public void removeShare(OCShare share){
1283         Uri share_uri = ProviderTableMeta.CONTENT_URI_SHARE;
1284         String where = ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
1285         String [] whereArgs = new String[]{mAccount.name, share.getPath()};
1286         if (getContentProviderClient() != null) {
1287             try {
1288                 getContentProviderClient().delete(share_uri, where, whereArgs);
1289             } catch (RemoteException e) {
1290                 e.printStackTrace();
1291             }
1292         } else {
1293             getContentResolver().delete(share_uri, where, whereArgs);
1294         }
1295     }
1296
1297     public void saveSharesDB(ArrayList<OCShare> shares) {
1298         saveShares(shares);
1299
1300         ArrayList<OCFile> sharedFiles = new ArrayList<OCFile>();
1301
1302         for (OCShare share : shares) {
1303             // Get the path
1304             String path = share.getPath();
1305             if (share.isFolder()) {
1306                 path = path + FileUtils.PATH_SEPARATOR;
1307             }
1308
1309             // Update OCFile with data from share: ShareByLink  ¿and publicLink?
1310             OCFile file = getFileByPath(path);
1311             if (file != null) {
1312                 if (share.getShareType().equals(ShareType.PUBLIC_LINK)) {
1313                     file.setShareByLink(true);
1314                     sharedFiles.add(file);
1315                 }
1316             }
1317         }
1318
1319         updateSharedFiles(sharedFiles);
1320     }
1321
1322
1323     public void saveSharesInFolder(ArrayList<OCShare> shares, OCFile folder) {
1324         cleanSharedFilesInFolder(folder);
1325         ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>();
1326         operations = prepareRemoveSharesInFolder(folder, operations);
1327
1328         if (shares != null) {
1329             // prepare operations to insert or update files to save in the given folder
1330             for (OCShare share : shares) {
1331                 ContentValues cv = new ContentValues();
1332                 cv.put(ProviderTableMeta.OCSHARES_FILE_SOURCE, share.getFileSource());
1333                 cv.put(ProviderTableMeta.OCSHARES_ITEM_SOURCE, share.getItemSource());
1334                 cv.put(ProviderTableMeta.OCSHARES_SHARE_TYPE, share.getShareType().getValue());
1335                 cv.put(ProviderTableMeta.OCSHARES_SHARE_WITH, share.getShareWith());
1336                 cv.put(ProviderTableMeta.OCSHARES_PATH, share.getPath());
1337                 cv.put(ProviderTableMeta.OCSHARES_PERMISSIONS, share.getPermissions());
1338                 cv.put(ProviderTableMeta.OCSHARES_SHARED_DATE, share.getSharedDate());
1339                 cv.put(ProviderTableMeta.OCSHARES_EXPIRATION_DATE, share.getExpirationDate());
1340                 cv.put(ProviderTableMeta.OCSHARES_TOKEN, share.getToken());
1341                 cv.put(ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME, share.getSharedWithDisplayName());
1342                 cv.put(ProviderTableMeta.OCSHARES_IS_DIRECTORY, share.isFolder() ? 1 : 0);
1343                 cv.put(ProviderTableMeta.OCSHARES_USER_ID, share.getUserId());
1344                 cv.put(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED, share.getIdRemoteShared());
1345                 cv.put(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER, mAccount.name);
1346
1347                 /*
1348                 if (shareExists(share.getIdRemoteShared())) {
1349                     // updating an existing share resource
1350                     operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI_SHARE).
1351                             withValues(cv).
1352                             withSelection(  ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + "=?",
1353                                     new String[] { String.valueOf(share.getIdRemoteShared()) })
1354                                     .build());
1355
1356                 } else {
1357                 */
1358                 // adding a new share resource
1359                 operations.add(ContentProviderOperation.newInsert(ProviderTableMeta.CONTENT_URI_SHARE).withValues(cv).build());
1360                 //}
1361             }
1362         }
1363
1364         // apply operations in batch
1365         if (operations.size() > 0) {
1366             @SuppressWarnings("unused")
1367             ContentProviderResult[] results = null;
1368             Log_OC.d(TAG, "Sending " + operations.size() + " operations to FileContentProvider");
1369             try {
1370                 if (getContentResolver() != null) {
1371                     results = getContentResolver().applyBatch(MainApp.getAuthority(), operations);
1372
1373                 } else {
1374                     results = getContentProviderClient().applyBatch(operations);
1375                 }
1376
1377             } catch (OperationApplicationException e) {
1378                 Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
1379
1380             } catch (RemoteException e) {
1381                 Log_OC.e(TAG, "Exception in batch of operations  " + e.getMessage());
1382             }
1383         }
1384         //}
1385
1386     }
1387
1388     private ArrayList<ContentProviderOperation> prepareRemoveSharesInFolder(OCFile folder, ArrayList<ContentProviderOperation> preparedOperations) {
1389         if (folder != null) {
1390             String where = ProviderTableMeta.OCSHARES_PATH + "=?" + " AND " + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?";
1391             String [] whereArgs = new String[]{ "", mAccount.name };
1392
1393             Vector<OCFile> files = getFolderContent(folder);
1394
1395             for (OCFile file : files) {
1396                 whereArgs[0] = file.getRemotePath();
1397                 preparedOperations.add(ContentProviderOperation.newDelete(ProviderTableMeta.CONTENT_URI_SHARE)
1398                         .withSelection(where, whereArgs)
1399                         .build());
1400             }
1401         }
1402         return preparedOperations;
1403
1404         /*
1405         if (operations.size() > 0) {
1406             try {
1407                 if (getContentResolver() != null) {
1408                     getContentResolver().applyBatch(MainApp.getAuthority(), operations);
1409
1410                 } else {
1411                     getContentProviderClient().applyBatch(operations);
1412                 }
1413
1414             } catch (OperationApplicationException e) {
1415                 Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
1416
1417             } catch (RemoteException e) {
1418                 Log_OC.e(TAG, "Exception in batch of operations  " + e.getMessage());
1419             }
1420         }
1421         */
1422
1423             /*
1424             if (getContentResolver() != null) {
1425
1426                 getContentResolver().delete(ProviderTableMeta.CONTENT_URI_SHARE,
1427                                             where,
1428                                             whereArgs);
1429             } else {
1430                 try {
1431                     getContentProviderClient().delete(  ProviderTableMeta.CONTENT_URI_SHARE,
1432                                                         where,
1433                                                         whereArgs);
1434
1435                 } catch (RemoteException e) {
1436                     Log_OC.e(TAG, "Exception deleting shares in a folder " + e.getMessage());
1437                 }
1438             }
1439             */
1440         //}
1441     }
1442
1443 }