Split off of #5150

Signed-off-by: tobiasKaminsky <tobias@kaminsky.me>

src/androidTest/java/com/owncloud/android/datamodel/FileDataStorageManagerContentProviderClientTest.java

@@ -0,0 +1,37 @@
+/*
+ *
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2020 Tobias Kaminsky
+ * Copyright (C) 2020 Nextcloud GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.datamodel;
+
+import com.owncloud.android.db.ProviderMeta;
+
+public class FileDataStorageManagerContentProviderClientTest extends FileDataStorageManagerTest {
+
+    @Override
+    public void before() {
+        sut = new FileDataStorageManager(account,
+                                         targetContext
+                                             .getContentResolver()
+                                             .acquireContentProviderClient(ProviderMeta.ProviderTableMeta.CONTENT_URI)
+        );
+    }
+}

src/androidTest/java/com/owncloud/android/datamodel/FileDataStorageManagerContentResolverTest.java

@@ -0,0 +1,30 @@
+/*
+ *
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2020 Tobias Kaminsky
+ * Copyright (C) 2020 Nextcloud GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.datamodel;
+
+public class FileDataStorageManagerContentResolverTest extends FileDataStorageManagerTest {
+    @Override
+    public void before() {
+        sut = new FileDataStorageManager(account, targetContext.getContentResolver());
+    }
+}

src/androidTest/java/com/owncloud/android/datamodel/FileDataStorageManagerTest.java

@@ -0,0 +1,244 @@
+/*
+ *
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2020 Tobias Kaminsky
+ * Copyright (C) 2020 Nextcloud GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.datamodel;
+
+import android.content.ContentValues;
+
+import com.owncloud.android.AbstractIT;
+import com.owncloud.android.db.ProviderMeta;
+import com.owncloud.android.lib.common.operations.RemoteOperationResult;
+import com.owncloud.android.lib.resources.files.CreateFolderRemoteOperation;
+import com.owncloud.android.lib.resources.files.SearchRemoteOperation;
+import com.owncloud.android.lib.resources.files.UploadFileRemoteOperation;
+import com.owncloud.android.lib.resources.files.model.RemoteFile;
+import com.owncloud.android.operations.RefreshFolderOperation;
+import com.owncloud.android.utils.FileStorageUtils;
+
+import junit.framework.TestCase;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.owncloud.android.lib.resources.files.SearchRemoteOperation.SearchType.PHOTO_SEARCH;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+abstract public class FileDataStorageManagerTest extends AbstractIT {
+
+    protected FileDataStorageManager sut;
+
+    @Before
+    abstract public void before();
+
+    @After
+    public void after() {
+        super.after();
+
+        sut.deleteAllFiles();
+        sut.deleteVirtuals(VirtualFolderType.PHOTOS);
+    }
+
+    @Test
+    public void simpleTest() {
+        assertTrue(sut.getFileByPath("/").fileExists());
+        assertNull(sut.getFileByPath("/123123"));
+    }
+
+    @Test
+    public void getAllFiles_NoAvailable() {
+        assertEquals(0, sut.getAllFiles().size());
+    }
+
+    @Test
+    public void testFolderContent() throws IOException {
+        assertEquals(0, sut.getAllFiles().size());
+        assertTrue(new CreateFolderRemoteOperation("/1/1/", true).execute(client).isSuccess());
+
+        assertTrue(new CreateFolderRemoteOperation("/1/2/", true).execute(client).isSuccess());
+
+        assertTrue(new UploadFileRemoteOperation(FileStorageUtils.getSavePath(account.name) + "/chunkedFile.txt",
+                                                 "/1/1/chunkedFile.txt",
+                                                 "text/plain",
+                                                 String.valueOf(System.currentTimeMillis() / 1000))
+                       .execute(client).isSuccess());
+
+        assertTrue(new UploadFileRemoteOperation(FileStorageUtils.getSavePath(account.name) + "/chunkedFile.txt",
+                                                 "/1/1/chunkedFile2.txt",
+                                                 "text/plain",
+                                                 String.valueOf(System.currentTimeMillis() / 1000))
+                       .execute(client).isSuccess());
+
+        File imageFile = getFile("imageFile.png");
+        assertTrue(new UploadFileRemoteOperation(imageFile.getAbsolutePath(),
+                                                 "/1/1/imageFile.png",
+                                                 "image/png",
+                                                 String.valueOf(System.currentTimeMillis() / 1000))
+                       .execute(client).isSuccess());
+
+        // sync
+        assertNull(sut.getFileByPath("/1/1/"));
+
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/1/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/1/1/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+        assertEquals(3, sut.getFolderContent(sut.getFileByPath("/1/1/"), false).size());
+    }
+
+    /**
+     * This test creates an image, does a photo search (now returned image is not yet in file hierarchy), then root
+     * folder is refreshed and it is verified that the same image file is used in database
+     */
+    @Test
+    public void testPhotoSearch() throws IOException {
+        String remotePath = "/imageFile.png";
+        VirtualFolderType virtualType = VirtualFolderType.PHOTOS;
+
+        assertEquals(0, sut.getFolderContent(sut.getFileByPath("/"), false).size());
+        assertEquals(1, sut.getAllFiles().size());
+
+        File imageFile = getFile("imageFile.png");
+        assertTrue(new UploadFileRemoteOperation(imageFile.getAbsolutePath(),
+                                                 remotePath,
+                                                 "image/png",
+                                                 String.valueOf(System.currentTimeMillis() / 1000))
+                       .execute(client).isSuccess());
+
+        assertNull(sut.getFileByPath(remotePath));
+
+        // search
+        SearchRemoteOperation searchRemoteOperation = new SearchRemoteOperation("image/%",
+                                                                                PHOTO_SEARCH,
+                                                                                false);
+
+        RemoteOperationResult searchResult = searchRemoteOperation.execute(client);
+        TestCase.assertTrue(searchResult.isSuccess());
+        TestCase.assertEquals(1, searchResult.getData().size());
+
+        OCFile ocFile = FileStorageUtils.fillOCFile((RemoteFile) searchResult.getData().get(0));
+        sut.saveFile(ocFile);
+
+        List<ContentValues> contentValues = new ArrayList<>();
+        ContentValues cv = new ContentValues();
+        cv.put(ProviderMeta.ProviderTableMeta.VIRTUAL_TYPE, virtualType.toString());
+        cv.put(ProviderMeta.ProviderTableMeta.VIRTUAL_OCFILE_ID, ocFile.getFileId());
+
+        contentValues.add(cv);
+
+        sut.saveVirtuals(contentValues);
+
+        assertEquals(remotePath, ocFile.getRemotePath());
+
+        assertEquals(0, sut.getFolderContent(sut.getFileByPath("/"), false).size());
+
+        assertEquals(1, sut.getVirtualFolderContent(virtualType, false).size());
+        assertEquals(2, sut.getAllFiles().size());
+
+        // update root
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+
+        assertEquals(1, sut.getFolderContent(sut.getFileByPath("/"), false).size());
+        assertEquals(1, sut.getVirtualFolderContent(virtualType, false).size());
+        assertEquals(2, sut.getAllFiles().size());
+
+        assertEquals(sut.getVirtualFolderContent(virtualType, false).get(0),
+                     sut.getFolderContent(sut.getFileByPath("/"), false).get(0));
+    }
+
+    @Test
+    public void testSaveNewFile() {
+        assertTrue(new CreateFolderRemoteOperation("/1/1/", true).execute(client).isSuccess());
+
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/1/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+        assertTrue(new RefreshFolderOperation(sut.getFileByPath("/1/1/"),
+                                              System.currentTimeMillis() / 1000,
+                                              false,
+                                              false,
+                                              sut,
+                                              account,
+                                              targetContext).execute(client).isSuccess());
+
+        OCFile newFile = new OCFile("/1/1/1.txt");
+        newFile.setRemoteId("123");
+
+        sut.saveNewFile(newFile);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testSaveNewFile_NonexistingParent() {
+        assertTrue(new CreateFolderRemoteOperation("/1/1/", true).execute(client).isSuccess());
+
+        OCFile newFile = new OCFile("/1/1/1.txt");
+
+        sut.saveNewFile(newFile);
+    }
+}

