@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/support/long-image/src/main/java/com/quicktvui/support/longimage/utils/LongImageLoader.java

@@ -0,0 +1,180 @@
+package com.quicktvui.support.longimage.utils;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.Priority;
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.DecodeFormat;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.RequestOptions;
+import com.bumptech.glide.request.target.SimpleTarget;
+import com.bumptech.glide.request.target.Target;
+import com.bumptech.glide.request.transition.Transition;
+import com.quicktvui.sdk.base.EsCallback;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.base.core.EsProxy;
+import com.sunrain.toolkit.utils.log.L;
+
+import java.io.InputStream;
+
+
+import com.quicktvui.support.imageloader.EsHttpGlideUrlLoader;
+import com.quicktvui.support.imageloader.Request;
+
+public class LongImageLoader {
+    private final Handler mHandler;
+    static volatile LongImageLoader INSTANCE;
+    private LongLoadTarget target;
+
+    public static LongImageLoader getInstance() {
+        if (INSTANCE == null) {
+            synchronized (LongImageLoader.class) {
+                if (INSTANCE == null) {
+                    INSTANCE = new LongImageLoader();
+                }
+            }
+        }
+        return INSTANCE;
+    }
+
+    public LongImageLoader() {
+        mHandler = new Handler(Looper.getMainLooper());
+        Glide glide = Glide.get(EsProxy.get().getContext());
+        if (glide != null) {
+            glide.getRegistry().replace(GlideUrl.class, InputStream.class, new EsHttpGlideUrlLoader.Factory());
+        }
+        target = new LongLoadTarget(mHandler, false, 0.5f);
+    }
+
+    public void loadImage(Context context, EsMap params, boolean enableAutoCompress, float compressScale, EsCallback<Bitmap, Throwable> callback) {
+        if (context instanceof Activity) {
+            if (((Activity) context).isFinishing()
+                    || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1
+                    && ((Activity) context).isDestroyed())) {
+                return;
+            }
+        }
+        Request request = new Request(params);
+        if (L.DEBUG) L.logD("loadImage: " + request.url);
+        if (target != null) {
+            target.setEnableAutoCompress(enableAutoCompress);
+            target.setCompressScale(compressScale);
+            target.setCallback(callback);
+            Glide.with(context)
+                    .asBitmap()
+                    .load(request.url)
+                    .apply(makeOptions(request))
+                    .listener(target)
+                    .into(target);
+        }
+    }
+
+    public void loadImageUri(Context context, Uri uri, EsMap params,boolean enableAutoCompress, float compressScale, EsCallback<Bitmap, Throwable> callback ){
+        if (context instanceof Activity) {
+            if (((Activity) context).isFinishing()
+                    || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1
+                    && ((Activity) context).isDestroyed())) {
+                return;
+            }
+        }
+        Request request = new Request(params);
+        if (L.DEBUG) L.logD("loadImage: " + uri.toString());
+        if (target != null) {
+            target.setEnableAutoCompress(enableAutoCompress);
+            target.setCompressScale(compressScale);
+            target.setCallback(callback);
+            Glide.with(context)
+                    .asBitmap()
+                    .load(uri)
+                    .apply(makeOptions(request))
+                    .listener(target)
+                    .into(target);
+        }
+    }
+
+    private static class LongLoadTarget extends SimpleTarget<Bitmap> implements RequestListener<Bitmap> {
+
+        private Handler handler;
+        private EsCallback<Bitmap, Throwable> callback;
+        private boolean enableAutoCompress;
+        private float compressScale;
+
+        public LongLoadTarget(Handler handler, boolean enableAutoCompress, float compressScale) {
+            this.handler = handler;
+            this.enableAutoCompress = enableAutoCompress;
+            this.compressScale = compressScale;
+        }
+
+        @Override
+        public boolean onResourceReady(Bitmap resource, Object model, Target<Bitmap> target, DataSource dataSource, boolean isFirstResource) {
+            handler.post(() -> this.callback.onSuccess(enableAutoCompress ? matrixBitmap(resource, compressScale) : resource));
+            return false;
+        }
+
+        @Override
+        public void onResourceReady(Bitmap resource, Transition<? super Bitmap> transition) {
+        }
+
+        @Override
+        public boolean onLoadFailed(GlideException e, Object model, Target<Bitmap> target, boolean isFirstResource) {
+            handler.post(() -> callback.onFailed(e));
+            return false;
+        }
+
+        @Override
+        public void onLoadFailed(Drawable errorDrawable) {
+        }
+
+        public void setCallback(EsCallback<Bitmap, Throwable> callback) {
+            this.callback = callback;
+        }
+
+        public Bitmap matrixBitmap(Bitmap bitmap, Float scale) {
+            Matrix matrix = new Matrix();
+            matrix.setScale(scale, scale);
+//            BitmapFactory.Options options=new BitmapFactory.Options();
+//            options.inJustDecodeBounds = true;
+            Bitmap bm = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+            return bm;
+        }
+
+        public void setEnableAutoCompress(boolean enableAutoCompress) {
+            this.enableAutoCompress = enableAutoCompress;
+        }
+
+        public void setCompressScale(float compressScale) {
+            this.compressScale = compressScale;
+        }
+    }
+
+    private RequestOptions makeOptions(Request request) {
+        RequestOptions options = new RequestOptions();
+        if (!request.url.toLowerCase().endsWith(".gif")) {
+            DecodeFormat f = request.fullQuality ? DecodeFormat.PREFER_ARGB_8888 : DecodeFormat.PREFER_RGB_565;
+            options = options.skipMemoryCache(true).format(f).dontAnimate();
+            if (request.width > 0 && request.height > 0)
+                options = options.override(request.width, request.height);
+            if (request.circle) options = options.circleCrop();
+        }
+        if (request.width >= 500 || request.height >= 500) {
+            options = options.skipMemoryCache(true);
+        }
+        options = options.timeout(20000).priority(Priority.values()[request.priority]);
+        return options;
+    }
+
+    public void destroy(Context context) {
+
+    }
+}

