@quicktvui/ai 1.0.7 → 1.0.8

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

@@ -0,0 +1,287 @@
+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.
+ */
+
+//To implement APEZProvider in your application, you'll want to change
+//the AUTHORITY to match what you define in the manifest.
+
+
+import android.content.ContentProvider;
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.ProviderInfo;
+import android.content.res.AssetFileDescriptor;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.provider.BaseColumns;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+
+/**
+ * This content provider is an optional part of the library.
+ * 
+ * <p>Most apps don't need to use this class. This defines a
+ * ContentProvider that marshalls the data from the ZIP files through a
+ * content provider Uri in order to provide file access for certain Android APIs 
+ * that expect Uri access to media files.
+ *
+ */
+public abstract class APEZProvider extends ContentProvider {	
+
+	private ZipResourceFile mAPKExtensionFile;
+	private boolean mInit;
+	
+	public static final String FILEID = BaseColumns._ID;
+	public static final String FILENAME = "ZPFN";
+	public static final String ZIPFILE = "ZFIL";
+	public static final String MODIFICATION = "ZMOD";
+	public static final String CRC32 = "ZCRC";
+	public static final String COMPRESSEDLEN = "ZCOL";
+	public static final String UNCOMPRESSEDLEN = "ZUNL";
+	public static final String COMPRESSIONTYPE = "ZTYP";
+	
+	public static final String[] ALL_FIELDS = {
+		FILEID,
+		FILENAME,
+		ZIPFILE,
+		MODIFICATION,
+		CRC32,
+		COMPRESSEDLEN,
+		UNCOMPRESSEDLEN,
+		COMPRESSIONTYPE
+	};
+	
+	public static final int FILEID_IDX = 0;
+	public static final int FILENAME_IDX = 1;
+	public static final int ZIPFILE_IDX = 2;
+	public static final int MOD_IDX = 3;
+	public static final int CRC_IDX = 4;
+	public static final int COMPLEN_IDX = 5;
+	public static final int UNCOMPLEN_IDX = 6;
+	public static final int COMPTYPE_IDX = 7;
+	
+	public static final int[] ALL_FIELDS_INT = {
+		FILEID_IDX,
+		FILENAME_IDX,
+		ZIPFILE_IDX,
+		MOD_IDX,
+		CRC_IDX,
+		COMPLEN_IDX,
+		UNCOMPLEN_IDX,
+		COMPTYPE_IDX
+	};
+	
+	/**
+	 * This needs to match the authority in your manifest
+	 */
+	public abstract String getAuthority();
+	
+	@Override
+	public int delete(Uri arg0, String arg1, String[] arg2) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public String getType(Uri uri) {
+		return "vnd.android.cursor.item/asset";
+	}
+
+	@Override
+	public Uri insert(Uri uri, ContentValues values) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	static private final String NO_FILE = "N";
+	
+	private boolean initIfNecessary() {
+	    if ( !mInit ) {
+            Context ctx = getContext();
+            PackageManager pm = ctx.getPackageManager();
+            ProviderInfo pi = pm.resolveContentProvider(getAuthority(), PackageManager.GET_META_DATA);
+            PackageInfo packInfo;
+            try {
+                packInfo = pm.getPackageInfo(ctx.getPackageName(), 0);
+            } catch (NameNotFoundException e1) {
+                e1.printStackTrace();
+                return false;
+            }
+            int patchFileVersion;
+            int mainFileVersion;
+            int appVersionCode = packInfo.versionCode;
+            String[] resourceFiles = null;
+            if ( null != pi.metaData ) {
+                mainFileVersion = pi.metaData.getInt("mainVersion", appVersionCode);
+                patchFileVersion = pi.metaData.getInt("patchVersion", appVersionCode);
+                String mainFileName = pi.metaData.getString("mainFilename", NO_FILE);
+                if ( NO_FILE != mainFileName ) {
+                    String patchFileName = pi.metaData.getString("patchFilename", NO_FILE);
+                    if ( NO_FILE != patchFileName ) {
+                        resourceFiles = new String[] { mainFileName, patchFileName };
+                    } else {
+                        resourceFiles = new String[] { mainFileName };
+                    }
+                }
+            } else {
+                mainFileVersion = patchFileVersion = appVersionCode;
+            }
+            try {
+                if ( null == resourceFiles ) {
+                    mAPKExtensionFile = APKExpansionSupport.getAPKExpansionZipFile(ctx, mainFileVersion, patchFileVersion);
+                } else {
+                    mAPKExtensionFile = APKExpansionSupport.getResourceZipFile(resourceFiles);
+                }
+                mInit = true;
+                return true;
+            } catch (IOException e) {
+                e.printStackTrace();                
+            }
+	    }
+        return false;	    
+	}
+
+	@Override
+	public boolean onCreate() {
+	    return true;
+	}
+
+	@Override
+	public AssetFileDescriptor openAssetFile(Uri uri, String mode)
+			throws FileNotFoundException {
+        initIfNecessary();
+		String path = uri.getEncodedPath();
+		if ( path.startsWith("/") ) {
+			path = path.substring(1);
+		}
+		return mAPKExtensionFile.getAssetFileDescriptor(path);		
+	}
+
+	@Override
+	public ContentProviderResult[] applyBatch(
+			ArrayList<ContentProviderOperation> operations)
+			throws OperationApplicationException {
+        initIfNecessary();
+		return super.applyBatch(operations);
+	}
+
+	@Override
+	public ParcelFileDescriptor openFile(Uri uri, String mode)
+			throws FileNotFoundException {
+        initIfNecessary();
+		AssetFileDescriptor af = openAssetFile(uri, mode);
+		if ( null != af ) {
+			return af.getParcelFileDescriptor();
+		}
+		return null;
+	}
+
+	@Override
+	public Cursor query(Uri uri, String[] projection, String selection,
+			String[] selectionArgs, String sortOrder) {
+	    initIfNecessary();
+		// lists all of the items in the file that match
+		ZipResourceFile.ZipEntryRO[] zipEntries;
+		if ( null == mAPKExtensionFile ) {
+			zipEntries = new ZipResourceFile.ZipEntryRO[0];
+		} else {
+			zipEntries = mAPKExtensionFile.getAllEntries();
+		}
+		int[] intProjection;
+		if ( null == projection )  {
+			intProjection = ALL_FIELDS_INT;
+			projection = ALL_FIELDS;
+		} else {
+			int len = projection.length;
+			intProjection = new int[len];
+			for ( int i = 0; i < len; i++ ) {
+				if ( projection[i].equals(FILEID) ) {
+					intProjection[i] = FILEID_IDX;
+				} else if ( projection[i].equals(FILENAME) ) {
+					intProjection[i] = FILENAME_IDX;
+				} else if ( projection[i].equals(ZIPFILE) ) {
+					intProjection[i] = ZIPFILE_IDX;
+				} else if ( projection[i].equals(MODIFICATION) ) {
+					intProjection[i] = MOD_IDX;
+				} else if ( projection[i].equals(CRC32) ) {
+					intProjection[i] = CRC_IDX;
+				} else if ( projection[i].equals(COMPRESSEDLEN) ) {
+					intProjection[i] = COMPLEN_IDX;
+				} else if ( projection[i].equals(UNCOMPRESSEDLEN) ) {
+					intProjection[i] = UNCOMPLEN_IDX;
+				} else if ( projection[i].equals(COMPRESSIONTYPE) ) {
+					intProjection[i] = COMPTYPE_IDX;
+				} else {
+					throw new RuntimeException();
+				}
+			}
+		}
+		MatrixCursor mc = new MatrixCursor(projection, zipEntries.length);
+		int len = intProjection.length;
+		for ( ZipResourceFile.ZipEntryRO zer : zipEntries ) {
+			MatrixCursor.RowBuilder rb = mc.newRow();
+			for ( int i = 0; i < len; i++ ) {				
+				switch (intProjection[i]) {
+					case FILEID_IDX:
+						rb.add(i);
+						break;
+					case FILENAME_IDX:
+						rb.add(zer.mFileName);
+						break;
+					case ZIPFILE_IDX:
+						rb.add(zer.getZipFileName());
+						break;
+					case MOD_IDX:
+						rb.add(zer.mWhenModified);
+						break;
+					case CRC_IDX:
+						rb.add(zer.mCRC32);
+						break;
+					case COMPLEN_IDX:
+						rb.add(zer.mCompressedLength);
+						break;
+					case UNCOMPLEN_IDX:
+						rb.add(zer.mUncompressedLength);
+						break;
+					case COMPTYPE_IDX:
+						rb.add(zer.mMethod);
+						break;
+				}
+			}
+		}
+		return mc;
+	}
+
+	@Override
+	public int update(Uri uri, ContentValues values, String selection,
+			String[] selectionArgs) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+}

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