src/main/java/com/owncloud/android/operations/RefreshFolderOperation.java

@@ -438,20 +438,21 @@ public class RefreshFolderOperation extends RemoteOperation {
         OCFile remoteFile;
         OCFile localFile;
         OCFile updatedFile;
-        RemoteFile r;
+        RemoteFile remote;
 
         for (int i = 1; i < folderAndFiles.size(); i++) {
             /// new OCFile instance with the data from the server
-            r = (RemoteFile) folderAndFiles.get(i);
-            remoteFile = FileStorageUtils.fillOCFile(r);
+            remote = (RemoteFile) folderAndFiles.get(i);
+            remoteFile = FileStorageUtils.fillOCFile(remote);
 
             // new OCFile instance to merge fresh data from server with local state
-            updatedFile = FileStorageUtils.fillOCFile(r);
+            updatedFile = FileStorageUtils.fillOCFile(remote);
             updatedFile.setParentId(mLocalFolder.getFileId());
 
             // retrieve local data for the read file
             localFile = localFilesMap.remove(remoteFile.getRemotePath());
 
+            // TODO better implementation is needed
             if (localFile == null) {
                 localFile = mStorageManager.getFileByPath(updatedFile.getRemotePath());
             }

src/main/java/com/owncloud/android/operations/SynchronizeFolderOperation.java

@@ -43,6 +43,7 @@ import com.owncloud.android.utils.FileStorageUtils;
 import com.owncloud.android.utils.MimeTypeUtil;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -261,7 +262,7 @@ public class SynchronizeFolderOperation extends SyncOperation {
         }
 
         FileDataStorageManager storageManager = getStorageManager();
-        List<OCFile> updatedFiles = new Vector<>(folderAndFiles.size() - 1);
+        List<OCFile> updatedFiles = new ArrayList<>(folderAndFiles.size() - 1);
 
         // get current data about local contents of the folder to synchronize
         List<OCFile> localFiles = storageManager.getFolderContent(mLocalFolder, false);

src/main/java/com/owncloud/android/providers/FileContentProvider.java

@@ -265,14 +265,16 @@ public class FileContentProvider extends ContentProvider {
         switch (mUriMatcher.match(uri)) {
             case ROOT_DIRECTORY:
             case SINGLE_FILE:
-                String remotePath = values.getAsString(ProviderTableMeta.FILE_PATH);
-                String accountName = values.getAsString(ProviderTableMeta.FILE_ACCOUNT_OWNER);
                 String[] projection = new String[]{
                     ProviderTableMeta._ID, ProviderTableMeta.FILE_PATH,
                     ProviderTableMeta.FILE_ACCOUNT_OWNER
                 };
                 String where = ProviderTableMeta.FILE_PATH + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
-                String[] whereArgs = new String[]{remotePath, accountName};
+
+                String remotePath = values.getAsString(ProviderTableMeta.FILE_PATH);
+                String accountName = values.getAsString(ProviderTableMeta.FILE_ACCOUNT_OWNER);
+                String[] whereArgs = {remotePath, accountName};
+
                 Cursor doubleCheck = query(db, uri, projection, where, whereArgs, null);
                 // ugly patch; serious refactorization is needed to reduce work in
                 // FileDataStorageManager and bring it to FileContentProvider
@@ -299,9 +301,9 @@ public class FileContentProvider extends ContentProvider {
 
             case SHARES:
                 Uri insertedShareUri;
-                long rowId = db.insert(ProviderTableMeta.OCSHARES_TABLE_NAME, null, values);
-                if (rowId > 0) {
-                    insertedShareUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_SHARE, rowId);
+                long idShares = db.insert(ProviderTableMeta.OCSHARES_TABLE_NAME, null, values);
+                if (idShares > 0) {
+                    insertedShareUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_SHARE, idShares);
                 } else {
                     throw new SQLException(ERROR + uri);
 
@@ -312,9 +314,9 @@ public class FileContentProvider extends ContentProvider {
 
             case CAPABILITIES:
                 Uri insertedCapUri;
-                long id = db.insert(ProviderTableMeta.CAPABILITIES_TABLE_NAME, null, values);
-                if (id > 0) {
-                    insertedCapUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_CAPABILITIES, id);
+                long idCapabilities = db.insert(ProviderTableMeta.CAPABILITIES_TABLE_NAME, null, values);
+                if (idCapabilities > 0) {
+                    insertedCapUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_CAPABILITIES, idCapabilities);
                 } else {
                     throw new SQLException(ERROR + uri);
                 }
@@ -663,16 +665,16 @@ public class FileContentProvider extends ContentProvider {
         ContentProviderResult[] results = new ContentProviderResult[operations.size()];
         int i = 0;
 
-        SQLiteDatabase db = mDbHelper.getWritableDatabase();
-        db.beginTransaction();  // it's supposed that transactions can be nested
+        SQLiteDatabase database = mDbHelper.getWritableDatabase();
+        database.beginTransaction();  // it's supposed that transactions can be nested
         try {
             for (ContentProviderOperation operation : operations) {
                 results[i] = operation.apply(this, results, i);
                 i++;
             }
-            db.setTransactionSuccessful();
+            database.setTransactionSuccessful();
         } finally {
-            db.endTransaction();
+            database.endTransaction();
         }
         Log_OC.d("FileContentProvider", "applied batch in provider " + this);
         return results;

src/main/java/com/owncloud/android/ui/adapter/OCFileListAdapter.java

@@ -1019,6 +1019,7 @@ public class OCFileListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHol
                 }
             }
         }
+
         mStorageManager.saveShares(shares);
     }
 
@@ -1091,7 +1092,7 @@ public class OCFileListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHol
         }
 
         preferences.setPhotoSearchTimestamp(System.currentTimeMillis());
-        mStorageManager.saveVirtuals(type, contentValues);
+        mStorageManager.saveVirtuals(contentValues);
     }
 
     public void showVirtuals(VirtualFolderType type, boolean onlyImages, FileDataStorageManager storageManager) {