@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/support/gif-view/src/main/java/com/quicktvui/rastermill/FrameSequenceDrawable.java

@@ -0,0 +1,381 @@
+package com.quicktvui.rastermill;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapShader;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.Shader;
+import android.graphics.Bitmap.Config;
+import android.graphics.Shader.TileMode;
+import android.graphics.drawable.Animatable;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.SystemClock;
+
+public class FrameSequenceDrawable extends Drawable implements Animatable, Runnable {
+    private static final long MIN_DELAY_MS = 20L;
+    private static final long DEFAULT_DELAY_MS = 100L;
+    private static final Object sLock = new Object();
+    private static HandlerThread sDecodingThread;
+    private static Handler sDecodingThreadHandler;
+    private static BitmapProvider sAllocatingBitmapProvider = new BitmapProvider() {
+        public Bitmap acquireBitmap(int minWidth, int minHeight) {
+            return Bitmap.createBitmap(minWidth, minHeight, Config.ARGB_8888);
+        }
+
+        public void releaseBitmap(Bitmap bitmap) {
+        }
+    };
+    public static final int LOOP_ONCE = 1;
+    public static final int LOOP_INF = 2;
+    public static final int LOOP_DEFAULT = 3;
+    private final FrameSequence mFrameSequence;
+    private final FrameSequence.State mFrameSequenceState;
+    private final Paint mPaint;
+    private BitmapShader mFrontBitmapShader;
+    private BitmapShader mBackBitmapShader;
+    private final Rect mSrcRect;
+    private boolean mCircleMaskEnabled;
+    private final Object mLock;
+    private final BitmapProvider mBitmapProvider;
+    private boolean mDestroyed;
+    private Bitmap mFrontBitmap;
+    private Bitmap mBackBitmap;
+    private static final int STATE_SCHEDULED = 1;
+    private static final int STATE_DECODING = 2;
+    private static final int STATE_WAITING_TO_SWAP = 3;
+    private static final int STATE_READY_TO_SWAP = 4;
+    private int mState;
+    private int mCurrentLoop;
+    private int mLoopBehavior;
+    private long mLastSwap;
+    private long mNextSwap;
+    private int mNextFrameToDecode;
+    private OnFinishedListener mOnFinishedListener;
+    private Runnable mDecodeRunnable;
+    private Runnable mCallbackRunnable;
+
+    private static void initializeDecodingThread() {
+        synchronized(sLock) {
+            if (sDecodingThread == null) {
+                sDecodingThread = new HandlerThread("FrameSequence decoding thread", 10);
+                sDecodingThread.start();
+                sDecodingThreadHandler = new Handler(sDecodingThread.getLooper());
+            }
+        }
+    }
+
+    public void setOnFinishedListener(OnFinishedListener onFinishedListener) {
+        this.mOnFinishedListener = onFinishedListener;
+    }
+
+    public void setLoopBehavior(int loopBehavior) {
+        this.mLoopBehavior = loopBehavior;
+    }
+
+    private static Bitmap acquireAndValidateBitmap(BitmapProvider bitmapProvider, int minWidth, int minHeight) {
+        Bitmap bitmap = bitmapProvider.acquireBitmap(minWidth, minHeight);
+        if (bitmap.getWidth() >= minWidth && bitmap.getHeight() >= minHeight && bitmap.getConfig() == Config.ARGB_8888) {
+            return bitmap;
+        } else {
+            throw new IllegalArgumentException("Invalid bitmap provided");
+        }
+    }
+
+    public FrameSequenceDrawable(FrameSequence frameSequence) {
+        this(frameSequence, sAllocatingBitmapProvider);
+    }
+
+    public FrameSequenceDrawable(FrameSequence frameSequence, BitmapProvider bitmapProvider) {
+        this.mLock = new Object();
+        this.mDestroyed = false;
+        this.mLoopBehavior = 3;
+        this.mDecodeRunnable = new Runnable() {
+            public void run() {
+                int nextFrame;
+                Bitmap bitmap;
+                synchronized(FrameSequenceDrawable.this.mLock) {
+                    if (FrameSequenceDrawable.this.mDestroyed) {
+                        return;
+                    }
+
+                    nextFrame = FrameSequenceDrawable.this.mNextFrameToDecode;
+                    if (nextFrame < 0) {
+                        return;
+                    }
+
+                    bitmap = FrameSequenceDrawable.this.mBackBitmap;
+                    FrameSequenceDrawable.this.mState = 2;
+                }
+
+                int lastFrame = nextFrame - 2;
+                long invalidateTimeMs = FrameSequenceDrawable.this.mFrameSequenceState.getFrame(nextFrame, bitmap, lastFrame);
+                if (invalidateTimeMs < 20L) {
+                    invalidateTimeMs = 100L;
+                }
+
+                boolean schedule = false;
+                Bitmap bitmapToRelease = null;
+                synchronized(FrameSequenceDrawable.this.mLock) {
+                    if (FrameSequenceDrawable.this.mDestroyed) {
+                        bitmapToRelease = FrameSequenceDrawable.this.mBackBitmap;
+                        FrameSequenceDrawable.this.mBackBitmap = null;
+                    } else if (FrameSequenceDrawable.this.mNextFrameToDecode >= 0 && FrameSequenceDrawable.this.mState == 2) {
+                        schedule = true;
+                        FrameSequenceDrawable.this.mNextSwap = invalidateTimeMs + FrameSequenceDrawable.this.mLastSwap;
+                        FrameSequenceDrawable.this.mState = 3;
+                    }
+                }
+
+                if (schedule) {
+                    FrameSequenceDrawable.this.scheduleSelf(FrameSequenceDrawable.this, FrameSequenceDrawable.this.mNextSwap);
+                }
+
+                if (bitmapToRelease != null) {
+                    FrameSequenceDrawable.this.mBitmapProvider.releaseBitmap(bitmapToRelease);
+                }
+
+            }
+        };
+        this.mCallbackRunnable = new Runnable() {
+            public void run() {
+                if (FrameSequenceDrawable.this.mOnFinishedListener != null) {
+                    FrameSequenceDrawable.this.mOnFinishedListener.onFinished(FrameSequenceDrawable.this);
+                }
+
+            }
+        };
+        if (frameSequence != null && bitmapProvider != null) {
+            this.mFrameSequence = frameSequence;
+            this.mFrameSequenceState = frameSequence.createState();
+            int width = frameSequence.getWidth();
+            int height = frameSequence.getHeight();
+            this.mBitmapProvider = bitmapProvider;
+            this.mFrontBitmap = acquireAndValidateBitmap(bitmapProvider, width, height);
+            this.mBackBitmap = acquireAndValidateBitmap(bitmapProvider, width, height);
+            this.mSrcRect = new Rect(0, 0, width, height);
+            this.mPaint = new Paint();
+            this.mPaint.setFilterBitmap(true);
+            this.mFrontBitmapShader = new BitmapShader(this.mFrontBitmap, TileMode.CLAMP, TileMode.CLAMP);
+            this.mBackBitmapShader = new BitmapShader(this.mBackBitmap, TileMode.CLAMP, TileMode.CLAMP);
+            this.mLastSwap = 0L;
+            this.mNextFrameToDecode = -1;
+            this.mFrameSequenceState.getFrame(0, this.mFrontBitmap, -1);
+            initializeDecodingThread();
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public final void setCircleMaskEnabled(boolean circleMaskEnabled) {
+        this.mCircleMaskEnabled = circleMaskEnabled;
+        this.mPaint.setAntiAlias(circleMaskEnabled);
+    }
+
+    private void checkDestroyedLocked() {
+        if (this.mDestroyed) {
+            throw new IllegalStateException("Cannot perform operation on recycled drawable");
+        }
+    }
+
+    public boolean isDestroyed() {
+        synchronized(this.mLock) {
+            return this.mDestroyed;
+        }
+    }
+
+    public void destroy() {
+        if (this.mBitmapProvider == null) {
+            throw new IllegalStateException("BitmapProvider must be non-null");
+        } else {
+            Bitmap bitmapToReleaseB = null;
+            Bitmap bitmapToReleaseA;
+            synchronized(this.mLock) {
+                this.checkDestroyedLocked();
+                bitmapToReleaseA = this.mFrontBitmap;
+                this.mFrontBitmap = null;
+                if (this.mState != 2) {
+                    bitmapToReleaseB = this.mBackBitmap;
+                    this.mBackBitmap = null;
+                }
+
+                this.mDestroyed = true;
+            }
+
+            this.mBitmapProvider.releaseBitmap(bitmapToReleaseA);
+            if (bitmapToReleaseB != null) {
+                this.mBitmapProvider.releaseBitmap(bitmapToReleaseB);
+            }
+
+        }
+    }
+
+    protected void finalize() throws Throwable {
+        try {
+            this.mFrameSequenceState.destroy();
+        } finally {
+            super.finalize();
+        }
+
+    }
+
+    public void draw(Canvas canvas) {
+        synchronized(this.mLock) {
+            this.checkDestroyedLocked();
+            if (this.mState == 3 && this.mNextSwap - SystemClock.uptimeMillis() <= 0L) {
+                this.mState = 4;
+            }
+
+            if (this.isRunning() && this.mState == 4) {
+                Bitmap tmp = this.mBackBitmap;
+                this.mBackBitmap = this.mFrontBitmap;
+                this.mFrontBitmap = tmp;
+                BitmapShader tmpShader = this.mBackBitmapShader;
+                this.mBackBitmapShader = this.mFrontBitmapShader;
+                this.mFrontBitmapShader = tmpShader;
+                this.mLastSwap = SystemClock.uptimeMillis();
+                boolean continueLooping = true;
+                if (this.mNextFrameToDecode == this.mFrameSequence.getFrameCount() - 1) {
+                    ++this.mCurrentLoop;
+                    if (this.mLoopBehavior == 1 && this.mCurrentLoop == 1 || this.mLoopBehavior == 3 && this.mCurrentLoop == this.mFrameSequence.getDefaultLoopCount()) {
+                        continueLooping = false;
+                    }
+                }
+
+                if (continueLooping) {
+                    this.scheduleDecodeLocked();
+                } else {
+                    this.scheduleSelf(this.mCallbackRunnable, 0L);
+                }
+            }
+        }
+
+        if (this.mCircleMaskEnabled) {
+            Rect bounds = this.getBounds();
+            this.mPaint.setShader(this.mFrontBitmapShader);
+            float width = (float)bounds.width();
+            float height = (float)bounds.height();
+            float circleRadius = Math.min(width, height) / 2.0F;
+            canvas.drawCircle(width / 2.0F, height / 2.0F, circleRadius, this.mPaint);
+        } else {
+            this.mPaint.setShader((Shader)null);
+            canvas.drawBitmap(this.mFrontBitmap, this.mSrcRect, this.getBounds(), this.mPaint);
+        }
+
+    }
+
+    private void scheduleDecodeLocked() {
+        this.mState = 1;
+        this.mNextFrameToDecode = (this.mNextFrameToDecode + 1) % this.mFrameSequence.getFrameCount();
+        sDecodingThreadHandler.post(this.mDecodeRunnable);
+    }
+
+    public void run() {
+        boolean invalidate = false;
+        synchronized(this.mLock) {
+            if (this.mNextFrameToDecode >= 0 && this.mState == 3) {
+                this.mState = 4;
+                invalidate = true;
+            }
+        }
+
+        if (invalidate) {
+            this.invalidateSelf();
+        }
+
+    }
+
+    public void start() {
+        if (!this.isRunning()) {
+            synchronized(this.mLock) {
+                this.checkDestroyedLocked();
+                if (this.mState == 1) {
+                    return;
+                }
+
+                this.mCurrentLoop = 0;
+                this.scheduleDecodeLocked();
+            }
+        }
+
+    }
+
+    public void stop() {
+        if (this.isRunning()) {
+            this.unscheduleSelf(this);
+        }
+
+    }
+
+    public boolean isRunning() {
+        synchronized(this.mLock) {
+            return this.mNextFrameToDecode > -1 && !this.mDestroyed;
+        }
+    }
+
+    public void unscheduleSelf(Runnable what) {
+        synchronized(this.mLock) {
+            this.mNextFrameToDecode = -1;
+            this.mState = 0;
+        }
+
+        super.unscheduleSelf(what);
+    }
+
+    public boolean setVisible(boolean visible, boolean restart) {
+        boolean changed = super.setVisible(visible, restart);
+        if (!visible) {
+            this.stop();
+        } else if (restart || changed) {
+            this.stop();
+            this.start();
+        }
+
+        return changed;
+    }
+
+    public void setFilterBitmap(boolean filter) {
+        this.mPaint.setFilterBitmap(filter);
+    }
+
+    public void setAlpha(int alpha) {
+        this.mPaint.setAlpha(alpha);
+    }
+
+    public void setColorFilter(ColorFilter colorFilter) {
+        this.mPaint.setColorFilter(colorFilter);
+    }
+
+    public int getIntrinsicWidth() {
+        return this.mFrameSequence.getWidth();
+    }
+
+    public int getIntrinsicHeight() {
+        return this.mFrameSequence.getHeight();
+    }
+
+    public int getOpacity() {
+        return this.mFrameSequence.isOpaque() ? -1 : -2;
+    }
+
+    public FrameSequence getFramSequence() {
+        return this.mFrameSequence;
+    }
+
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
+
+    public interface BitmapProvider {
+        Bitmap acquireBitmap(int var1, int var2);
+
+        void releaseBitmap(Bitmap var1);
+    }
+
+    public interface OnFinishedListener {
+        void onFinished(FrameSequenceDrawable var1);
+    }
+}

package/rules/.source/sdk/support/gif-view/src/main/java/com/quicktvui/support/gif/ESGifViewComponent.java

@@ -0,0 +1,49 @@
+package com.quicktvui.support.gif;
+
+import android.content.Context;
+import com.quicktvui.rastermill.FrameSequenceDrawable;
+import android.text.TextUtils;
+
+import com.quicktvui.sdk.annotations.ESKitAutoRegister;
+import com.quicktvui.sdk.base.EsPromise;
+import com.quicktvui.sdk.base.args.EsArray;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.base.component.EsComponentAttribute;
+import com.quicktvui.sdk.base.component.IEsComponent;
+
+import com.quicktvui.giflibrary.GifImageLoader;
+
+@ESKitAutoRegister
+public class ESGifViewComponent implements IEsComponent<GifView> {
+
+    private Context context;
+
+    @Override
+    public GifView createView(Context context, EsMap params) {
+        this.context = context;
+        return new GifView(context);
+    }
+
+
+    @EsComponentAttribute
+    public void url(GifView gifView, String url) {
+        try {
+            if (TextUtils.isEmpty(url)) {
+                return;
+            }
+            GifImageLoader.display(context, url, gifView, FrameSequenceDrawable.LOOP_INF);
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void dispatchFunction(GifView view, String eventName, EsArray params, EsPromise promise) {
+
+    }
+
+    @Override
+    public void destroy(GifView view) {
+
+    }
+}

package/rules/.source/sdk/support/gif-view/src/main/java/com/quicktvui/support/gif/GifView.java

@@ -0,0 +1,24 @@
+package com.quicktvui.support.gif;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.widget.ImageView;
+
+import com.quicktvui.sdk.base.component.IEsComponentView;
+
+
+public class GifView extends ImageView implements IEsComponentView {
+
+    public GifView(Context context) {
+        super(context);
+    }
+
+    public GifView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public GifView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+}

package/rules/.source/sdk/support/install-manager/src/main/java/com/quicktvui/support/install/manager/ESInstallManagerModule.java

@@ -0,0 +1,143 @@
+package com.quicktvui.support.install.manager;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
+import android.widget.Toast;
+
+import android.support.v4.content.FileProvider;
+
+import com.quicktvui.sdk.annotations.ESKitAutoRegister;
+import com.quicktvui.sdk.base.EsPromise;
+import com.quicktvui.sdk.base.IEsInfo;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.base.core.EsProxy;
+import com.quicktvui.sdk.base.module.IEsModule;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Objects;
+
+
+@ESKitAutoRegister
+public class ESInstallManagerModule implements IEsModule, IEsInfo {
+    private Context mContext;
+
+    private static final String TAG = "ESInstallManagerModule";
+
+    @Override
+    public void getEsInfo(EsPromise promise) {
+
+    }
+
+    @Override
+    public void init(Context context) {
+        this.mContext = context;
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+
+    public void installPackage(String filePath, String apkName, EsPromise promise) {
+        File apkFile = new File(filePath, apkName);//data/data/包名/
+        if (!apkFile.exists()) {
+            EsMap map = new EsMap();
+            map.pushString("message", "文件不存在");
+            promise.resolve(map);
+            Toast.makeText(EsProxy.get().getContext(), "文件不存在", Toast.LENGTH_LONG).show();
+            return;
+        }
+        Intent intent = null;
+        Uri uri = null;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            intent = new Intent(Intent.ACTION_VIEW);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            if (mContext != null) {
+                uri = FileProvider.getUriForFile(Objects.requireNonNull(EsProxy.get().getContext()), mContext.getApplicationContext().getPackageName() + ".fileProvider", apkFile);
+            } else {
+                uri = FileProvider.getUriForFile(Objects.requireNonNull(EsProxy.get().getContext()), EsProxy.get().getContext().getApplicationContext().getPackageName() + ".fileProvider", apkFile);
+            }
+            intent.setDataAndType(uri, "application/vnd.android.package-archive");
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        } else {
+            intent = new Intent(Intent.ACTION_VIEW);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            intent.setDataAndType(Uri.fromFile(apkFile), "application/vnd.android.package-archive");
+        }
+        try {
+            Objects.requireNonNull(EsProxy.get().getContext()).startActivity(intent);
+        } catch (Exception e) {
+            e.printStackTrace();
+            Toast.makeText(EsProxy.get().getContext(), "安装包异常", Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    public void installESPackage(String filePath, String apkName, EsPromise promise) {
+        File apkFile = new File(filePath, apkName);//data/data/包名/
+        if (!apkFile.exists()) {
+            EsMap map = new EsMap();
+            map.pushString("message", "文件不存在");
+            promise.resolve(map);
+            Toast.makeText(EsProxy.get().getContext(), "文件不存在", Toast.LENGTH_LONG).show();
+            return;
+        }
+        Intent intent = null;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            intent = new Intent(Intent.ACTION_VIEW);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            Uri uri = FileProvider.getUriForFile(Objects.requireNonNull(EsProxy.get().getContext()), "eskit.sdk.support.install.manager.fileProvider", apkFile);
+            intent.setDataAndType(uri, "application/vnd.android.package-archive");
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        } else {
+            intent = new Intent();
+            Uri uri = Uri.fromFile(apkFile);
+            intent.setClassName("com.android.packageinstaller", "com.android.packageinstaller.PackageInstallerActivity");
+            intent.setData(uri);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        }
+        try {
+            Objects.requireNonNull(EsProxy.get().getContext()).startActivity(intent);
+        } catch (Exception e) {
+            e.printStackTrace();
+            Toast.makeText(EsProxy.get().getContext(), "安装包异常", Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private static Uri getApkUri(File apkFile) {
+        Log.d(TAG, apkFile.toString());
+        //如果没有设置 SDCard 写权限，或者没有 SDCard,apk 文件保存在内存中，需要授予权限才能安装
+        try {
+            String[] command = {"chmod", "777", apkFile.toString()};
+            ProcessBuilder builder = new ProcessBuilder(command);
+            builder.start();
+        } catch (IOException ignored) {
+        }
+        Uri uri = Uri.fromFile(apkFile);
+        Log.d(TAG, uri.toString());
+        return uri;
+    }
+
+    /**
+     * @param permission
+     * @param path
+     */
+    public void chmod(String permission, String path, Intent intent) {
+        try {
+            String command = "chmod " + permission + " " + path;
+            Runtime runtime = Runtime.getRuntime();
+            Process p = runtime.exec(command);
+            int state = p.waitFor();
+            if (state == 0) {
+                Toast.makeText(EsProxy.get().getContext(), "权限修改成功", Toast.LENGTH_SHORT).show();
+            } else {
+                Toast.makeText(EsProxy.get().getContext(), "权限修改失败", Toast.LENGTH_SHORT).show();
+            }
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}