@@ -0,0 +1,82 @@
+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 java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import android.content.Context;
+import android.os.Environment;
+import android.util.Log;
+
+public class APKExpansionSupport {
+	// The shared path to all app expansion files
+	private final static String EXP_PATH = "/Android/obb/";
+
+	static String[] getAPKExpansionFiles(Context ctx, int mainVersion, int patchVersion) {
+		String packageName = ctx.getPackageName();
+		Vector<String> ret = new Vector<String>();
+		if (Environment.getExternalStorageState().equals(
+				Environment.MEDIA_MOUNTED)) {
+			// Build the full path to the app's expansion files
+			File root = Environment.getExternalStorageDirectory();
+			File expPath = new File(root.toString() + EXP_PATH + packageName);
+
+			// Check that expansion file path exists
+			if (expPath.exists()) {
+				if ( mainVersion > 0 ) {
+					String strMainPath = expPath + File.separator + "main." + mainVersion + "." + packageName + ".obb";
+//					Log.d("APKEXPANSION", strMainPath);
+					File main = new File(strMainPath);
+					if ( main.isFile() ) {
+						ret.add(strMainPath);
+					}
+				}
+				if ( patchVersion > 0 ) {
+					String strPatchPath = expPath + File.separator + "patch." + patchVersion + "." + packageName + ".obb";
+					File main = new File(strPatchPath);
+					if ( main.isFile() ) {
+						ret.add(strPatchPath);
+					}
+				}
+			}
+		}
+		String[] retArray = new String[ret.size()];
+		ret.toArray(retArray);
+		return retArray;
+	}
+
+	static public ZipResourceFile getResourceZipFile(String[] expansionFiles) throws IOException {
+        ZipResourceFile apkExpansionFile = null;
+        for (String expansionFilePath : expansionFiles) {
+            if ( null == apkExpansionFile ) {
+                apkExpansionFile = new ZipResourceFile(expansionFilePath);
+            } else {
+                apkExpansionFile.addPatchFile(expansionFilePath);
+            }
+        }
+        return apkExpansionFile;
+	}
+	
+	static public ZipResourceFile getAPKExpansionZipFile(Context ctx, int mainVersion, int patchVersion) throws IOException{
+		String[] expansionFiles = getAPKExpansionFiles(ctx, mainVersion, patchVersion);
+		return getResourceZipFile(expansionFiles);
+	}
+}

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