package/rules/.source/sdk/support/long-image/src/main/java/com/quicktvui/support/longimage/utils/luban/Checker.java

@@ -0,0 +1,196 @@
+package com.quicktvui.support.longimage.utils.luban;
+
+import android.graphics.BitmapFactory;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+enum Checker {
+  SINGLE;
+
+  private static final String TAG = "Luban";
+
+  private static final String JPG = ".jpg";
+
+  private final byte[] JPEG_SIGNATURE = new byte[]{(byte) 0xFF, (byte) 0xD8, (byte) 0xFF};
+
+  /**
+   * Determine if it is JPG.
+   *
+   * @param is image file input stream
+   */
+  boolean isJPG(InputStream is) {
+    return isJPG(toByteArray(is));
+  }
+
+  /**
+   * Returns the degrees in clockwise. Values are 0, 90, 180, or 270.
+   */
+  int getOrientation(InputStream is) {
+    return getOrientation(toByteArray(is));
+  }
+
+  private boolean isJPG(byte[] data) {
+    if (data == null || data.length < 3) {
+      return false;
+    }
+    byte[] signatureB = new byte[]{data[0], data[1], data[2]};
+    return Arrays.equals(JPEG_SIGNATURE, signatureB);
+  }
+
+  private int getOrientation(byte[] jpeg) {
+    if (jpeg == null) {
+      return 0;
+    }
+
+    int offset = 0;
+    int length = 0;
+
+    // ISO/IEC 10918-1:1993(E)
+    while (offset + 3 < jpeg.length && (jpeg[offset++] & 0xFF) == 0xFF) {
+      int marker = jpeg[offset] & 0xFF;
+
+      // Check if the marker is a padding.
+      if (marker == 0xFF) {
+        continue;
+      }
+      offset++;
+
+      // Check if the marker is SOI or TEM.
+      if (marker == 0xD8 || marker == 0x01) {
+        continue;
+      }
+      // Check if the marker is EOI or SOS.
+      if (marker == 0xD9 || marker == 0xDA) {
+        break;
+      }
+
+      // Get the length and check if it is reasonable.
+      length = pack(jpeg, offset, 2, false);
+      if (length < 2 || offset + length > jpeg.length) {
+        Log.e(TAG, "Invalid length");
+        return 0;
+      }
+
+      // Break if the marker is EXIF in APP1.
+      if (marker == 0xE1 && length >= 8
+          && pack(jpeg, offset + 2, 4, false) == 0x45786966
+          && pack(jpeg, offset + 6, 2, false) == 0) {
+        offset += 8;
+        length -= 8;
+        break;
+      }
+
+      // Skip other markers.
+      offset += length;
+      length = 0;
+    }
+
+    // JEITA CP-3451 Exif Version 2.2
+    if (length > 8) {
+      // Identify the byte order.
+      int tag = pack(jpeg, offset, 4, false);
+      if (tag != 0x49492A00 && tag != 0x4D4D002A) {
+        Log.e(TAG, "Invalid byte order");
+        return 0;
+      }
+      boolean littleEndian = (tag == 0x49492A00);
+
+      // Get the offset and check if it is reasonable.
+      int count = pack(jpeg, offset + 4, 4, littleEndian) + 2;
+      if (count < 10 || count > length) {
+        Log.e(TAG, "Invalid offset");
+        return 0;
+      }
+      offset += count;
+      length -= count;
+
+      // Get the count and go through all the elements.
+      count = pack(jpeg, offset - 2, 2, littleEndian);
+      while (count-- > 0 && length >= 12) {
+        // Get the tag and check if it is orientation.
+        tag = pack(jpeg, offset, 2, littleEndian);
+        if (tag == 0x0112) {
+          int orientation = pack(jpeg, offset + 8, 2, littleEndian);
+          switch (orientation) {
+            case 1:
+              return 0;
+            case 3:
+              return 180;
+            case 6:
+              return 90;
+            case 8:
+              return 270;
+          }
+          Log.e(TAG, "Unsupported orientation");
+          return 0;
+        }
+        offset += 12;
+        length -= 12;
+      }
+    }
+
+    Log.e(TAG, "Orientation not found");
+    return 0;
+  }
+
+  String extSuffix(InputStreamProvider input) {
+    try {
+      BitmapFactory.Options options = new BitmapFactory.Options();
+      options.inJustDecodeBounds = true;
+      BitmapFactory.decodeStream(input.open(), null, options);
+      return options.outMimeType.replace("image/", ".");
+    } catch (Exception e) {
+      return JPG;
+    }
+  }
+
+  boolean needCompress(int leastCompressSize, String path) {
+    if (leastCompressSize > 0) {
+      File source = new File(path);
+      return source.exists() && source.length() > (leastCompressSize << 10);
+    }
+    return true;
+  }
+
+  private int pack(byte[] bytes, int offset, int length, boolean littleEndian) {
+    int step = 1;
+    if (littleEndian) {
+      offset += length - 1;
+      step = -1;
+    }
+
+    int value = 0;
+    while (length-- > 0) {
+      value = (value << 8) | (bytes[offset] & 0xFF);
+      offset += step;
+    }
+    return value;
+  }
+
+  private byte[] toByteArray(InputStream is) {
+    if (is == null) {
+      return new byte[0];
+    }
+    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+    int read;
+    byte[] data = new byte[4096];
+    try {
+      while ((read = is.read(data, 0, data.length)) != -1) {
+        buffer.write(data, 0, read);
+      }
+    } catch (Exception ignored) {
+      return new byte[0];
+    } finally {
+      try {
+        buffer.close();
+      } catch (IOException ignored) {
+      }
+    }
+    return buffer.toByteArray();
+  }
+}

