src/com/owncloud/android/utils/DisplayUtils.java

   1 /**
   2  *   ownCloud Android client application
   3  *
   4  *   @author Bartek Przybylski
   5  *   @author David A. Velasco
   6  *   Copyright (C) 2011  Bartek Przybylski
   7  *   Copyright (C) 2015 ownCloud Inc.
   8  *
   9  *   This program is free software: you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License version 2,
  11  *   as published by the Free Software Foundation.
  12  *
  13  *   This program is distributed in the hope that it will be useful,
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *   GNU General Public License for more details.
  17  *
  18  *   You should have received a copy of the GNU General Public License
  19  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  *
  21  */
  22
  23 package com.owncloud.android.utils;
  24
  25 import android.annotation.TargetApi;
  26 import android.app.Activity;
  27 import android.content.Context;
  28 import android.graphics.Point;
  29 import android.graphics.PorterDuff;
  30 import android.os.Build;
  31 import android.text.format.DateUtils;
  32 import android.view.Display;
  33 import android.widget.ProgressBar;
  34 import android.widget.SeekBar;
  35
  36 import com.owncloud.android.MainApp;
  37 import com.owncloud.android.R;
  38 import com.owncloud.android.datamodel.OCFile;
  39
  40 import java.net.IDN;
  41 import java.text.DateFormat;
  42 import java.util.Calendar;
  43 import java.util.Date;
  44 import java.util.HashMap;
  45 import java.util.Map;
  46
  47 /**
  48  * A helper class for some string operations.
  49  */
  50 public class DisplayUtils {
  51
  52     private static final String OWNCLOUD_APP_NAME = "ownCloud";
  53
  54     private static final String[] sizeSuffixes = { "B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
  55
  56     private static Map<String, String> mimeType2HumanReadable;
  57
  58     static {
  59         mimeType2HumanReadable = new HashMap<String, String>();
  60         // images
  61         mimeType2HumanReadable.put("image/jpeg", "JPEG image");
  62         mimeType2HumanReadable.put("image/jpg", "JPEG image");
  63         mimeType2HumanReadable.put("image/png", "PNG image");
  64         mimeType2HumanReadable.put("image/bmp", "Bitmap image");
  65         mimeType2HumanReadable.put("image/gif", "GIF image");
  66         mimeType2HumanReadable.put("image/svg+xml", "JPEG image");
  67         mimeType2HumanReadable.put("image/tiff", "TIFF image");
  68         // music
  69         mimeType2HumanReadable.put("audio/mpeg", "MP3 music file");
  70         mimeType2HumanReadable.put("application/ogg", "OGG music file");
  71     }
  72
  73     /**
  74      * Converts the file size in bytes to human readable output.
  75      *
  76      * @param bytes Input file size
  77      * @return Like something readable like "12 MB"
  78      */
  79     public static String bytesToHumanReadable(long bytes) {
  80         double result = bytes;
  81         int attachedsuff = 0;
  82         while (result > 1024 && attachedsuff < sizeSuffixes.length) {
  83             result /= 1024.;
  84             attachedsuff++;
  85         }
  86         result = ((int) (result * 100)) / 100.;
  87         return result + " " + sizeSuffixes[attachedsuff];
  88     }
  89
  90     /**
  91      * Converts MIME types like "image/jpg" to more end user friendly output
  92      * like "JPG image".
  93      *
  94      * @param mimetype MIME type to convert
  95      * @return A human friendly version of the MIME type
  96      */
  97     public static String convertMIMEtoPrettyPrint(String mimetype) {
  98         if (mimeType2HumanReadable.containsKey(mimetype)) {
  99             return mimeType2HumanReadable.get(mimetype);
 100         }
 101         if (mimetype.split("/").length >= 2)
 102             return mimetype.split("/")[1].toUpperCase() + " file";
 103         return "Unknown type";
 104     }
 105
 106     /**
 107      * Converts Unix time to human readable format
 108      * @param milliseconds that have passed since 01/01/1970
 109      * @return The human readable time for the users locale
 110      */
 111     public static String unixTimeToHumanReadable(long milliseconds) {
 112         Date date = new Date(milliseconds);
 113         DateFormat df = DateFormat.getDateTimeInstance();
 114         return df.format(date);
 115     }
 116
 117     public static int getSeasonalIconId() {
 118         if (Calendar.getInstance().get(Calendar.DAY_OF_YEAR) >= 354 &&
 119                 MainApp.getAppContext().getString(R.string.app_name).equals(OWNCLOUD_APP_NAME)) {
 120             return R.drawable.winter_holidays_icon;
 121         } else {
 122             return R.drawable.icon;
 123         }
 124     }
 125
 126     /**
 127      * Converts an internationalized domain name (IDN) in an URL to and from ASCII/Unicode.
 128      * @param url the URL where the domain name should be converted
 129      * @param toASCII if true converts from Unicode to ASCII, if false converts from ASCII to Unicode
 130      * @return the URL containing the converted domain name
 131      */
 132     @TargetApi(Build.VERSION_CODES.GINGERBREAD)
 133     public static String convertIdn(String url, boolean toASCII) {
 134
 135         String urlNoDots = url;
 136         String dots="";
 137         while (urlNoDots.startsWith(".")) {
 138             urlNoDots = url.substring(1);
 139             dots = dots + ".";
 140         }
 141
 142         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
 143             // Find host name after '//' or '@'
 144             int hostStart = 0;
 145             if  (urlNoDots.indexOf("//") != -1) {
 146                 hostStart = url.indexOf("//") + "//".length();
 147             } else if (url.indexOf("@") != -1) {
 148                 hostStart = url.indexOf("@") + "@".length();
 149             }
 150
 151             int hostEnd = url.substring(hostStart).indexOf("/");
 152             // Handle URL which doesn't have a path (path is implicitly '/')
 153             hostEnd = (hostEnd == -1 ? urlNoDots.length() : hostStart + hostEnd);
 154
 155             String host = urlNoDots.substring(hostStart, hostEnd);
 156             host = (toASCII ? IDN.toASCII(host) : IDN.toUnicode(host));
 157
 158             return dots + urlNoDots.substring(0, hostStart) + host + urlNoDots.substring(hostEnd);
 159         } else {
 160             return dots + url;
 161         }
 162     }
 163
 164     /**
 165      * Get the file extension if it is on path as type "content://.../DocInfo.doc"
 166      * @param filepath: Content Uri converted to string format
 167      * @return String: fileExtension (type '.pdf'). Empty if no extension
 168      */
 169     public static String getComposedFileExtension(String filepath) {
 170         String fileExtension = "";
 171         String fileNameInContentUri = filepath.substring(filepath.lastIndexOf("/"));
 172
 173         // Check if extension is included in uri
 174         int pos = fileNameInContentUri.lastIndexOf('.');
 175         if (pos >= 0) {
 176             fileExtension = fileNameInContentUri.substring(pos);
 177         }
 178         return fileExtension;
 179     }
 180
 181     @SuppressWarnings("deprecation")
 182     public static CharSequence getRelativeDateTimeString (
 183             Context c, long time, long minResolution, long transitionResolution, int flags
 184             ){
 185
 186         CharSequence dateString = "";
 187
 188         // in Future
 189         if (time > System.currentTimeMillis()){
 190             return DisplayUtils.unixTimeToHumanReadable(time);
 191         }
 192         // < 60 seconds -> seconds ago
 193         else if ((System.currentTimeMillis() - time) < 60 * 1000) {
 194             return c.getString(R.string.file_list_seconds_ago);
 195         } else {
 196             // Workaround 2.x bug (see https://github.com/owncloud/android/issues/716)
 197             if (    Build.VERSION.SDK_INT <= Build.VERSION_CODES.HONEYCOMB &&
 198                     (System.currentTimeMillis() - time) > 24 * 60 * 60 * 1000   ) {
 199                 Date date = new Date(time);
 200                 date.setHours(0);
 201                 date.setMinutes(0);
 202                 date.setSeconds(0);
 203                 dateString = DateUtils.getRelativeDateTimeString(
 204                         c, date.getTime(), minResolution, transitionResolution, flags
 205                 );
 206             } else {
 207                 dateString = DateUtils.getRelativeDateTimeString(c, time, minResolution, transitionResolution, flags);
 208             }
 209         }
 210
 211         String[] parts = dateString.toString().split(",");
 212         if (parts.length == 2) {
 213             if(parts[0].contains(":") && !parts[1].contains(":")) {
 214                 return parts[1];
 215             } else if(parts[1].contains(":") && !parts[0].contains(":")) {
 216                 return parts[0];
 217             }
 218         }
 219         //dateString contains unexpected format. use localized, absolute date.
 220         return DisplayUtils.unixTimeToHumanReadable(time);
 221     }
 222
 223     /**
 224      * Update the passed path removing the last "/" if it is not the root folder
 225      * @param path
 226      */
 227     public static String getPathWithoutLastSlash(String path) {
 228
 229         // Remove last slash from path
 230         if (path.length() > 1 && path.charAt(path.length()-1) == OCFile.PATH_SEPARATOR.charAt(0)) {
 231             path = path.substring(0, path.length()-1);
 232         }
 233         return path;
 234     }
 235
 236
 237     /**
 238      * Gets the screen size in pixels in a backwards compatible way
 239      *
 240      * @param caller        Activity calling; needed to get access to the {@link android.view.WindowManager}
 241      * @return              Size in pixels of the screen, or default {@link Point} if caller is null
 242      */
 243     public static Point getScreenSize(Activity caller) {
 244         Point size = new Point();
 245         if (caller != null) {
 246             Display display = caller.getWindowManager().getDefaultDisplay();
 247             if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.HONEYCOMB_MR2) {
 248                 display.getSize(size);
 249             } else {
 250                 size.set(display.getWidth(), display.getHeight());
 251             }
 252         }
 253         return size;
 254     }
 255
 256     /**
 257      * sets the coloring of the given progress bar to color_accent.
 258      *
 259      * @param progressBar the progress bar to be colored
 260      */
 261     public static void colorPreLollipopHorizontalProgressBar(ProgressBar progressBar) {
 262         if (progressBar != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
 263             int color = progressBar.getResources().getColor(R.color.color_accent);
 264             progressBar.getIndeterminateDrawable().setColorFilter(color, PorterDuff.Mode.SRC_IN);
 265             progressBar.getProgressDrawable().setColorFilter(color, PorterDuff.Mode.SRC_IN);
 266         }
 267     }
 268
 269     /**
 270      * sets the coloring of the given seek bar to color_accent.
 271      *
 272      * @param seekBar the seek bar to be colored
 273      */
 274     public static void colorPreLollipopHorizontalSeekBar(SeekBar seekBar) {
 275         if (seekBar != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
 276             colorPreLollipopHorizontalProgressBar(seekBar);
 277
 278             if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
 279                 int color = seekBar.getResources().getColor(R.color.color_accent);
 280                 seekBar.getThumb().setColorFilter(color, PorterDuff.Mode.SRC_IN);
 281                 seekBar.getThumb().setColorFilter(color, PorterDuff.Mode.SRC_IN);
 282             }
 283         }
 284     }
 285 }