@@ -0,0 +1,13 @@
+package com.tencent.mtt.hippy.views.videoview;
+
+public enum PivotPoint {
+    LEFT_TOP,
+    LEFT_CENTER,
+    LEFT_BOTTOM,
+    CENTER_TOP,
+    CENTER,
+    CENTER_BOTTOM,
+    RIGHT_TOP,
+    RIGHT_CENTER,
+    RIGHT_BOTTOM
+}

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

@@ -0,0 +1,34 @@
+package com.tencent.mtt.hippy.views.videoview;
+
+public enum ScalableType {
+    NONE,
+
+    FIT_XY,
+    FIT_START,
+    FIT_CENTER,
+    FIT_END,
+
+    LEFT_TOP,
+    LEFT_CENTER,
+    LEFT_BOTTOM,
+    CENTER_TOP,
+    CENTER,
+    CENTER_BOTTOM,
+    RIGHT_TOP,
+    RIGHT_CENTER,
+    RIGHT_BOTTOM,
+
+    LEFT_TOP_CROP,
+    LEFT_CENTER_CROP,
+    LEFT_BOTTOM_CROP,
+    CENTER_TOP_CROP,
+    CENTER_CROP,
+    CENTER_BOTTOM_CROP,
+    RIGHT_TOP_CROP,
+    RIGHT_CENTER_CROP,
+    RIGHT_BOTTOM_CROP,
+
+    START_INSIDE,
+    CENTER_INSIDE,
+    END_INSIDE
+}

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

