+
+ /**
+ * Sorts all filenames, regarding last user decision
+ */
+ public static Vector<OCFile> sortFolder(Vector<OCFile> files){
+ switch (mSortOrder){
+ case 0:
+ files = FileStorageUtils.sortByName(files);
+ break;
+ case 1:
+ files = FileStorageUtils.sortByDate(files);
+ break;
+ case 2:
+ // mFiles = FileStorageUtils.sortBySize(mSortAscending);
+ break;
+ }
+
+ return files;
+ }
+
+ /**
+ * Sorts list by Date
+ * @param files
+ */
+ public static Vector<OCFile> sortByDate(Vector<OCFile> files){
+ final Integer val;
+ if (mSortAscending){
+ val = 1;
+ } else {
+ val = -1;
+ }
+
+ Collections.sort(files, new Comparator<OCFile>() {
+ public int compare(OCFile o1, OCFile o2) {
+ if (o1.isFolder() && o2.isFolder()) {
+ Long obj1 = o1.getModificationTimestamp();
+ return val * obj1.compareTo(o2.getModificationTimestamp());
+ }
+ else if (o1.isFolder()) {
+ return -1;
+ } else if (o2.isFolder()) {
+ return 1;
+ } else if (o1.getModificationTimestamp() == 0 || o2.getModificationTimestamp() == 0){
+ return 0;
+ } else {
+ Long obj1 = o1.getModificationTimestamp();
+ return val * obj1.compareTo(o2.getModificationTimestamp());
+ }
+ }
+ });
+
+ return files;
+ }
+
+// /**
+// * Sorts list by Size
+// * @param sortAscending true: ascending, false: descending
+// */
+// public static Vector<OCFile> sortBySize(Vector<OCFile> files){
+// final Integer val;
+// if (mSortAscending){
+// val = 1;
+// } else {
+// val = -1;
+// }
+//
+// Collections.sort(files, new Comparator<OCFile>() {
+// public int compare(OCFile o1, OCFile o2) {
+// if (o1.isFolder() && o2.isFolder()) {
+// Long obj1 = getFolderSize(new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, o1)));
+// return val * obj1.compareTo(getFolderSize(new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, o2))));
+// }
+// else if (o1.isFolder()) {
+// return -1;
+// } else if (o2.isFolder()) {
+// return 1;
+// } else if (o1.getFileLength() == 0 || o2.getFileLength() == 0){
+// return 0;
+// } else {
+// Long obj1 = o1.getFileLength();
+// return val * obj1.compareTo(o2.getFileLength());
+// }
+// }
+// });
+//
+// return files;
+// }
+
+ /**
+ * Sorts list by Name
+ * @param files files to sort
+ */
+ public static Vector<OCFile> sortByName(Vector<OCFile> files){
+ final Integer val;
+ if (mSortAscending){
+ val = 1;
+ } else {
+ val = -1;
+ }
+
+ Collections.sort(files, new Comparator<OCFile>() {
+ public int compare(OCFile o1, OCFile o2) {
+ if (o1.isFolder() && o2.isFolder()) {
+ return val * new AlphanumComparator().compare(o1, o2);
+ } else if (o1.isFolder()) {
+ return -1;
+ } else if (o2.isFolder()) {
+ return 1;
+ }
+ return val * new AlphanumComparator().compare(o1, o2);
+ }
+ });
+
+ return files;
+ }
+
+ /**
+ * Local Folder size
+ * @param dir File
+ * @return Size in bytes
+ */
+ public static long getFolderSize(File dir) {
+ if (dir.exists()) {
+ long result = 0;
+ for (File f : dir.listFiles()) {
+ if (f.isDirectory())
+ result += getFolderSize(f);
+ else
+ result += f.length();
+ }
+ return result;
+ }
+ return 0;
+ }
+
+ /**
+ * Mimetype String of a file
+ * @param path
+ * @return
+ */
+ public static String getMimeTypeFromName(String path) {
+ String extension = "";
+ int pos = path.lastIndexOf('.');
+ if (pos >= 0) {
+ extension = path.substring(pos + 1);
+ }
+ String result = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.toLowerCase());
+ return (result != null) ? result : "";
+ }
+
+ /**
+ * Scans the default location for saving local copies of files searching for
+ * a 'lost' file with the same full name as the {@link OCFile} received as
+ * parameter.
+ *
+ * This method helps to keep linked local copies of the files when the app is uninstalled, and then
+ * reinstalled in the device. OR after the cache of the app was deleted in system settings.
+ *
+ * The method is assuming that all the local changes in the file where synchronized in the past. This is dangerous,
+ * but assuming the contrary could lead to massive unnecessary synchronizations of downloaded file after deleting
+ * the app cache.
+ *
+ * This should be changed in the near future to avoid any chance of data loss, but we need to add some options
+ * to limit hard automatic synchronizations to wifi, unless the user wants otherwise.
+ *
+ * @param file File to associate a possible 'lost' local file.
+ * @param account Account holding file.
+ */
+ public static void searchForLocalFileInDefaultPath(OCFile file, Account account) {
+ if (file.getStoragePath() == null && !file.isFolder()) {
+ File f = new File(FileStorageUtils.getDefaultSavePathFor(account.name, file));
+ if (f.exists()) {
+ file.setStoragePath(f.getAbsolutePath());
+ file.setLastSyncDateForData(f.lastModified());
+ }
+ }
+ }
+
+ public static boolean copyFile(File src, File target) {
+ boolean ret = true;
+
+ InputStream in = null;
+ OutputStream out = null;
+
+ try {
+ in = new FileInputStream(src);
+ out = new FileOutputStream(target);
+ byte[] buf = new byte[1024];
+ int len;
+ while ((len = in.read(buf)) > 0) {
+ out.write(buf, 0, len);
+ }
+ } catch (IOException ex) {
+ ret = false;
+ } finally {
+ if (in != null) try {
+ in.close();
+ } catch (IOException e) {
+ e.printStackTrace(System.err);
+ }
+ if (out != null) try {
+ out.close();
+ } catch (IOException e) {
+ e.printStackTrace(System.err);
+ }
+ }
+
+ return ret;
+ }
+
projects / pub / Android / ownCloud.git / blobdiff