make FolderMetadata access private and use getter/setter

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

src/main/java/com/owncloud/android/datamodel/DecryptedFolderMetadata.java

@@ -28,8 +28,8 @@ import java.util.HashMap;
  */
 
 public class DecryptedFolderMetadata {
-    public Metadata metadata;
-    public HashMap<String, DecryptedFile> files;
+    private Metadata metadata;
+    private HashMap<String, DecryptedFile> files;
 
     public DecryptedFolderMetadata() {
         this.metadata = new Metadata();
@@ -41,10 +41,50 @@ public class DecryptedFolderMetadata {
         this.files = files;
     }
 
+    public Metadata getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(Metadata metadata) {
+        this.metadata = metadata;
+    }
+
+    public HashMap<String, DecryptedFile> getFiles() {
+        return files;
+    }
+
+    public void setFiles(HashMap<String, DecryptedFile> files) {
+        this.files = files;
+    }
+
     public static class Metadata {
-        public HashMap<Integer, String> metadataKeys; // each keys is encrypted on its own, decrypt on use
-        public Sharing sharing;
-        public int version;
+        private HashMap<Integer, String> metadataKeys; // each keys is encrypted on its own, decrypt on use
+        private Sharing sharing;
+        private int version;
+
+        public HashMap<Integer, String> getMetadataKeys() {
+            return metadataKeys;
+        }
+
+        public void setMetadataKeys(HashMap<Integer, String> metadataKeys) {
+            this.metadataKeys = metadataKeys;
+        }
+
+        public Sharing getSharing() {
+            return sharing;
+        }
+
+        public void setSharing(Sharing sharing) {
+            this.sharing = sharing;
+        }
+
+        public int getVersion() {
+            return version;
+        }
+
+        public void setVersion(int version) {
+            this.version = version;
+        }
 
         @Override
         public String toString() {
@@ -53,25 +93,113 @@ public class DecryptedFolderMetadata {
     }
 
     public static class Encrypted {
-        public HashMap<Integer, String> metadataKeys;
+        private HashMap<Integer, String> metadataKeys;
+
+        public HashMap<Integer, String> getMetadataKeys() {
+            return metadataKeys;
+        }
+
+        public void setMetadataKeys(HashMap<Integer, String> metadataKeys) {
+            this.metadataKeys = metadataKeys;
+        }
     }
 
     public static class Sharing {
-        public HashMap<String, String> recipient;
-        public String signature;
+        private HashMap<String, String> recipient;
+        private String signature;
+
+        public HashMap<String, String> getRecipient() {
+            return recipient;
+        }
+
+        public void setRecipient(HashMap<String, String> recipient) {
+            this.recipient = recipient;
+        }
+
+        public String getSignature() {
+            return signature;
+        }
+
+        public void setSignature(String signature) {
+            this.signature = signature;
+        }
     }
 
     public static class DecryptedFile {
-        public Data encrypted;
-        public String initializationVector;
-        public String authenticationTag;
-        public int metadataKey;
+        private Data encrypted;
+        private String initializationVector;
+        private String authenticationTag;
+        private int metadataKey;
+
+        public Data getEncrypted() {
+            return encrypted;
+        }
+
+        public void setEncrypted(Data encrypted) {
+            this.encrypted = encrypted;
+        }
+
+        public String getInitializationVector() {
+            return initializationVector;
+        }
+
+        public void setInitializationVector(String initializationVector) {
+            this.initializationVector = initializationVector;
+        }
+
+        public String getAuthenticationTag() {
+            return authenticationTag;
+        }
+
+        public void setAuthenticationTag(String authenticationTag) {
+            this.authenticationTag = authenticationTag;
+        }
+
+        public int getMetadataKey() {
+            return metadataKey;
+        }
+
+        public void setMetadataKey(int metadataKey) {
+            this.metadataKey = metadataKey;
+        }
     }
 
     public static class Data {
-        public String key;
-        public String filename;
-        public String mimetype;
-        public int version;
+        private String key;
+        private String filename;
+        private String mimetype;
+        private int version;
+
+        public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            this.key = key;
+        }
+
+        public String getFilename() {
+            return filename;
+        }
+
+        public void setFilename(String filename) {
+            this.filename = filename;
+        }
+
+        public String getMimetype() {
+            return mimetype;
+        }
+
+        public void setMimetype(String mimetype) {
+            this.mimetype = mimetype;
+        }
+
+        public int getVersion() {
+            return version;
+        }
+
+        public void setVersion(int version) {
+            this.version = version;
+        }
     }
 }

src/main/java/com/owncloud/android/datamodel/EncryptedFolderMetadata.java

@@ -28,19 +28,67 @@ import java.util.HashMap;
  */
 
 public class EncryptedFolderMetadata {
-    public DecryptedFolderMetadata.Metadata metadata;
-    public HashMap<String, EncryptedFile> files;
-
+    private DecryptedFolderMetadata.Metadata metadata;
+    private HashMap<String, EncryptedFile> files;
+    
     public EncryptedFolderMetadata(DecryptedFolderMetadata.Metadata metadata, HashMap<String, EncryptedFile> files) {
         this.metadata = metadata;
         this.files = files;
     }
 
+    public DecryptedFolderMetadata.Metadata getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(DecryptedFolderMetadata.Metadata metadata) {
+        this.metadata = metadata;
+    }
+
+    public HashMap<String, EncryptedFile> getFiles() {
+        return files;
+    }
+
+    public void setFiles(HashMap<String, EncryptedFile> files) {
+        this.files = files;
+    }
+
     public static class EncryptedFile {
-        public String encrypted;
-        public String initializationVector;
-        public String authenticationTag;
-        public int metadataKey;
+        private String encrypted;
+        private String initializationVector;
+        private String authenticationTag;
+        private int metadataKey;
+
+        public String getEncrypted() {
+            return encrypted;
+        }
+
+        public void setEncrypted(String encrypted) {
+            this.encrypted = encrypted;
+        }
+
+        public String getInitializationVector() {
+            return initializationVector;
+        }
+
+        public void setInitializationVector(String initializationVector) {
+            this.initializationVector = initializationVector;
+        }
+
+        public String getAuthenticationTag() {
+            return authenticationTag;
+        }
+
+        public void setAuthenticationTag(String authenticationTag) {
+            this.authenticationTag = authenticationTag;
+        }
+
+        public int getMetadataKey() {
+            return metadataKey;
+        }
+
+        public void setMetadataKey(int metadataKey) {
+            this.metadataKey = metadataKey;
+        }
     }
 }
 

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

@@ -194,9 +194,12 @@ public class DownloadFileOperation extends RemoteOperation {
                 if (metadata == null) {
                     return new RemoteOperationResult(RemoteOperationResult.ResultCode.METADATA_NOT_FOUND);
                 }
-                byte[] key = EncryptionUtils.decodeStringToBase64Bytes(metadata.files.get(mFile.getEncryptedFileName()).encrypted.key);
-                byte[] iv = EncryptionUtils.decodeStringToBase64Bytes(metadata.files.get(mFile.getEncryptedFileName()).initializationVector);
-                byte[] authenticationTag = EncryptionUtils.decodeStringToBase64Bytes(metadata.files.get(mFile.getEncryptedFileName()).authenticationTag);
+                byte[] key = EncryptionUtils.decodeStringToBase64Bytes(metadata.getFiles()
+                        .get(mFile.getEncryptedFileName()).getEncrypted().getKey());
+                byte[] iv = EncryptionUtils.decodeStringToBase64Bytes(metadata.getFiles()
+                        .get(mFile.getEncryptedFileName()).getInitializationVector());
+                byte[] authenticationTag = EncryptionUtils.decodeStringToBase64Bytes(metadata.getFiles()
+                        .get(mFile.getEncryptedFileName()).getAuthenticationTag());
 
                 try {
                     byte[] decryptedBytes = EncryptionUtils.decryptFile(tmpFile, key, iv, authenticationTag);
@@ -205,7 +208,6 @@ public class DownloadFileOperation extends RemoteOperation {
                     fileOutputStream.write(decryptedBytes);
                     fileOutputStream.close();
                 } catch (Exception e) {
-                    // TODO TOBI better handling
                     return new RemoteOperationResult(e);
                 }
             }

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

@@ -455,8 +455,9 @@ public class RefreshFolderOperation extends RemoteOperation {
             if (metadata != null) {
                 updatedFile.setEncryptedFileName(updatedFile.getFileName());
                 try {
-                    String decryptedFileName = metadata.files.get(updatedFile.getFileName()).encrypted.filename;
-                    String mimetype = metadata.files.get(updatedFile.getFileName()).encrypted.mimetype;
+                    String decryptedFileName = metadata.getFiles().get(updatedFile.getFileName()).getEncrypted()
+                            .getFilename();
+                    String mimetype = metadata.getFiles().get(updatedFile.getFileName()).getEncrypted().getMimetype();
                     updatedFile.setFileName(decryptedFileName);
                     if (mimetype == null || mimetype.isEmpty()) {
                         updatedFile.setMimetype("application/octet-stream");

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

@@ -130,7 +130,7 @@ public class RemoveRemoteEncryptedFileOperation extends RemoteOperation {
             Log_OC.i(TAG, "Remove " + remotePath + ": " + result.getLogMessage());
 
             // remove file from metadata
-            metadata.files.remove(fileName);
+            metadata.getFiles().remove(fileName);
 
             EncryptedFolderMetadata encryptedFolderMetadata = EncryptionUtils.encryptFolderMetadata(metadata,
                     privateKey);

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

@@ -465,11 +465,11 @@ public class UploadFileOperation extends SyncOperation {
             } else if (getMetadataOperationResult.getHttpCode() == HttpStatus.SC_NOT_FOUND) {
                 // new metadata
                 metadata = new DecryptedFolderMetadata();
-                metadata.metadata = new DecryptedFolderMetadata.Metadata();
-                metadata.metadata.metadataKeys = new HashMap<>();
+                metadata.setMetadata(new DecryptedFolderMetadata.Metadata());
+                metadata.getMetadata().setMetadataKeys(new HashMap<>());
                 String metadataKey = EncryptionUtils.encodeBytesToBase64String(EncryptionUtils.generateKey());
                 String encryptedMetadataKey = EncryptionUtils.encryptStringAsymmetric(metadataKey, publicKey);
-                metadata.metadata.metadataKeys.put(0, encryptedMetadataKey);
+                metadata.getMetadata().getMetadataKeys().put(0, encryptedMetadataKey);
             } else {
                 // TODO error
                 throw new Exception("something wrong");
@@ -505,7 +505,7 @@ public class UploadFileOperation extends SyncOperation {
             // new random file name, check if it exists in metadata
             String encryptedFileName = UUID.randomUUID().toString().replaceAll("-", "");
 
-            while (metadata.files.get(encryptedFileName) != null) {
+            while (metadata.getFiles().get(encryptedFileName) != null) {
                 encryptedFileName = UUID.randomUUID().toString().replaceAll("-", "");
             }
 
@@ -643,15 +643,15 @@ public class UploadFileOperation extends SyncOperation {
                 // upload metadata
                 DecryptedFolderMetadata.DecryptedFile decryptedFile = new DecryptedFolderMetadata.DecryptedFile();
                 DecryptedFolderMetadata.Data data = new DecryptedFolderMetadata.Data();
-                data.filename = mFile.getFileName();
-                data.mimetype = mFile.getMimetype();
-                data.key = EncryptionUtils.encodeBytesToBase64String(key);
+                data.setFilename(mFile.getFileName());
+                data.setMimetype(mFile.getMimetype());
+                data.setKey(EncryptionUtils.encodeBytesToBase64String(key));
 
-                decryptedFile.encrypted = data;
-                decryptedFile.initializationVector = EncryptionUtils.encodeBytesToBase64String(iv);
-                decryptedFile.authenticationTag = encryptedFile.authenticationTag;
+                decryptedFile.setEncrypted(data);
+                decryptedFile.setInitializationVector(EncryptionUtils.encodeBytesToBase64String(iv));
+                decryptedFile.setAuthenticationTag(encryptedFile.authenticationTag);
 
-                metadata.files.put(encryptedFileName, decryptedFile);
+                metadata.getFiles().put(encryptedFileName, decryptedFile);
 
                 EncryptedFolderMetadata encryptedFolderMetadata = EncryptionUtils.encryptFolderMetadata(metadata,
                         privateKey);
@@ -1135,8 +1135,8 @@ public class UploadFileOperation extends SyncOperation {
         if (encrypted) {
             String fileName = new File(remotePath).getName();
 
-            for (DecryptedFolderMetadata.DecryptedFile file : metadata.files.values()) {
-                if (file.encrypted.filename.equalsIgnoreCase(fileName)) {
+            for (DecryptedFolderMetadata.DecryptedFile file : metadata.getFiles().values()) {
+                if (file.getEncrypted().getFilename().equalsIgnoreCase(fileName)) {
                     return true;
                 }
             }

src/main/java/com/owncloud/android/utils/EncryptionUtils.java

@@ -134,26 +134,27 @@ public class EncryptionUtils {
             NoSuchProviderException, IllegalBlockSizeException, InvalidKeySpecException, CertificateException {
 
         HashMap<String, EncryptedFolderMetadata.EncryptedFile> files = new HashMap<>();
-        EncryptedFolderMetadata encryptedFolderMetadata = new EncryptedFolderMetadata(decryptedFolderMetadata.metadata,
-                files);
+        EncryptedFolderMetadata encryptedFolderMetadata = new EncryptedFolderMetadata(decryptedFolderMetadata
+                .getMetadata(), files);
 
         // Encrypt each file in "files"
-        for (Map.Entry<String, DecryptedFolderMetadata.DecryptedFile> entry : decryptedFolderMetadata.files.entrySet()) {
+        for (Map.Entry<String, DecryptedFolderMetadata.DecryptedFile> entry : decryptedFolderMetadata
+                .getFiles().entrySet()) {
             String key = entry.getKey();
             DecryptedFolderMetadata.DecryptedFile decryptedFile = entry.getValue();
 
             EncryptedFolderMetadata.EncryptedFile encryptedFile = new EncryptedFolderMetadata.EncryptedFile();
-            encryptedFile.initializationVector = decryptedFile.initializationVector;
-            encryptedFile.metadataKey = decryptedFile.metadataKey;
-            encryptedFile.authenticationTag = decryptedFile.authenticationTag;
+            encryptedFile.setInitializationVector(decryptedFile.getInitializationVector());
+            encryptedFile.setMetadataKey(decryptedFile.getMetadataKey());
+            encryptedFile.setAuthenticationTag(decryptedFile.getAuthenticationTag());
 
             byte[] decryptedMetadataKey = EncryptionUtils.decodeStringToBase64Bytes(EncryptionUtils.decryptStringAsymmetric(
-                    decryptedFolderMetadata.metadata.metadataKeys.get(encryptedFile.metadataKey),
+                    decryptedFolderMetadata.getMetadata().getMetadataKeys().get(encryptedFile.getMetadataKey()),
                     privateKey));
 
             // encrypt
-            String dataJson = EncryptionUtils.serializeJSON(decryptedFile.encrypted);
-            encryptedFile.encrypted = EncryptionUtils.encryptStringSymmetric(dataJson, decryptedMetadataKey);
+            String dataJson = EncryptionUtils.serializeJSON(decryptedFile.getEncrypted());
+            encryptedFile.setEncrypted(EncryptionUtils.encryptStringSymmetric(dataJson, decryptedMetadataKey));
 
             files.put(key, encryptedFile);
         }
@@ -172,27 +173,28 @@ public class EncryptionUtils {
             NoSuchProviderException, IllegalBlockSizeException, CertificateException, InvalidKeySpecException {
 
         HashMap<String, DecryptedFolderMetadata.DecryptedFile> files = new HashMap<>();
-        DecryptedFolderMetadata decryptedFolderMetadata = new DecryptedFolderMetadata(encryptedFolderMetadata.metadata,
-                files);
+        DecryptedFolderMetadata decryptedFolderMetadata = new DecryptedFolderMetadata(
+                encryptedFolderMetadata.getMetadata(), files);
 
-        for (Map.Entry<String, EncryptedFolderMetadata.EncryptedFile> entry : encryptedFolderMetadata.files.entrySet()) {
+        for (Map.Entry<String, EncryptedFolderMetadata.EncryptedFile> entry : encryptedFolderMetadata
+                .getFiles().entrySet()) {
             String key = entry.getKey();
             EncryptedFolderMetadata.EncryptedFile encryptedFile = entry.getValue();
 
             DecryptedFolderMetadata.DecryptedFile decryptedFile = new DecryptedFolderMetadata.DecryptedFile();
-            decryptedFile.initializationVector = encryptedFile.initializationVector;
-            decryptedFile.metadataKey = encryptedFile.metadataKey;
-            decryptedFile.authenticationTag = encryptedFile.authenticationTag;
+            decryptedFile.setInitializationVector(encryptedFile.getInitializationVector());
+            decryptedFile.setMetadataKey(encryptedFile.getMetadataKey());
+            decryptedFile.setAuthenticationTag(encryptedFile.getAuthenticationTag());
 
-            byte[] decryptedMetadataKey = EncryptionUtils.decodeStringToBase64Bytes(EncryptionUtils.decryptStringAsymmetric(
-                    decryptedFolderMetadata.metadata.metadataKeys.get(encryptedFile.metadataKey),
-                    privateKey));
+            byte[] decryptedMetadataKey = EncryptionUtils.decodeStringToBase64Bytes(
+                    EncryptionUtils.decryptStringAsymmetric(decryptedFolderMetadata.getMetadata()
+                            .getMetadataKeys().get(encryptedFile.getMetadataKey()), privateKey));
 
             // decrypt
-            String dataJson = EncryptionUtils.decryptStringSymmetric(encryptedFile.encrypted, decryptedMetadataKey);
-            decryptedFile.encrypted = EncryptionUtils.deserializeJSON(dataJson,
+            String dataJson = EncryptionUtils.decryptStringSymmetric(encryptedFile.getEncrypted(), decryptedMetadataKey);
+            decryptedFile.setEncrypted(EncryptionUtils.deserializeJSON(dataJson,
                     new TypeToken<DecryptedFolderMetadata.Data>() {
-                    });
+                    }));
 
             files.put(key, decryptedFile);
         }