@@ -0,0 +1,265 @@
+package com.tencent.mtt.hippy.views.videoview;
+
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.AssetManager;
+import android.content.res.TypedArray;
+import android.graphics.Matrix;
+import android.graphics.SurfaceTexture;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.util.AttributeSet;
+import android.view.Surface;
+import android.view.TextureView;
+
+import com.tencent.mtt.hippy.R;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.util.Map;
+
+public class ScalableVideoView extends TextureView implements TextureView.SurfaceTextureListener,
+        MediaPlayer.OnVideoSizeChangedListener {
+
+    protected MediaPlayer mMediaPlayer;
+    protected ScalableType mScalableType = ScalableType.NONE;
+  private String mPosterUri;
+
+  public ScalableVideoView(Context context) {
+        this(context, null);
+    }
+
+    public ScalableVideoView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public ScalableVideoView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+
+        if (attrs == null) {
+            return;
+        }
+
+        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.scaleStyle, 0, 0);
+        if (a == null) {
+            return;
+        }
+
+        int scaleType = a.getInt(R.styleable.scaleStyle_scalableType, ScalableType.NONE.ordinal());
+        a.recycle();
+        mScalableType = ScalableType.values()[scaleType];
+    }
+
+    @Override
+    public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
+        Surface surface = new Surface(surfaceTexture);
+        if (mMediaPlayer != null) {
+            mMediaPlayer.setSurface(surface);
+        }
+
+//      if(!TextUtils.isEmpty(mPosterUri)){
+//        Canvas canvas = surface.lockHardwareCanvas();
+//        Paint paint = new Paint();
+//        paint.setColor(Color.RED);
+//        canvas.drawText(mPosterUri, 0, 0, paint);
+//        surface.unlockCanvasAndPost(canvas);
+//      }
+    }
+
+    @Override
+    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+    }
+
+    @Override
+    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+        return false;
+    }
+
+    @Override
+    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        if (mMediaPlayer == null) {
+            return;
+        }
+
+        if (isPlaying()) {
+            stop();
+        }
+        release();
+    }
+
+    @Override
+    public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
+        scaleVideoSize(width, height);
+    }
+
+    private void scaleVideoSize(int videoWidth, int videoHeight) {
+        if (videoWidth == 0 || videoHeight == 0) {
+            return;
+        }
+
+        Size viewSize = new Size(getWidth(), getHeight());
+        Size videoSize = new Size(videoWidth, videoHeight);
+        ScaleManager scaleManager = new ScaleManager(viewSize, videoSize);
+        Matrix matrix = scaleManager.getScaleMatrix(mScalableType);
+        if (matrix != null) {
+            setTransform(matrix);
+        }
+    }
+
+    private void initializeMediaPlayer() {
+        if (mMediaPlayer == null) {
+            mMediaPlayer = new MediaPlayer();
+            mMediaPlayer.setOnVideoSizeChangedListener(this);
+            setSurfaceTextureListener(this);
+        } else {
+            reset();
+        }
+    }
+
+    public void setRawData( int id) throws IOException {
+        AssetFileDescriptor afd = getResources().openRawResourceFd(id);
+        setDataSource(afd);
+    }
+
+    public void setAssetData( String assetName) throws IOException {
+        AssetManager manager = getContext().getAssets();
+        AssetFileDescriptor afd = manager.openFd(assetName);
+        setDataSource(afd);
+    }
+
+    private void setDataSource( AssetFileDescriptor afd) throws IOException {
+        setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
+        afd.close();
+    }
+
+    public void setDataSource( String path) throws IOException {
+        initializeMediaPlayer();
+        mMediaPlayer.setDataSource(path);
+    }
+
+    public void setDataSource( Context context,  Uri uri,
+             Map<String, String> headers) throws IOException {
+        initializeMediaPlayer();
+        mMediaPlayer.setDataSource(context, uri, headers);
+    }
+
+    public void setDataSource( Context context,  Uri uri) throws IOException {
+        initializeMediaPlayer();
+        mMediaPlayer.setDataSource(context, uri);
+    }
+
+    public void setDataSource( FileDescriptor fd, long offset, long length)
+            throws IOException {
+        initializeMediaPlayer();
+        mMediaPlayer.setDataSource(fd, offset, length);
+    }
+
+    public void setDataSource( FileDescriptor fd) throws IOException {
+        initializeMediaPlayer();
+        mMediaPlayer.setDataSource(fd);
+    }
+
+    public void setScalableType(ScalableType scalableType) {
+        mScalableType = scalableType;
+        scaleVideoSize(getVideoWidth(), getVideoHeight());
+    }
+
+    public void prepare( MediaPlayer.OnPreparedListener listener)
+            throws IOException, IllegalStateException {
+        mMediaPlayer.setOnPreparedListener(listener);
+        mMediaPlayer.prepare();
+    }
+
+    public void prepareAsync( MediaPlayer.OnPreparedListener listener)
+            throws IllegalStateException {
+        mMediaPlayer.setOnPreparedListener(listener);
+        mMediaPlayer.prepareAsync();
+    }
+
+    public void prepare() throws IOException, IllegalStateException {
+        prepare(null);
+    }
+
+    public void prepareAsync() throws IllegalStateException {
+        prepareAsync(null);
+    }
+
+    public void setOnErrorListener( MediaPlayer.OnErrorListener listener) {
+        mMediaPlayer.setOnErrorListener(listener);
+    }
+
+    public void setOnCompletionListener( MediaPlayer.OnCompletionListener listener) {
+        mMediaPlayer.setOnCompletionListener(listener);
+    }
+
+    public void setOnInfoListener( MediaPlayer.OnInfoListener listener) {
+        mMediaPlayer.setOnInfoListener(listener);
+    }
+
+    public int getCurrentPosition() {
+        return mMediaPlayer.getCurrentPosition();
+    }
+
+    public int getDuration() {
+        return mMediaPlayer.getDuration();
+    }
+
+    public int getVideoHeight() {
+        return mMediaPlayer.getVideoHeight();
+    }
+
+    public int getVideoWidth() {
+        return mMediaPlayer.getVideoWidth();
+    }
+
+    public boolean isLooping() {
+        return mMediaPlayer.isLooping();
+    }
+
+    public boolean isPlaying() {
+        return mMediaPlayer.isPlaying();
+    }
+
+    public void pause() {
+        mMediaPlayer.pause();
+    }
+
+    public void seekTo(int msec) {
+        mMediaPlayer.seekTo(msec);
+    }
+
+    public void setLooping(boolean looping) {
+        mMediaPlayer.setLooping(looping);
+    }
+
+    public void setVolume(float leftVolume, float rightVolume) {
+        mMediaPlayer.setVolume(leftVolume, rightVolume);
+    }
+
+    public void start() {
+        mMediaPlayer.start();
+    }
+
+    public void stop() {
+        mMediaPlayer.stop();
+    }
+
+    public void reset() {
+        mMediaPlayer.reset();
+    }
+
+    public void release() {
+        reset();
+        mMediaPlayer.release();
+        mMediaPlayer = null;
+    }
+
+  public void setPoster(String source) {
+    mPosterUri = source;
+  }
+}