package/rules/.source/sdk/support/long-image/src/main/java/com/quicktvui/support/longimage/utils/luban/CompressionPredicate.java

@@ -0,0 +1,19 @@
+package com.quicktvui.support.longimage.utils.luban;
+
+/**
+ * Created on 2018/1/3 19:43
+ *
+ * @author andy
+ *
+ * A functional interface (callback) that returns true or false for the given input path should be compressed.
+ */
+
+public interface CompressionPredicate {
+
+    /**
+     * Determine the given input path should be compressed and return a boolean.
+     * @param path input path
+     * @return the boolean result
+     */
+    boolean apply(String path);
+}

package/rules/.source/sdk/support/long-image/src/main/java/com/quicktvui/support/longimage/utils/luban/Engine.java

@@ -0,0 +1,90 @@
+package com.quicktvui.support.longimage.utils.luban;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/**
+ * Responsible for starting compress and managing active and cached resources.
+ */
+class Engine {
+  private InputStreamProvider srcImg;
+  private File tagImg;
+  private int srcWidth;
+  private int srcHeight;
+  private boolean focusAlpha;
+
+  Engine(InputStreamProvider srcImg, File tagImg, boolean focusAlpha) throws IOException {
+    this.tagImg = tagImg;
+    this.srcImg = srcImg;
+    this.focusAlpha = focusAlpha;
+
+    BitmapFactory.Options options = new BitmapFactory.Options();
+    options.inJustDecodeBounds = true;
+    options.inSampleSize = 1;
+
+    BitmapFactory.decodeStream(srcImg.open(), null, options);
+    this.srcWidth = options.outWidth;
+    this.srcHeight = options.outHeight;
+  }
+
+  private int computeSize() {
+    srcWidth = srcWidth % 2 == 1 ? srcWidth + 1 : srcWidth;
+    srcHeight = srcHeight % 2 == 1 ? srcHeight + 1 : srcHeight;
+
+    int longSide = Math.max(srcWidth, srcHeight);
+    int shortSide = Math.min(srcWidth, srcHeight);
+
+    float scale = ((float) shortSide / longSide);
+    if (scale <= 1 && scale > 0.5625) {
+      if (longSide < 1664) {
+        return 1;
+      } else if (longSide < 4990) {
+        return 2;
+      } else if (longSide > 4990 && longSide < 10240) {
+        return 4;
+      } else {
+        return longSide / 1280 == 0 ? 1 : longSide / 1280;
+      }
+    } else if (scale <= 0.5625 && scale > 0.5) {
+      return longSide / 1280 == 0 ? 1 : longSide / 1280;
+    } else {
+      return (int) Math.ceil(longSide / (1280.0 / scale));
+    }
+  }
+
+  private Bitmap rotatingImage(Bitmap bitmap, int angle) {
+    Matrix matrix = new Matrix();
+
+    matrix.postRotate(angle);
+
+    return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+  }
+
+  File compress() throws IOException {
+    BitmapFactory.Options options = new BitmapFactory.Options();
+    options.inSampleSize = computeSize();
+    Bitmap tagBitmap = BitmapFactory.decodeStream(srcImg.open(), null, options);
+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
+
+//    if (Checker.SINGLE.isJPG(srcImg.open())) {
+//      Log.v("yuyuyu","compress---------------4");
+//      tagBitmap = rotatingImage(tagBitmap, Checker.SINGLE.getOrientation(srcImg.open()));
+//    }
+    tagBitmap.compress(focusAlpha ? Bitmap.CompressFormat.PNG : Bitmap.CompressFormat.JPEG, 60, stream);
+    tagBitmap.recycle();
+
+    FileOutputStream fos = new FileOutputStream(tagImg);
+    fos.write(stream.toByteArray());
+    fos.flush();
+    fos.close();
+    stream.close();
+
+    return tagImg;
+  }
+}

