content: /*
   * Copyright (C) 2010 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.android.gallery3d.common;
  
  import android.content.Context;
  import android.content.pm.PackageInfo;
  import android.content.pm.PackageManager.NameNotFoundException;
  import android.database.Cursor;
  import android.os.Build;
  import android.os.ParcelFileDescriptor;
  import android.text.TextUtils;
  import android.util.Log;
  
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.InterruptedIOException;
  
  public class Utils {
      private static final String TAG = "Utils";
      private static final String DEBUG_TAG = "GalleryDebug";
  
      private static final long POLY64REV = 0x95AC9329AC4BC9B5L;
      private static final long INITIALCRC = 0xFFFFFFFFFFFFFFFFL;
  
      private static long[] sCrcTable = new long[256];
  
      private static final boolean IS_DEBUG_BUILD =
              Build.TYPE.equals("eng") || Build.TYPE.equals("userdebug");
  
      private static final String MASK_STRING = "********************************";
  
      // Throws AssertionError if the input is false.
      public static void assertTrue(boolean cond) {
          if (!cond) {
              throw new AssertionError();
          }
      }
  
      // Throws AssertionError with the message. We had a method having the form
      //   assertTrue(boolean cond, String message, Object ... args);
      // However a call to that method will cause memory allocation even if the
      // condition is false (due to autoboxing generated by "Object ... args"),
      // so we don't use that anymore.
      public static void fail(String message, Object ... args) {
          throw new AssertionError(
                  args.length == 0 ? message : String.format(message, args));
      }
  
      // Throws NullPointerException if the input is null.
      public static <T> T checkNotNull(T object) {
          if (object == null) throw new NullPointerException();
          return object;
      }
  
      // Returns true if two input Object are both null or equal
      // to each other.
      public static boolean equals(Object a, Object b) {
          return (a == b) || (a == null ? false : a.equals(b));
      }
  
      // Returns the next power of two.
      // Returns the input if it is already power of 2.
      // Throws IllegalArgumentException if the input is <= 0 or
      // the answer overflows.
      public static int nextPowerOf2(int n) {
          if (n <= 0 || n > (1 << 30)) throw new IllegalArgumentException("n is invalid: " + n);
          n -= 1;
          n |= n >> 16;
          n |= n >> 8;
          n |= n >> 4;
          n |= n >> 2;
          n |= n >> 1;
          return n + 1;
      }
  
      // Returns the previous power of two.
      // Returns the input if it is already power of 2.
      // Throws IllegalArgumentException if the input is <= 0
      public static int prevPowerOf2(int n) {
          if (n <= 0) throw new IllegalArgumentException();
          return Integer.highestOneBit(n);
      }
  
      // Returns the input value x clamped to the range [min, max].
      public static int clamp(int x, int min, int max) {
          if (x > max) return max;
          if (x < min) return min;
          return x;
      }
  
      // Returns the input value x clamped to the range [min, max].
      public static float clamp(float x, float min, float max) {
          if (x > max) return max;
          if (x < min) return min;
          return x;
      }
  
      // Returns the input value x clamped to the range [min, max].
      public static long clamp(long x, long min, long max) {
          if (x > max) return max;
          if (x < min) return min;
          return x;
      }
  
      public static boolean isOpaque(int color) {
          return color >>> 24 == 0xFF;
      }
  
      public static void swap(int[] array, int i, int j) {
          int temp = array[i];
          array[i] = array[j];
          array[j] = temp;
      }
  
      /**
       * A function thats returns a 64-bit crc for string
       *
       * @param in input string
       * @return a 64-bit crc value
       */
      public static final long crc64Long(String in) {
          if (in == null || in.length() == 0) {
              return 0;
          }
          return crc64Long(getBytes(in));
      }
  
      static {
          // http://bioinf.cs.ucl.ac.uk/downloads/crc64/crc64.c
          long part;
          for (int i = 0; i < 256; i++) {
              part = i;
              for (int j = 0; j < 8; j++) {
                  long x = ((int) part & 1) != 0 ? POLY64REV : 0;
                  part = (part >> 1) ^ x;
              }
              sCrcTable[i] = part;
          }
      }
  
      public static final long crc64Long(byte[] buffer) {
          long crc = INITIALCRC;
          for (int k = 0, n = buffer.length; k < n; ++k) {
              crc = sCrcTable[(((int) crc) ^ buffer[k]) & 0xff] ^ (crc >> 8);
          }
          return crc;
      }
  
      public static byte[] getBytes(String in) {
          byte[] result = new byte[in.length() * 2];
          int output = 0;
          for (char ch : in.toCharArray()) {
              result[output++] = (byte) (ch & 0xFF);
              result[output++] = (byte) (ch >> 8);
          }
          return result;
      }
  
      public static void closeSilently(Closeable c) {
          if (c == null) return;
          try {
              c.close();
          } catch (IOException t) {
              Log.w(TAG, "close fail ", t);
          }
      }
  
      public static int compare(long a, long b) {
          return a < b ? -1 : a == b ? 0 : 1;
      }
  
      public static int ceilLog2(float value) {
          int i;
          for (i = 0; i < 31; i++) {
              if ((1 << i) >= value) break;
          }
          return i;
      }
  
      public static int floorLog2(float value) {
          int i;
          for (i = 0; i < 31; i++) {
              if ((1 << i) > value) break;
          }
          return i - 1;
      }
  
      public static void closeSilently(ParcelFileDescriptor fd) {
          try {
              if (fd != null) fd.close();
          } catch (Throwable t) {
              Log.w(TAG, "fail to close", t);
          }
      }
  
      public static void closeSilently(Cursor cursor) {
          try {
              if (cursor != null) cursor.close();
          } catch (Throwable t) {
              Log.w(TAG, "fail to close", t);
          }
      }
  
      public static float interpolateAngle(
              float source, float target, float progress) {
          // interpolate the angle from source to target
          // We make the difference in the range of [-179, 180], this is the
          // shortest path to change source to target.
          float diff = target - source;
          if (diff < 0) diff += 360f;
          if (diff > 180) diff -= 360f;
  
          float result = source + diff * progress;
          return result < 0 ? result + 360f : result;
      }
  
      public static float interpolateScale(
              float source, float target, float progress) {
          return source + progress * (target - source);
      }
  
      public static String ensureNotNull(String value) {
          return value == null ? "" : value;
      }
  
      public static float parseFloatSafely(String content, float defaultValue) {
          if (content == null) return defaultValue;
          try {
              return Float.parseFloat(content);
          } catch (NumberFormatException e) {
              return defaultValue;
          }
      }
  
      public static int parseIntSafely(String content, int defaultValue) {
          if (content == null) return defaultValue;
          try {
              return Integer.parseInt(content);
          } catch (NumberFormatException e) {
              return defaultValue;
          }
      }
  
      public static boolean isNullOrEmpty(String exifMake) {
          return TextUtils.isEmpty(exifMake);
      }
  
      public static void waitWithoutInterrupt(Object object) {
          try {
              object.wait();
          } catch (InterruptedException e) {
              Log.w(TAG, "unexpected interrupt: " + object);
          }
      }
  
      public static boolean handleInterrruptedException(Throwable e) {
          // A helper to deal with the interrupt exception
          // If an interrupt detected, we will setup the bit again.
          if (e instanceof InterruptedIOException
                  || e instanceof InterruptedException) {
              Thread.currentThread().interrupt();
              return true;
          }
          return false;
      }
  
      /**
       * @return String with special XML characters escaped.
       */
      public static String escapeXml(String s) {
          StringBuilder sb = new StringBuilder();
          for (int i = 0, len = s.length(); i < len; ++i) {
              char c = s.charAt(i);
              switch (c) {
                  case '<':  sb.append("&lt;"); break;
                  case '>':  sb.append("&gt;"); break;
                  case '\"': sb.append("&quot;"); break;
                  case '\'': sb.append("&#039;"); break;
                  case '&':  sb.append("&amp;"); break;
                  default: sb.append(c);
              }
          }
          return sb.toString();
      }
  
      public static String getUserAgent(Context context) {
          PackageInfo packageInfo;
          try {
              packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
          } catch (NameNotFoundException e) {
              throw new IllegalStateException("getPackageInfo failed");
          }
          return String.format("%s/%s; %s/%s/%s/%s; %s/%s/%s",
                  packageInfo.packageName,
                  packageInfo.versionName,
                  Build.BRAND,
                  Build.DEVICE,
                  Build.MODEL,
                  Build.ID,
                  Build.VERSION.SDK_INT,
                  Build.VERSION.RELEASE,
                  Build.VERSION.INCREMENTAL);
      }
  
      public static String[] copyOf(String[] source, int newSize) {
          String[] result = new String[newSize];
          newSize = Math.min(source.length, newSize);
          System.arraycopy(source, 0, result, 0, newSize);
          return result;
      }
  
      // Mask information for debugging only. It returns <code>info.toString()</code> directly
      // for debugging build (i.e., 'eng' and 'userdebug') and returns a mask ("****")
      // in release build to protect the information (e.g. for privacy issue).
      public static String maskDebugInfo(Object info) {
          if (info == null) return null;
          String s = info.toString();
          int length = Math.min(s.length(), MASK_STRING.length());
          return IS_DEBUG_BUILD ? s : MASK_STRING.substring(0, length);
      }
  
      // This method should be ONLY used for debugging.
      public static void debug(String message, Object ... args) {
          Log.v(DEBUG_TAG, String.format(message, args));
      }
  }
  