@quicktvui/ai 1.0.7 → 1.0.8

package/rules/.source/hippy/hippy_views/videoview/VideoHippyViewController.java

@@ -0,0 +1,236 @@
+package com.tencent.mtt.hippy.views.videoview;
+
+import android.content.Context;
+import android.view.View;
+
+import com.tencent.mtt.hippy.annotation.HippyController;
+import com.tencent.mtt.hippy.annotation.HippyControllerProps;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.HippyViewController;
+
+@HippyController(name = VideoHippyViewController.CLASS_NAME)
+public class VideoHippyViewController extends HippyViewController<VideoHippyView> {
+
+    public static final String	CLASS_NAME						= "VideoView_";
+    public static final String PROP_SRC = "src";
+    public static final String PROP_SRC_URI = "uri";
+    public static final String PROP_SRC_TYPE = "type";
+    public static final String PROP_SRC_HEADERS = "requestHeaders";
+    public static final String PROP_SRC_IS_NETWORK = "isNetwork";
+    public static final String PROP_SRC_MAINVER = "mainVer";
+    public static final String PROP_SRC_PATCHVER = "patchVer";
+    public static final String PROP_SRC_IS_ASSET = "isAsset";
+    public static final String PROP_RESIZE_MODE = "resizeMode";
+    public static final String PROP_REPEAT = "loop";
+    public static final String PROP_PAUSED = "paused";
+    public static final String PROP_POSTER = "poster";
+    public static final String PROP_AUTOPLAY = "autoPlay";
+    public static final String PROP_MUTED = "muted";
+    public static final String PROP_VOLUME = "volume";
+    public static final String PROP_STEREO_PAN = "stereoPan";
+    public static final String PROP_PROGRESS_UPDATE_INTERVAL = "progressUpdateInterval";
+    public static final String PROP_SEEK = "seek";
+    public static final String PROP_RATE = "rate";
+    public static final String PROP_FULLSCREEN = "fullscreen";
+    public static final String PROP_PLAY_IN_BACKGROUND = "playInBackground";
+    public static final String PROP_CONTROLS = "controls";
+
+
+
+    public static final String OP_PLAY = "play";
+    public static final String OP_PAUSE = "pause";
+    public static final String OP_RESUME = "resume";
+    public static final String OP_SEEKTO = "seek";
+    public static final String OP_RESET ="reset";
+    public static final String OP_STOP = "stop";
+    public static final String OP_RELEASE = "release";
+    public static final String OP_PLAY_DELAY = "playDelay";
+    public static final String OP_IS_PLAY = "isPlay";
+    public static final String OP_PLAY_PAUSE = "playOrPause";
+    public static final String OP_SHOW_CONTROLLER = "showController";
+    public static final String OP_HIDE_CONTROLLER = "hideController";
+
+    private int playDelayed = 50;
+
+    @Override
+    protected View createViewImpl(Context context, HippyMap iniProps)
+    {
+        VideoHippyView view = new VideoHippyView(context);
+        return view;
+    }
+
+    @Override
+    protected View createViewImpl(Context context)
+    {
+        return null;
+    }
+
+    @HippyControllerProps(name = PROP_POSTER)
+    public void setPoster(final VideoHippyView videoView, String source){
+      videoView.setPoster(source);
+    }
+
+    @HippyControllerProps(name = PROP_SRC)
+    public void setSrc(final VideoHippyView videoView,  String source) {
+//        int mainVer = 0;
+//        int patchVer = 0;
+//        if(mainVer<0) { mainVer = 0; }
+//        if(patchVer<0) { patchVer = 0; }
+
+        if(playTask != null){
+          videoView.removeCallbacks(playTask);
+        }
+        playTask = new PlayTask(videoView,source);
+
+        videoView.postDelayed(playTask,playDelayed);
+
+    }
+
+    @HippyControllerProps(name = PROP_RESIZE_MODE)
+    public void setResizeMode(final VideoHippyView videoView, final String resizeModeOrdinalString) {
+        videoView.setResizeModeModifier(ScalableType.values()[Integer.parseInt(resizeModeOrdinalString)]);
+    }
+
+    @HippyControllerProps(name = PROP_REPEAT,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setRepeat(final VideoHippyView videoView, final boolean repeat) {
+        videoView.setRepeatModifier(repeat);
+    }
+
+    @HippyControllerProps(name = PROP_PAUSED,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setPaused(final VideoHippyView videoView, final boolean paused) {
+        videoView.setPausedModifier(paused);
+    }
+
+    @HippyControllerProps(name = PROP_MUTED,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setMuted(final VideoHippyView videoView, final boolean muted) {
+        videoView.setMutedModifier(muted);
+    }
+
+    @HippyControllerProps(name = PROP_VOLUME,defaultType = HippyControllerProps.NUMBER,defaultNumber = 1.0f)
+    public void setVolume(final VideoHippyView videoView, final float volume) {
+        videoView.setVolumeModifier(volume);
+    }
+
+    @HippyControllerProps(name = PROP_STEREO_PAN)
+    public void setStereoPan(final VideoHippyView videoView, final float stereoPan) {
+        videoView.setStereoPan(stereoPan);
+    }
+
+    @HippyControllerProps(name = PROP_PROGRESS_UPDATE_INTERVAL,defaultType = HippyControllerProps.NUMBER, defaultNumber = 250.0f)
+    public void setProgressUpdateInterval(final VideoHippyView videoView, final float progressUpdateInterval) {
+        videoView.setProgressUpdateInterval(progressUpdateInterval);
+    }
+
+    @HippyControllerProps(name = PROP_SEEK)
+    public void setSeek(final VideoHippyView videoView, final float seek) {
+        videoView.seekTo(Math.round(seek * 1000.0f));
+    }
+
+    @HippyControllerProps(name = PROP_RATE,defaultType = HippyControllerProps.NUMBER,defaultNumber = 0.0f)
+    public void setRate(final VideoHippyView videoView, final float rate) {
+        videoView.setRateModifier(rate);
+    }
+
+    @HippyControllerProps(name = PROP_FULLSCREEN,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setFullscreen(final VideoHippyView videoView, final boolean fullscreen) {
+        videoView.setFullscreen(fullscreen);
+    }
+
+    @HippyControllerProps(name = PROP_PLAY_IN_BACKGROUND,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setPlayInBackground(final VideoHippyView videoView, final boolean playInBackground) {
+        videoView.setPlayInBackground(playInBackground);
+    }
+
+    @HippyControllerProps(name = PROP_CONTROLS,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setControls(final VideoHippyView videoView, final boolean controls) {
+        // NOT SUPPORT Yet
+         videoView.setControls(controls);
+    }
+
+    @HippyControllerProps(name = PROP_AUTOPLAY,defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+    public void setAutoPlay(final VideoHippyView videoView, final boolean autoPlay) {
+         videoView.setAutoPlay(autoPlay);
+    }
+    @Override
+    public void dispatchFunction(final  VideoHippyView view, String functionName, HippyArray var, Promise promise)
+    {
+        switch (functionName)
+        {
+            case OP_PLAY:
+                view.applyModifiers(false);
+                break;
+            case OP_PAUSE:
+                view.pause();
+                break;
+            case OP_RESUME:
+                view.start();
+                break;
+            case OP_STOP:
+                view.stop();
+                break;
+            case OP_RELEASE:
+                view.release();
+                break;
+            case OP_SEEKTO:
+                view.seekTo(var.getInt(0));
+                break;
+            case OP_RESET:
+                view.reset();
+                break;
+            case OP_IS_PLAY:
+                if(promise != null) {
+                    promise.resolve(view.isPlaying());
+                }
+                break;
+            case OP_PLAY_PAUSE:
+                if (view.isPlaying()) {
+                    view.pause();
+                }else{
+                    view.start();
+                }
+                break;
+            case OP_SHOW_CONTROLLER:
+                view.setControlVisible(true);
+                break;
+            case OP_HIDE_CONTROLLER:
+                view.setControlVisible(false);
+                break;
+        }
+    }
+
+    /***zhaopeng add*/
+    private static class PlayTask implements Runnable{
+
+      final VideoHippyView videoView;
+      final String source ;
+
+      private PlayTask(VideoHippyView videoView, String source) {
+        this.videoView = videoView;
+        this.source = source;
+      }
+
+      @Override
+      public void run() {
+        videoView.setSrc(
+          source,
+          "mp4",
+          true,
+          false,
+          new HippyMap(),
+          0,
+          0
+        );
+      }
+    }
+
+    private Runnable playTask;
+
+  @HippyControllerProps(name = OP_PLAY_DELAY,defaultType = HippyControllerProps.NUMBER, defaultNumber = 300)
+  public void setPlayDelay(final VideoHippyView videoView, final int delay) {
+    this.playDelayed = delay;
+  }
+
+}
+

package/rules/.source/hippy/hippy_views/videoview/ZipResourceFile.java

@@ -0,0 +1,427 @@
+package com.tencent.mtt.hippy.views.videoview;
+
+/*
+ * Copyright (C) 2012 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.
+ */
+
+import android.content.res.AssetFileDescriptor;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Vector;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class ZipResourceFile {
+
+    //
+    // Read-only access to Zip archives, with minimal heap allocation.
+    //
+    static final String LOG_TAG = "zipro";
+    static final boolean LOGV = false;
+
+    // 4-byte number
+    static private int swapEndian(int i)
+    {
+        return ((i & 0xff) << 24) + ((i & 0xff00) << 8) + ((i & 0xff0000) >>> 8)
+                + ((i >>> 24) & 0xff);
+    }
+
+    // 2-byte number
+    static private int swapEndian(short i)
+    {
+        return ((i & 0x00FF) << 8 | (i & 0xFF00) >>> 8);
+    }
+
+    /*
+     * Zip file constants.
+     */
+    static final int kEOCDSignature = 0x06054b50;
+    static final int kEOCDLen = 22;
+    static final int kEOCDNumEntries = 8; // offset to #of entries in file
+    static final int kEOCDSize = 12; // size of the central directory
+    static final int kEOCDFileOffset = 16; // offset to central directory
+
+    static final int kMaxCommentLen = 65535; // longest possible in ushort
+    static final int kMaxEOCDSearch = (kMaxCommentLen + kEOCDLen);
+
+    static final int kLFHSignature = 0x04034b50;
+    static final int kLFHLen = 30; // excluding variable-len fields
+    static final int kLFHNameLen = 26; // offset to filename length
+    static final int kLFHExtraLen = 28; // offset to extra length
+
+    static final int kCDESignature = 0x02014b50;
+    static final int kCDELen = 46; // excluding variable-len fields
+    static final int kCDEMethod = 10; // offset to compression method
+    static final int kCDEModWhen = 12; // offset to modification timestamp
+    static final int kCDECRC = 16; // offset to entry CRC
+    static final int kCDECompLen = 20; // offset to compressed length
+    static final int kCDEUncompLen = 24; // offset to uncompressed length
+    static final int kCDENameLen = 28; // offset to filename length
+    static final int kCDEExtraLen = 30; // offset to extra length
+    static final int kCDECommentLen = 32; // offset to comment length
+    static final int kCDELocalOffset = 42; // offset to local hdr
+
+    static final int kCompressStored = 0; // no compression
+    static final int kCompressDeflated = 8; // standard deflate
+
+    /*
+     * The values we return for ZipEntryRO use 0 as an invalid value, so we want
+     * to adjust the hash table index by a fixed amount. Using a large value
+     * helps insure that people don't mix & match arguments, e.g. to
+     * findEntryByIndex().
+     */
+    static final int kZipEntryAdj = 10000;
+
+    static public final class ZipEntryRO {
+        public ZipEntryRO(final String zipFileName, final File file, final String fileName) {
+            mFileName = fileName;
+            mZipFileName = zipFileName;
+            mFile = file;
+        }
+
+        public final File mFile;
+        public final String mFileName;
+        public final String mZipFileName;
+        public long mLocalHdrOffset; // offset of local file header
+
+        /* useful stuff from the directory entry */
+        public int mMethod;
+        public long mWhenModified;
+        public long mCRC32;
+        public long mCompressedLength;
+        public long mUncompressedLength;
+
+        public long mOffset = -1;
+
+        public void setOffsetFromFile(RandomAccessFile f, ByteBuffer buf) throws IOException {
+            long localHdrOffset = mLocalHdrOffset;
+            try {
+                f.seek(localHdrOffset);
+                f.readFully(buf.array());
+                if (buf.getInt(0) != kLFHSignature) {
+                    Log.w(LOG_TAG, "didn't find signature at start of lfh");
+                    throw new IOException();
+                }
+                int nameLen = buf.getShort(kLFHNameLen) & 0xFFFF;
+                int extraLen = buf.getShort(kLFHExtraLen) & 0xFFFF;
+                mOffset = localHdrOffset + kLFHLen + nameLen + extraLen;
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+            } catch (IOException ioe) {
+                ioe.printStackTrace();
+            }
+        }
+
+        /**
+         * Calculates the offset of the start of the Zip file entry within the
+         * Zip file.
+         * 
+         * @return the offset, in bytes from the start of the file of the entry
+         */
+        public long getOffset() {
+            return mOffset;
+        }
+
+        /**
+         * isUncompressed
+         * 
+         * @return true if the file is stored in uncompressed form
+         */
+        public boolean isUncompressed() {
+            return mMethod == kCompressStored;
+        }
+
+        public AssetFileDescriptor getAssetFileDescriptor() {
+            if (mMethod == kCompressStored) {
+                ParcelFileDescriptor pfd;
+                try {
+                    pfd = ParcelFileDescriptor.open(mFile, ParcelFileDescriptor.MODE_READ_ONLY);
+                    return new AssetFileDescriptor(pfd, getOffset(), mUncompressedLength);
+                } catch (FileNotFoundException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return null;
+        }
+
+        public String getZipFileName() {
+            return mZipFileName;
+        }
+
+        public File getZipFile() {
+            return mFile;
+        }
+
+    }
+
+    private final HashMap<String, ZipEntryRO> mHashMap = new HashMap<String, ZipEntryRO>();
+
+    /* for reading compressed files */
+    public HashMap<File, ZipFile> mZipFiles = new HashMap<File, ZipFile>();
+
+    public ZipResourceFile(String zipFileName) throws IOException {
+        addPatchFile(zipFileName);
+    }
+
+    ZipEntryRO[] getEntriesAt(String path) {
+        Vector<ZipEntryRO> zev = new Vector<ZipEntryRO>();
+        Collection<ZipEntryRO> values = mHashMap.values();
+        if (null == path)
+            path = "";
+        int length = path.length();
+        for (ZipEntryRO ze : values) {
+            if (ze.mFileName.startsWith(path)) {
+                if (-1 == ze.mFileName.indexOf('/', length)) {
+                    zev.add(ze);
+                }
+            }
+        }
+        ZipEntryRO[] entries = new ZipEntryRO[zev.size()];
+        return zev.toArray(entries);
+    }
+
+    public ZipEntryRO[] getAllEntries() {
+        Collection<ZipEntryRO> values = mHashMap.values();
+        return values.toArray(new ZipEntryRO[values.size()]);
+    }
+
+    /**
+     * getAssetFileDescriptor allows for ZipResourceFile to directly feed
+     * Android API's that want an fd, offset, and length such as the
+     * MediaPlayer. It also allows for the class to be used in a content
+     * provider that can feed video players. The file must be stored
+     * (non-compressed) in the Zip file for this to work.
+     * 
+     * @param assetPath
+     * @return the asset file descriptor for the file, or null if the file isn't
+     *         present or is stored compressed
+     */
+    public AssetFileDescriptor getAssetFileDescriptor(String assetPath) {
+        ZipEntryRO entry = mHashMap.get(assetPath);
+        if (null != entry) {
+            return entry.getAssetFileDescriptor();
+        }
+        return null;
+    }
+
+    /**
+     * getInputStream returns an AssetFileDescriptor.AutoCloseInputStream
+     * associated with the asset that is contained in the Zip file, or a
+     * standard ZipInputStream if necessary to uncompress the file
+     * 
+     * @param assetPath
+     * @return an input stream for the named asset path, or null if not found
+     * @throws IOException
+     */
+    public InputStream getInputStream(String assetPath) throws IOException {
+        ZipEntryRO entry = mHashMap.get(assetPath);
+        if (null != entry) {
+            if (entry.isUncompressed()) {
+                return entry.getAssetFileDescriptor().createInputStream();
+            } else {
+                ZipFile zf = mZipFiles.get(entry.getZipFile());
+                /** read compressed files **/
+                if (null == zf) {
+                    zf = new ZipFile(entry.getZipFile(), ZipFile.OPEN_READ);
+                    mZipFiles.put(entry.getZipFile(), zf);
+                }
+                ZipEntry zi = zf.getEntry(assetPath);
+                if (null != zi)
+                    return zf.getInputStream(zi);
+            }
+        }
+        return null;
+    }
+
+    ByteBuffer mLEByteBuffer = ByteBuffer.allocate(4);
+
+    static private int read4LE(RandomAccessFile f) throws IOException {
+        return swapEndian(f.readInt());
+    }
+    
+    /*
+     * Opens the specified file read-only. We memory-map the entire thing and
+     * close the file before returning.
+     */
+    void addPatchFile(String zipFileName) throws IOException
+    {
+        File file = new File(zipFileName);
+        RandomAccessFile f = new RandomAccessFile(file, "r");
+        long fileLength = f.length();
+
+        if (fileLength < kEOCDLen) {
+            throw new java.io.IOException();
+        }
+
+        long readAmount = kMaxEOCDSearch;
+        if (readAmount > fileLength)
+            readAmount = fileLength;
+
+        /*
+         * Make sure this is a Zip archive.
+         */
+        f.seek(0);
+
+        int header = read4LE(f);
+        if (header == kEOCDSignature) {
+            Log.i(LOG_TAG, "Found Zip archive, but it looks empty");
+            throw new IOException();
+        } else if (header != kLFHSignature) {
+            Log.v(LOG_TAG, "Not a Zip archive");
+            throw new IOException();
+        }
+
+        /*
+         * Perform the traditional EOCD snipe hunt. We're searching for the End
+         * of Central Directory magic number, which appears at the start of the
+         * EOCD block. It's followed by 18 bytes of EOCD stuff and up to 64KB of
+         * archive comment. We need to read the last part of the file into a
+         * buffer, dig through it to find the magic number, parse some values
+         * out, and use those to determine the extent of the CD. We start by
+         * pulling in the last part of the file.
+         */
+        long searchStart = fileLength - readAmount;
+
+        f.seek(searchStart);
+        ByteBuffer bbuf = ByteBuffer.allocate((int) readAmount);
+        byte[] buffer = bbuf.array();
+        f.readFully(buffer);
+        bbuf.order(ByteOrder.LITTLE_ENDIAN);
+
+        /*
+         * Scan backward for the EOCD magic. In an archive without a trailing
+         * comment, we'll find it on the first try. (We may want to consider
+         * doing an initial minimal read; if we don't find it, retry with a
+         * second read as above.)
+         */
+
+        // EOCD == 0x50, 0x4b, 0x05, 0x06
+        int eocdIdx;
+        for (eocdIdx = buffer.length - kEOCDLen; eocdIdx >= 0; eocdIdx--) {
+            if (buffer[eocdIdx] == 0x50 && bbuf.getInt(eocdIdx) == kEOCDSignature)
+            {
+                if (LOGV) {
+                    Log.v(LOG_TAG, "+++ Found EOCD at index: " + eocdIdx);
+                }
+                break;
+            }
+        }
+
+        if (eocdIdx < 0) {
+            Log.d(LOG_TAG, "Zip: EOCD not found, " + zipFileName + " is not zip");
+        }
+
+        /*
+         * Grab the CD offset and size, and the number of entries in the
+         * archive. After that, we can release our EOCD hunt buffer.
+         */
+
+        int numEntries = bbuf.getShort(eocdIdx + kEOCDNumEntries);
+        long dirSize = bbuf.getInt(eocdIdx + kEOCDSize) & 0xffffffffL;
+        long dirOffset = bbuf.getInt(eocdIdx + kEOCDFileOffset) & 0xffffffffL;
+
+        // Verify that they look reasonable.
+        if (dirOffset + dirSize > fileLength) {
+            Log.w(LOG_TAG, "bad offsets (dir " + dirOffset + ", size " + dirSize + ", eocd "
+                    + eocdIdx + ")");
+            throw new IOException();
+        }
+        if (numEntries == 0) {
+            Log.w(LOG_TAG, "empty archive?");
+            throw new IOException();
+        }
+
+        if (LOGV) {
+            Log.v(LOG_TAG, "+++ numEntries=" + numEntries + " dirSize=" + dirSize + " dirOffset="
+                    + dirOffset);
+        }
+
+        MappedByteBuffer directoryMap = f.getChannel()
+                .map(FileChannel.MapMode.READ_ONLY, dirOffset, dirSize);
+        directoryMap.order(ByteOrder.LITTLE_ENDIAN);
+
+        byte[] tempBuf = new byte[0xffff];
+
+        /*
+         * Walk through the central directory, adding entries to the hash table.
+         */
+
+        int currentOffset = 0;
+
+        /*
+         * Allocate the local directory information
+         */
+        ByteBuffer buf = ByteBuffer.allocate(kLFHLen);
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+
+        for (int i = 0; i < numEntries; i++) {
+            if (directoryMap.getInt(currentOffset) != kCDESignature) {
+                Log.w(LOG_TAG, "Missed a central dir sig (at " + currentOffset + ")");
+                throw new IOException();
+            }
+
+            /* useful stuff from the directory entry */
+            int fileNameLen = directoryMap.getShort(currentOffset + kCDENameLen) & 0xffff;
+            int extraLen = directoryMap.getShort(currentOffset + kCDEExtraLen) & 0xffff;
+            int commentLen = directoryMap.getShort(currentOffset + kCDECommentLen) & 0xffff;
+
+            /* get the CDE filename */
+
+            directoryMap.position(currentOffset + kCDELen);
+            directoryMap.get(tempBuf, 0, fileNameLen);
+            directoryMap.position(0);
+
+            /* UTF-8 on Android */
+            String str = new String(tempBuf, 0, fileNameLen);
+            if (LOGV) {
+                Log.v(LOG_TAG, "Filename: " + str);
+            }
+
+            ZipEntryRO ze = new ZipEntryRO(zipFileName, file, str);
+            ze.mMethod = directoryMap.getShort(currentOffset + kCDEMethod) & 0xffff;
+            ze.mWhenModified = directoryMap.getInt(currentOffset + kCDEModWhen) & 0xffffffffL;
+            ze.mCRC32 = directoryMap.getLong(currentOffset + kCDECRC) & 0xffffffffL;
+            ze.mCompressedLength = directoryMap.getLong(currentOffset + kCDECompLen) & 0xffffffffL;
+            ze.mUncompressedLength = directoryMap.getLong(currentOffset + kCDEUncompLen) & 0xffffffffL;
+            ze.mLocalHdrOffset = directoryMap.getInt(currentOffset + kCDELocalOffset) & 0xffffffffL;
+
+            // set the offsets
+            buf.clear();
+            ze.setOffsetFromFile(f, buf);
+
+            // put file into hash
+            mHashMap.put(str, ze);
+
+            // go to next directory entry
+            currentOffset += kCDELen + fileNameLen + extraLen + commentLen;
+        }
+        if (LOGV) {
+            Log.v(LOG_TAG, "+++ zip good scan " + numEntries + " entries");
+        }
+    }
+}

package/rules/.source/hippy/hippy_views/view/CardRootView.java

@@ -0,0 +1,28 @@
+package com.tencent.mtt.hippy.views.view;
+
+import android.content.Context;
+import android.util.Log;
+
+import com.tencent.extend.pm.WindowNode;
+import com.tencent.mtt.hippy.R;
+import com.tencent.mtt.hippy.uimanager.ExtendViewGroup;
+import com.tencent.mtt.hippy.utils.ExtendUtil;
+import com.tencent.mtt.hippy.utils.LogUtils;
+
+public class CardRootView extends HippyViewGroup{
+
+  public CardRootView(Context context) {
+    super(context);
+
+    if(LogUtils.isDebug()) {
+      Log.i(WindowNode.TAG, "CardRootView crate:"+ ExtendUtil.debugViewLite(this));
+    }
+    //setAsRootView();
+//    setAsRootView();
+
+    setTag(R.id.card_root_view, ExtendViewGroup.ROOT_TAG);
+    setUseAdvancedFocusSearch(true);
+  }
+
+
+}

package/rules/.source/hippy/hippy_views/view/CustomLayoutView.java

@@ -0,0 +1,10 @@
+package com.tencent.mtt.hippy.views.view;
+
+
+
+public interface CustomLayoutView {
+  String TAG = "LayoutLog";
+  void setLayoutRequestFromCustom(boolean b);
+  boolean isLayoutRequestFromCustom();
+
+}