package/rules/.source/sdk/support/long-image/src/main/java/com/quicktvui/support/longimage/utils/luban/InputStreamAdapter.java

@@ -0,0 +1,34 @@
+package com.quicktvui.support.longimage.utils.luban;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Automatically close the previous InputStream when opening a new InputStream,
+ * and finally need to manually call {@link #close()} to release the resource.
+ */
+public abstract class InputStreamAdapter implements InputStreamProvider {
+
+  private InputStream inputStream;
+
+  @Override
+  public InputStream open() throws IOException {
+    close();
+    inputStream = openInternal();
+    return inputStream;
+  }
+
+  public abstract InputStream openInternal() throws IOException;
+
+  @Override
+  public void close() {
+    if (inputStream != null) {
+      try {
+        inputStream.close();
+      } catch (IOException ignore) {
+      }finally {
+        inputStream = null;
+      }
+    }
+  }
+}

package/rules/.source/sdk/support/long-image/src/main/java/com/quicktvui/support/longimage/utils/luban/InputStreamProvider.java

@@ -0,0 +1,18 @@
+package com.quicktvui.support.longimage.utils.luban;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * 通过此接口获取输入流，以兼容文件、FileProvider方式获取到的图片
+ * <p>
+ * Get the input stream through this interface, and obtain the picture using compatible files and FileProvider
+ */
+public interface InputStreamProvider {
+
+  InputStream open() throws IOException;
+
+  void close();
+
+  String getPath();
+}