初始化

cocos2d-x/cocos/platform/android/java/.classpath

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>

cocos2d-x/cocos/platform/android/java/.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>libcocos2dx</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

cocos2d-x/cocos/platform/android/java/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.cocos2dx.lib"
+    android:versionCode="1"
+    android:versionName="1.0">
+
+    <uses-sdk android:minSdkVersion="9"/>
+
+</manifest> 

cocos2d-x/cocos/platform/android/java/build.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="cocos2dxandroid" default="help">
+
+    <!-- The local.properties file is created and updated by the 'android' tool.
+         It contains the path to the SDK. It should *NOT* be checked into
+         Version Control Systems. -->
+    <property file="local.properties" />
+
+    <!-- The ant.properties file can be created by you. It is only edited by the
+         'android' tool to add properties to it.
+         This is the place to change some Ant specific build properties.
+         Here are some properties you may want to change/update:
+
+         source.dir
+             The name of the source directory. Default is 'src'.
+         out.dir
+             The name of the output directory. Default is 'bin'.
+
+         For other overridable properties, look at the beginning of the rules
+         files in the SDK, at tools/ant/build.xml
+
+         Properties related to the SDK location or the project target should
+         be updated using the 'android' tool with the 'update' action.
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems.
+
+         -->
+    <property file="ant.properties" />
+
+    <!-- The project.properties file is created and updated by the 'android'
+         tool, as well as ADT.
+
+         This contains project specific properties such as project target, and library
+         dependencies. Lower level build properties are stored in ant.properties
+         (or in .classpath for Eclipse projects).
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems. -->
+    <loadproperties srcFile="project.properties" />
+
+    <!-- quick check on sdk.dir -->
+    <fail
+            message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through an env var"
+            unless="sdk.dir"
+    />
+
+    <!--
+        Import per project custom build rules if present at the root of the project.
+        This is the place to put custom intermediary targets such as:
+            -pre-build
+            -pre-compile
+            -post-compile (This is typically used for code obfuscation.
+                           Compiled code location: ${out.classes.absolute.dir}
+                           If this is not done in place, override ${out.dex.input.absolute.dir})
+            -post-package
+            -post-build
+            -pre-clean
+    -->
+    <import file="custom_rules.xml" optional="true" />
+
+    <!-- Import the actual build file.
+
+         To customize existing targets, there are two options:
+         - Customize only one target:
+             - copy/paste the target into this file, *before* the
+               <import> task.
+             - customize it to your needs.
+         - Customize the whole content of build.xml
+             - copy/paste the content of the rules files (minus the top node)
+               into this file, replacing the <import> task.
+             - customize to your needs.
+
+         ***********************
+         ****** IMPORTANT ******
+         ***********************
+         In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
+         in order to avoid having your file be overridden by tools such as "android update project"
+    -->
+    <!-- version-tag: 1 -->
+    <import file="${sdk.dir}/tools/ant/build.xml" />
+
+</project>

cocos2d-x/cocos/platform/android/java/proguard-project.txt

@@ -0,0 +1,20 @@
+# To enable ProGuard in your project, edit project.properties
+# to define the proguard.config property as described in that file.
+#
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ${sdk.dir}/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/CanvasRenderingContext2DImpl.java

@@ -0,0 +1,510 @@
+/****************************************************************************
+ * Copyright (c) 2018 Xiamen Yaji Software Co., Ltd.
+ *
+ * http://www.cocos.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ****************************************************************************/
+
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Typeface;
+import android.os.Build;
+import android.text.TextPaint;
+import android.util.Log;
+
+import java.lang.ref.WeakReference;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.HashMap;
+
+public class CanvasRenderingContext2DImpl {
+
+    private static final String TAG = "CanvasContext2D";
+
+    private static final int TEXT_ALIGN_LEFT = 0;
+    private static final int TEXT_ALIGN_CENTER = 1;
+    private static final int TEXT_ALIGN_RIGHT = 2;
+
+    private static final int TEXT_BASELINE_TOP = 0;
+    private static final int TEXT_BASELINE_MIDDLE = 1;
+    private static final int TEXT_BASELINE_BOTTOM = 2;
+
+    private static WeakReference<Context> sContext;
+    private TextPaint mTextPaint;
+    private Paint mLinePaint;
+    private Path mLinePath;
+    private Canvas mCanvas = new Canvas();
+    private Bitmap mBitmap;
+    private int mTextAlign = TEXT_ALIGN_LEFT;
+    private int mTextBaseline = TEXT_BASELINE_BOTTOM;
+    private int mFillStyleR = 0;
+    private int mFillStyleG = 0;
+    private int mFillStyleB = 0;
+    private int mFillStyleA = 255;
+
+    private int mStrokeStyleR = 0;
+    private int mStrokeStyleG = 0;
+    private int mStrokeStyleB = 0;
+    private int mStrokeStyleA = 255;
+
+    private String mFontName = "Arial";
+    private float mFontSize = 40.0f;
+    private float mLineWidth = 0.0f;
+    private static float _sApproximatingOblique = -0.25f;//please check paint api documentation
+    private boolean mIsBoldFont = false;
+    private boolean mIsItalicFont = false;
+    private boolean mIsObliqueFont = false;
+    private boolean mIsSmallCapsFontVariant = false;
+    private String mLineCap = "butt";
+    private String mLineJoin = "miter";
+
+    private class Size {
+        Size(float w, float h) {
+            this.width = w;
+            this.height = h;
+        }
+
+        Size() {
+            this.width = 0;
+            this.height = 0;
+        }
+        public float width;
+        public float height;
+    }
+
+    private class Point {
+        Point(float x, float y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        Point() {
+            this.x = this.y = 0.0f;
+        }
+
+        Point(Point pt) {
+            this.x = pt.x;
+            this.y = pt.y;
+        }
+
+        void set(float x, float y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public float x;
+        public float y;
+    }
+
+    static void init(Context context) {
+        sContext = new WeakReference<>(context);
+    }
+
+    static void destroy() {
+        sContext = null;
+    }
+
+    private static HashMap<String, Typeface> sTypefaceCache = new HashMap<>();
+
+    // url is a full path started with '@assets/'
+    private static void loadTypeface(String familyName, String url) {
+        if (!sTypefaceCache.containsKey(familyName)) {
+            try {
+                Typeface typeface = null;
+                if (url.startsWith("/")) {
+                    typeface = Typeface.createFromFile(url);
+                } else if (sContext.get() != null) {
+                    final String prefix = "@assets/";
+                    if (url.startsWith(prefix)) {
+                        url = url.substring(prefix.length());
+                    }
+                    typeface = Typeface.createFromAsset(sContext.get().getAssets(), url);
+                }
+
+                if (typeface != null) {
+                    sTypefaceCache.put(familyName, typeface);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    // REFINE:: native should clear font cache before exiting game.
+    private static void clearTypefaceCache() {
+        sTypefaceCache.clear();
+    }
+
+    private static TextPaint newPaint(String fontName, int fontSize, boolean enableBold, boolean enableItalic, boolean obliqueFont, boolean smallCapsFontVariant) {
+        TextPaint paint = new TextPaint();
+        paint.setTextSize(fontSize);
+        paint.setAntiAlias(true);
+        paint.setSubpixelText(true);
+
+        String key = fontName;
+        if (enableBold) {
+            key += "-Bold";
+            paint.setFakeBoldText(true);
+        }
+        if (enableItalic) {
+            key += "-Italic";
+        }
+
+        Typeface typeFace;
+        if (sTypefaceCache.containsKey(key)) {
+            typeFace = sTypefaceCache.get(key);
+        } else {
+            int style = Typeface.NORMAL;
+            if (enableBold && enableItalic) {
+                style = Typeface.BOLD_ITALIC;
+            } else if (enableBold) {
+                style = Typeface.BOLD;
+            } else if (enableItalic) {
+                style = Typeface.ITALIC;
+            }
+            typeFace = Typeface.create(fontName, style);
+        }
+        paint.setTypeface(typeFace);
+        if(obliqueFont) {
+            paint.setTextSkewX(_sApproximatingOblique);
+        }
+        if(smallCapsFontVariant && Build.VERSION.SDK_INT >= 21) {
+            Cocos2dxReflectionHelper.<Void>invokeInstanceMethod(paint,
+                    "setFontFeatureSettings",
+                    new Class[]{String.class},
+                    new Object[]{"smcp"});
+        }
+        return paint;
+    }
+
+    private CanvasRenderingContext2DImpl() {
+        // Log.d(TAG, "constructor");
+    }
+
+    private void recreateBuffer(float w, float h) {
+        // Log.d(TAG, "recreateBuffer:" + w + ", " + h);
+        if (mBitmap != null) {
+            mBitmap.recycle();
+        }
+        mBitmap = Bitmap.createBitmap((int)Math.ceil(w), (int)Math.ceil(h), Bitmap.Config.ARGB_8888);
+        // FIXME: in MIX 2S, its API level is 28, but can not find invokeInstanceMethod. It seems
+        // devices may not obey the specification, so comment the codes.
+//        if (Build.VERSION.SDK_INT >= 19) {
+//            Cocos2dxReflectionHelper.<Void>invokeInstanceMethod(mBitmap,
+//                                                    "setPremultiplied",
+//                                                                new Class[]{Boolean.class},
+//                                                                new Object[]{Boolean.FALSE});
+//        }
+        mCanvas.setBitmap(mBitmap);
+    }
+
+    private void beginPath() {
+        if (mLinePath == null) {
+            mLinePath = new Path();
+        }
+        mLinePath.reset();
+    }
+
+    private void closePath() {
+        mLinePath.close();
+    }
+
+    private void moveTo(float x, float y) {
+        mLinePath.moveTo(x, y);
+    }
+
+    private void lineTo(float x, float y) {
+        mLinePath.lineTo(x, y);
+    }
+
+    private void stroke() {
+        if (mLinePaint == null) {
+            mLinePaint = new Paint();
+            mLinePaint.setAntiAlias(true);
+        }
+
+        if(mLinePath == null) {
+            mLinePath = new Path();
+        }
+
+        mLinePaint.setARGB(mStrokeStyleA, mStrokeStyleR, mStrokeStyleG, mStrokeStyleB);
+        mLinePaint.setStyle(Paint.Style.STROKE);
+        mLinePaint.setStrokeWidth(mLineWidth);
+        this.setStrokeCap(mLinePaint);
+        this.setStrokeJoin(mLinePaint);
+        mCanvas.drawPath(mLinePath, mLinePaint);
+    }
+
+    private void setStrokeCap(Paint paint) {
+        switch (mLineCap) {
+            case "butt":
+                paint.setStrokeCap(Paint.Cap.BUTT);
+                break;
+            case "round":
+                paint.setStrokeCap(Paint.Cap.ROUND);
+                break;
+            case "square":
+                paint.setStrokeCap(Paint.Cap.SQUARE);
+                break;
+        }
+    }
+
+    private void setStrokeJoin(Paint paint) {
+        switch (mLineJoin) {
+            case "bevel":
+                paint.setStrokeJoin(Paint.Join.BEVEL);
+                break;
+            case "round":
+                paint.setStrokeJoin(Paint.Join.ROUND);
+                break;
+            case "miter":
+                paint.setStrokeJoin(Paint.Join.MITER);
+                break;
+        }
+    }
+
+    private void fill() {
+        if (mLinePaint == null) {
+            mLinePaint = new Paint();
+        }
+
+        if(mLinePath == null) {
+            mLinePath = new Path();
+        }
+
+        mLinePaint.setARGB(mFillStyleA, mFillStyleR, mFillStyleG, mFillStyleB);
+        mLinePaint.setStyle(Paint.Style.FILL);
+        mCanvas.drawPath(mLinePath, mLinePaint);
+        // workaround: draw a hairline to cover the border
+        mLinePaint.setStrokeWidth(0);
+        this.setStrokeCap(mLinePaint);
+        this.setStrokeJoin(mLinePaint);
+        mLinePaint.setStyle(Paint.Style.STROKE);
+        mCanvas.drawPath(mLinePath, mLinePaint);
+        mLinePaint.setStrokeWidth(mLineWidth);
+    }
+
+    private void setLineCap(String lineCap) {
+        mLineCap = lineCap;
+    }
+
+    private void setLineJoin(String lineJoin) {
+        mLineJoin = lineJoin;
+    }
+
+    private void saveContext() {
+        mCanvas.save();
+    }
+
+    private void restoreContext() {
+        // If there is no saved state, this method should do nothing.
+        if (mCanvas.getSaveCount() > 1){
+            mCanvas.restore();
+        }
+    }
+
+    private void rect(float x, float y, float w, float h) {
+        //        Log.d(TAG, "this: " + this + ", rect: " + x + ", " + y + ", " + w + ", " + h);
+        beginPath();
+        moveTo(x, y);
+        lineTo(x, y + h);
+        lineTo(x + w, y + h);
+        lineTo(x + w, y);
+        closePath();
+    }
+
+    private void clearRect(float x, float y, float w, float h) {
+        //        Log.d(TAG, "this: " + this + ", clearRect: " + x + ", " + y + ", " + w + ", " + h);
+        int clearSize = (int)(w * h);
+        int[] clearColor = new int[clearSize];
+        for (int i = 0; i < clearSize; ++i) {
+            clearColor[i] = Color.TRANSPARENT;
+        }
+        mBitmap.setPixels(clearColor, 0, (int) w, (int) x, (int) y, (int) w, (int) h);
+    }
+
+    private void createTextPaintIfNeeded() {
+        if (mTextPaint == null) {
+            mTextPaint = newPaint(mFontName, (int) mFontSize, mIsBoldFont, mIsItalicFont, mIsObliqueFont, mIsSmallCapsFontVariant);
+        }
+    }
+
+    private void fillRect(float x, float y, float w, float h) {
+        // Log.d(TAG, "fillRect: " + x + ", " + y + ", " + ", " + w + ", " + h);
+        int pixelValue = (mFillStyleA & 0xff) << 24 | (mFillStyleR & 0xff) << 16 | (mFillStyleG & 0xff) << 8 | (mFillStyleB & 0xff);
+        int fillSize = (int)(w * h);
+        int[] fillColors = new int[fillSize];
+        for (int i = 0; i < fillSize; ++i) {
+            fillColors[i] = pixelValue;
+        }
+        mBitmap.setPixels(fillColors, 0, (int) w, (int)x, (int)y, (int)w, (int)h);
+    }
+
+    private void scaleX(TextPaint textPaint, String text, float maxWidth) {
+        if(maxWidth < Float.MIN_VALUE) return;
+        float measureWidth = this.measureText(text);
+        if((measureWidth - maxWidth) < Float.MIN_VALUE) return;
+        float scaleX = maxWidth/measureWidth;
+        textPaint.setTextScaleX(scaleX);
+    }
+
+    private void fillText(String text, float x, float y, float maxWidth) {
+//        Log.d(TAG, "this: " + this + ", fillText: " + text + ", " + x + ", " + y + ", " + ", " + maxWidth);
+        createTextPaintIfNeeded();
+        mTextPaint.setARGB(mFillStyleA, mFillStyleR, mFillStyleG, mFillStyleB);
+        mTextPaint.setStyle(Paint.Style.FILL);
+        scaleX(mTextPaint, text, maxWidth);
+        Point pt = convertDrawPoint(new Point(x, y), text);
+        mCanvas.drawText(text, pt.x, pt.y, mTextPaint);
+    }
+
+    private void strokeText(String text, float x, float y, float maxWidth) {
+        // Log.d(TAG, "strokeText: " + text + ", " + x + ", " + y + ", " + ", " + maxWidth);
+        createTextPaintIfNeeded();
+        mTextPaint.setARGB(mStrokeStyleA, mStrokeStyleR, mStrokeStyleG, mStrokeStyleB);
+        mTextPaint.setStyle(Paint.Style.STROKE);
+        mTextPaint.setStrokeWidth(mLineWidth);
+        scaleX(mTextPaint, text, maxWidth);
+        Point pt = convertDrawPoint(new Point(x, y), text);
+        mCanvas.drawText(text, pt.x, pt.y, mTextPaint);
+    }
+
+    private float measureText(String text) {
+        createTextPaintIfNeeded();
+        float ret = mTextPaint.measureText(text);
+        // Log.d(TAG, "measureText: " + text + ", return: " + ret);
+        return ret;
+    }
+
+    private Size measureTextReturnSize(String text) {
+        createTextPaintIfNeeded();
+        Paint.FontMetrics fm = mTextPaint.getFontMetrics();
+        // Use descent & ascent for clipping the transparent region.
+        // So don't use bottom & top which will make text be cut.
+        return new Size(measureText(text), fm.descent - fm.ascent);
+    }
+
+    private void updateFont(String fontName, float fontSize, boolean bold, boolean italic, boolean oblique, boolean smallCaps) {
+        // Log.d(TAG, "updateFont: " + fontName + ", " + fontSize);
+        mFontName = fontName;
+        mFontSize = fontSize;
+        mIsBoldFont = bold;
+        mIsItalicFont = italic;
+        mIsObliqueFont = oblique;
+        mIsSmallCapsFontVariant = smallCaps;
+        mTextPaint = null; // Reset paint to re-create paint object in createTextPaintIfNeeded
+    }
+
+    private void setTextAlign(int align) {
+        // Log.d(TAG, "setTextAlign: " + align);
+        mTextAlign = align;
+    }
+
+    private void setTextBaseline(int baseline) {
+        // Log.d(TAG, "setTextBaseline: " + baseline);
+        mTextBaseline = baseline;
+    }
+
+    private void setFillStyle(float r, float g, float b, float a) {
+        // Log.d(TAG, "setFillStyle: " + r + ", " + g + ", " + b + ", " + a);
+        mFillStyleR = (int)(r * 255.0f);
+        mFillStyleG = (int)(g * 255.0f);
+        mFillStyleB = (int)(b * 255.0f);
+        mFillStyleA = (int)(a * 255.0f);
+    }
+
+    private void setStrokeStyle(float r, float g, float b, float a) {
+        // Log.d(TAG, "setStrokeStyle: " + r + ", " + g + ", " + b + ", " + a);
+        mStrokeStyleR = (int)(r * 255.0f);
+        mStrokeStyleG = (int)(g * 255.0f);
+        mStrokeStyleB = (int)(b * 255.0f);
+        mStrokeStyleA = (int)(a * 255.0f);
+    }
+
+    private void setLineWidth(float lineWidth) {
+        mLineWidth = lineWidth;
+    }
+
+    private void _fillImageData(byte[] imageData, float imageWidth, float imageHeight, float offsetX, float offsetY) {
+        Log.d(TAG, "_fillImageData: ");
+        int fillSize = (int) (imageWidth * imageHeight);
+        int[] fillColors = new int[fillSize];
+        int r, g, b, a;
+        for (int i = 0; i < fillSize; ++i) {
+            // imageData Pixel (RGBA) -> fillColors int (ARGB)
+            r = ((int)imageData[4 * i + 0]) & 0xff;
+            g = ((int)imageData[4 * i + 1]) & 0xff;
+            b = ((int)imageData[4 * i + 2]) & 0xff;
+            a = ((int)imageData[4 * i + 3]) & 0xff;
+            fillColors[i] = (a & 0xff) << 24 | (r & 0xff) << 16 | (g & 0xff) << 8 | (b & 0xff);
+        }
+        mBitmap.setPixels(fillColors, 0, (int) imageWidth, (int) offsetX, (int) offsetY, (int) imageWidth, (int) imageHeight);
+    }
+
+    private Point convertDrawPoint(final Point point, String text) {
+        // The parameter 'point' is located at left-bottom position.
+        // Need to adjust 'point' according 'text align' & 'text base line'.
+        Point ret = new Point(point);
+        Size textSize = measureTextReturnSize(text);
+        // Log.d(TAG,"textSize: " + textSize.width + ", " + textSize.height);
+
+        if (mTextAlign == TEXT_ALIGN_CENTER)
+        {
+            ret.x -= textSize.width / 2;
+        }
+        else if (mTextAlign == TEXT_ALIGN_RIGHT)
+        {
+            ret.x -= textSize.width;
+        }
+
+        if (mTextBaseline == TEXT_BASELINE_TOP)
+        {
+            ret.y += textSize.height;
+        }
+        else if (mTextBaseline == TEXT_BASELINE_MIDDLE)
+        {
+            ret.y += textSize.height / 2;
+        }
+
+        return ret;
+    }
+
+    private byte[] getDataRef() {
+//        Log.d(TAG, "this: " + this + ", getDataRef ...");
+        if (mBitmap != null) {
+            final int len = mBitmap.getWidth() * mBitmap.getHeight() * 4;
+            final byte[] pixels = new byte[len];
+            final ByteBuffer buf = ByteBuffer.wrap(pixels);
+            buf.order(ByteOrder.nativeOrder());
+            mBitmap.copyPixelsToBuffer(buf);
+
+            return pixels;
+        }
+
+        Log.e(TAG, "getDataRef return null");
+        return null;
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxAccelerometer.java

@@ -0,0 +1,147 @@
+/****************************************************************************
+Copyright (c) 2010-2013 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+
+public class Cocos2dxAccelerometer implements SensorEventListener {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+
+    private static final String TAG = Cocos2dxAccelerometer.class.getSimpleName();
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+    private final Context mContext;
+    private final SensorManager mSensorManager;
+    private final Sensor mAcceleration;
+    private final Sensor mAccelerationIncludingGravity;
+    private final Sensor mGyroscope;
+    private int mSamplingPeriodUs = SensorManager.SENSOR_DELAY_GAME;
+
+    class Acceleration {
+        public float x = 0.0f;
+        public float y = 0.0f;
+        public float z = 0.0f;
+    }
+
+    class RotationRate {
+        public float alpha = 0.0f;
+        public float beta = 0.0f;
+        public float gamma = 0.0f;
+    }
+
+    class DeviceMotionEvent {
+        public Acceleration acceleration = new Acceleration();
+        public Acceleration accelerationIncludingGravity = new Acceleration();
+        public RotationRate rotationRate = new RotationRate();
+    }
+
+    private DeviceMotionEvent mDeviceMotionEvent = new DeviceMotionEvent();
+
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+
+    public Cocos2dxAccelerometer(final Context context) {
+        mContext = context;
+
+        mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
+        mAcceleration = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+        mAccelerationIncludingGravity = mSensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
+        mGyroscope = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
+    }
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+    public void enable() {
+        mSensorManager.registerListener(this, mAcceleration, mSamplingPeriodUs);
+        mSensorManager.registerListener(this, mAccelerationIncludingGravity, mSamplingPeriodUs);
+        mSensorManager.registerListener(this, mGyroscope, mSamplingPeriodUs);
+    }
+
+    public void disable() {
+        this.mSensorManager.unregisterListener(this);
+    }
+
+    public void setInterval(float interval) {
+        if (android.os.Build.VERSION.SDK_INT >= 11) {
+            mSamplingPeriodUs = (int) (interval * 1000000);
+        }
+        disable();
+        enable();
+    }
+
+    public DeviceMotionEvent getDeviceMotionEvent() {
+        return mDeviceMotionEvent;
+    }
+
+    // ===========================================================
+    // Methods for/from SuperClass/Interfaces
+    // ===========================================================
+    @Override
+    public void onSensorChanged(final SensorEvent sensorEvent) {
+        int type = sensorEvent.sensor.getType();
+        if (type == Sensor.TYPE_ACCELEROMETER) {
+            mDeviceMotionEvent.accelerationIncludingGravity.x = sensorEvent.values[0];
+            mDeviceMotionEvent.accelerationIncludingGravity.y = sensorEvent.values[1];
+            mDeviceMotionEvent.accelerationIncludingGravity.z = sensorEvent.values[2];
+        }
+        else if (type == Sensor.TYPE_LINEAR_ACCELERATION) {
+            mDeviceMotionEvent.acceleration.x = sensorEvent.values[0];
+            mDeviceMotionEvent.acceleration.y = sensorEvent.values[1];
+            mDeviceMotionEvent.acceleration.z = sensorEvent.values[2];
+        }
+        else if (type == Sensor.TYPE_GYROSCOPE) {
+            // The unit is rad/s, need to be converted to deg/s
+            mDeviceMotionEvent.rotationRate.alpha = (float)Math.toDegrees(sensorEvent.values[0]);
+            mDeviceMotionEvent.rotationRate.beta = (float)Math.toDegrees(sensorEvent.values[1]);
+            mDeviceMotionEvent.rotationRate.gamma = (float)Math.toDegrees(sensorEvent.values[2]);
+        }
+    }
+
+    @Override
+    public void onAccuracyChanged(final Sensor sensor, final int accuracy) {
+    }
+
+    // ===========================================================
+    // Methods
+        // Native method called from Cocos2dxGLSurfaceView (To be in the same thread)
+    // ===========================================================
+
+    public static native void onSensorChanged(final float x, final float y, final float z, final long timestamp);
+
+    // ===========================================================
+    // Inner and Anonymous Classes
+    // ===========================================================
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxActivity.java

@@ -0,0 +1,652 @@
+/****************************************************************************
+Copyright (c) 2010-2013 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.graphics.Color;
+import android.graphics.PixelFormat;
+import android.media.AudioManager;
+import android.opengl.GLSurfaceView;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Message;
+import android.preference.PreferenceManager.OnActivityResultListener;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import org.cocos2dx.lib.Cocos2dxHelper.Cocos2dxHelperListener;
+
+import java.lang.reflect.Field;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLDisplay;
+
+public abstract class Cocos2dxActivity extends Activity implements Cocos2dxHelperListener {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+
+    private final static String TAG = Cocos2dxActivity.class.getSimpleName();
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+    private static Cocos2dxActivity sContext = null;
+
+    protected FrameLayout mFrameLayout = null;
+    
+    private Cocos2dxGLSurfaceView mGLSurfaceView = null;
+    private int[] mGLContextAttrs = null;
+    private Cocos2dxHandler mHandler = null;
+    private Cocos2dxVideoHelper mVideoHelper = null;
+    private Cocos2dxWebViewHelper mWebViewHelper = null;
+    private boolean hasFocus = false;
+    private Cocos2dxEditBox mEditBox = null;
+    private boolean gainAudioFocus = false;
+    private boolean paused = true;
+
+    // DEBUG VIEW BEGIN
+    private LinearLayout mLinearLayoutForDebugView;
+    private TextView mFPSTextView;
+    private TextView mJSBInvocationTextView;
+    private TextView mGLOptModeTextView;
+    private TextView mGameInfoTextView_0;
+    private TextView mGameInfoTextView_1;
+    private TextView mGameInfoTextView_2;
+    // DEBUG VIEW END
+
+    private Cocos2dxOrientationHelper mCocos2dxOrientationHelper = null;
+    // ===========================================================
+    // Inner class
+    // ===========================================================
+
+    public class Cocos2dxEGLConfigChooser implements GLSurfaceView.EGLConfigChooser {
+        protected int[] configAttribs;
+        public Cocos2dxEGLConfigChooser(int redSize, int greenSize, int blueSize, int alphaSize, int depthSize, int stencilSize)
+        {
+            configAttribs = new int[] {redSize, greenSize, blueSize, alphaSize, depthSize, stencilSize};
+        }
+        public Cocos2dxEGLConfigChooser(int[] attribs)
+        {
+            configAttribs = attribs;
+        }
+
+        private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+                EGLConfig config, int attribute, int defaultValue) {
+            int[] value = new int[1];
+            if (egl.eglGetConfigAttrib(display, config, attribute, value)) {
+                return value[0];
+            }
+            return defaultValue;
+        }
+
+        class ConfigValue implements Comparable<ConfigValue> {
+            public EGLConfig config = null;
+            public int[] configAttribs = null;
+            public int value = 0;
+            private void calcValue() {
+                // depth factor 29bit and [6,12)bit
+                if (configAttribs[4] > 0) {
+                    value = value + (1 << 29) + ((configAttribs[4]%64) << 6);
+                }
+                // stencil factor 28bit and [0, 6)bit
+                if (configAttribs[5] > 0) {
+                    value = value + (1 << 28) + ((configAttribs[5]%64));
+                }
+                // alpha factor 30bit and [24, 28)bit
+                if (configAttribs[3] > 0) {
+                    value = value + (1 << 30) + ((configAttribs[3]%16) << 24);
+                }
+                // green factor [20, 24)bit
+                if (configAttribs[1] > 0) {
+                    value = value + ((configAttribs[1]%16) << 20);
+                }
+                // blue factor [16, 20)bit
+                if (configAttribs[2] > 0) {
+                    value = value + ((configAttribs[2]%16) << 16);
+                }
+                // red factor [12, 16)bit
+                if (configAttribs[0] > 0) {
+                    value = value + ((configAttribs[0]%16) << 12);
+                }
+            }
+
+            public ConfigValue(int[] attribs) {
+                configAttribs = attribs;
+                calcValue();
+            }
+
+            public ConfigValue(EGL10 egl, EGLDisplay display, EGLConfig config) {
+                this.config = config;
+                configAttribs = new int[6];
+                configAttribs[0] = findConfigAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
+                configAttribs[1] = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
+                configAttribs[2] = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
+                configAttribs[3] = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
+                configAttribs[4] = findConfigAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
+                configAttribs[5] = findConfigAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);
+                calcValue();
+            }
+
+            @Override
+            public int compareTo(ConfigValue another) {
+                if (value < another.value) {
+                    return -1;
+                } else if (value > another.value) {
+                    return 1;
+                } else {
+                    return 0;
+                }
+            }
+
+            @Override
+            public String toString() {
+                return "{ color: " + configAttribs[3] + configAttribs[2] + configAttribs[1] + configAttribs[0] +
+                        "; depth: " + configAttribs[4] + "; stencil: " + configAttribs[5] + ";}";
+            }
+        }
+
+        @Override
+        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) 
+        {
+            int[] EGLattribs = {
+                    EGL10.EGL_RED_SIZE, configAttribs[0],
+                    EGL10.EGL_GREEN_SIZE, configAttribs[1],
+                    EGL10.EGL_BLUE_SIZE, configAttribs[2],
+                    EGL10.EGL_ALPHA_SIZE, configAttribs[3],
+                    EGL10.EGL_DEPTH_SIZE, configAttribs[4],
+                    EGL10.EGL_STENCIL_SIZE,configAttribs[5],
+                    EGL10.EGL_RENDERABLE_TYPE, 4, //EGL_OPENGL_ES2_BIT
+                    EGL10.EGL_NONE
+            };
+            EGLConfig[] configs = new EGLConfig[1];
+            int[] numConfigs = new int[1];
+            boolean eglChooseResult = egl.eglChooseConfig(display, EGLattribs, configs, 1, numConfigs);
+            if (eglChooseResult && numConfigs[0] > 0)
+            {
+                return configs[0];
+            }
+
+            // there's no config match the specific configAttribs, we should choose a closest one
+            int[] EGLV2attribs = {
+                    EGL10.EGL_RENDERABLE_TYPE, 4, //EGL_OPENGL_ES2_BIT
+                    EGL10.EGL_NONE
+            };
+            eglChooseResult = egl.eglChooseConfig(display, EGLV2attribs, null, 0, numConfigs);
+            if(eglChooseResult && numConfigs[0] > 0) {
+                int num = numConfigs[0];
+                ConfigValue[] cfgVals = new ConfigValue[num];
+
+                // convert all config to ConfigValue
+                configs = new EGLConfig[num];
+                egl.eglChooseConfig(display, EGLV2attribs, configs, num, numConfigs);
+                for (int i = 0; i < num; ++i) {
+                    cfgVals[i] = new ConfigValue(egl, display, configs[i]);
+                }
+
+                ConfigValue e = new ConfigValue(configAttribs);
+                // bin search
+                int lo = 0;
+                int hi = num;
+                int mi;
+                while (lo < hi - 1) {
+                    mi = (lo + hi) / 2;
+                    if (e.compareTo(cfgVals[mi]) < 0) {
+                        hi = mi;
+                    } else {
+                        lo = mi;
+                    }
+                }
+                if (lo != num - 1) {
+                    lo = lo + 1;
+                }
+                Log.w("cocos2d", "Can't find EGLConfig match: " + e + ", instead of closest one:" + cfgVals[lo]);
+                return cfgVals[lo].config;
+            }
+
+            Log.e(DEVICE_POLICY_SERVICE, "Can not select an EGLConfig for rendering.");
+            return null;
+        }
+
+    }
+
+    // ===========================================================
+    // Member methods
+    // ===========================================================
+
+    public Cocos2dxGLSurfaceView getGLSurfaceView(){
+        return  mGLSurfaceView;
+    }
+    public static Context getContext() {
+        return sContext;
+    }
+
+    public void init() {
+        ViewGroup.LayoutParams frameLayoutParams =
+                new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
+                                           ViewGroup.LayoutParams.MATCH_PARENT);
+        mFrameLayout = new FrameLayout(this);
+        mFrameLayout.setLayoutParams(frameLayoutParams);
+
+        Cocos2dxRenderer renderer = this.addSurfaceView();
+        this.addDebugInfo(renderer);
+
+
+        // Should create EditBox after adding SurfaceView, or EditBox will be hidden by SurfaceView.
+        mEditBox = new Cocos2dxEditBox(this, mFrameLayout);
+
+        // Set frame layout as the content view
+        setContentView(mFrameLayout);
+
+        WindowManager.LayoutParams lp = getWindow().getAttributes();
+        try {
+            Field field = lp.getClass().getField("layoutInDisplayCutoutMode");
+            //Field constValue = lp.getClass().getDeclaredField("LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER");
+            Field constValue = lp.getClass().getDeclaredField("LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES");
+            field.setInt(lp, constValue.getInt(null));
+            
+            // https://developer.android.com/training/system-ui/immersive
+            int flag = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                    | View.SYSTEM_UI_FLAG_FULLSCREEN
+                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                    | View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
+
+            flag |= View.class.getDeclaredField("SYSTEM_UI_FLAG_IMMERSIVE_STICKY").getInt(null);
+            View view = getWindow().getDecorView();
+            view.setSystemUiVisibility(flag);
+
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        mCocos2dxOrientationHelper = new Cocos2dxOrientationHelper(this);
+    }
+
+    public void setKeepScreenOn(boolean value) {
+        final boolean newValue = value;
+        runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                mGLSurfaceView.setKeepScreenOn(newValue);
+            }
+        });
+    }
+
+    public void setEnableAudioFocusGain(boolean value) {
+        if(gainAudioFocus != value) {
+            if(!paused) {
+                if (value)
+                    Cocos2dxAudioFocusManager.registerAudioFocusListener(this);
+                else
+                    Cocos2dxAudioFocusManager.unregisterAudioFocusListener(this);
+            }
+            gainAudioFocus = value;
+        }
+    }
+    
+    public Cocos2dxGLSurfaceView onCreateView() {
+        Cocos2dxGLSurfaceView glSurfaceView = new Cocos2dxGLSurfaceView(this);
+        //this line is need on some device if we specify an alpha bits
+        if(this.mGLContextAttrs[3] > 0) glSurfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
+
+        Cocos2dxEGLConfigChooser chooser = new Cocos2dxEGLConfigChooser(this.mGLContextAttrs);
+        glSurfaceView.setEGLConfigChooser(chooser);
+
+        return glSurfaceView;
+    }
+
+    // ===========================================================
+    // Override functions
+    // ===========================================================
+
+    @Override
+    protected void onCreate(final Bundle savedInstanceState) {
+        Log.d(TAG, "Cocos2dxActivity onCreate: " + this + ", savedInstanceState: " + savedInstanceState);
+        super.onCreate(savedInstanceState);
+
+        // Workaround in https://stackoverflow.com/questions/16283079/re-launch-of-activity-on-home-button-but-only-the-first-time/16447508
+        if (!isTaskRoot()) {
+            // Android launched another instance of the root activity into an existing task
+            //  so just quietly finish and go away, dropping the user back into the activity
+            //  at the top of the stack (ie: the last state of this task)
+            finish();
+            Log.w(TAG, "[Workaround] Ignore the activity started from icon!");
+            return;
+        }
+
+        Utils.setActivity(this);
+
+        Utils.hideVirtualButton();
+
+        Cocos2dxHelper.registerBatteryLevelReceiver(this);
+
+        onLoadNativeLibraries();
+
+        sContext = this;
+        this.mHandler = new Cocos2dxHandler(this);
+        
+        Cocos2dxHelper.init(this);
+        CanvasRenderingContext2DImpl.init(this);
+        
+        this.mGLContextAttrs = getGLContextAttrs();
+        this.init();
+
+        if (mVideoHelper == null) {
+            mVideoHelper = new Cocos2dxVideoHelper(this, mFrameLayout);
+        }
+
+        if(mWebViewHelper == null){
+            mWebViewHelper = new Cocos2dxWebViewHelper(mFrameLayout);
+        }
+
+        Window window = this.getWindow();
+        window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+        this.setVolumeControlStream(AudioManager.STREAM_MUSIC);
+    }
+
+    @Override
+    protected void onResume() {
+    	Log.d(TAG, "onResume()");
+        paused = false;
+        super.onResume();
+        if(gainAudioFocus)
+            Cocos2dxAudioFocusManager.registerAudioFocusListener(this);
+        Utils.hideVirtualButton();
+       	resumeIfHasFocus();
+       	mCocos2dxOrientationHelper.onResume();
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+    	Log.d(TAG, "onWindowFocusChanged() hasFocus=" + hasFocus);
+        super.onWindowFocusChanged(hasFocus);
+        
+        this.hasFocus = hasFocus;
+        resumeIfHasFocus();
+    }
+
+    private void resumeIfHasFocus() {
+        if(hasFocus && !paused) {
+            Utils.hideVirtualButton();
+            Cocos2dxHelper.onResume();
+            mGLSurfaceView.onResume();
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        Log.d(TAG, "onPause()");
+        paused = true;
+        super.onPause();
+        if(gainAudioFocus)
+            Cocos2dxAudioFocusManager.unregisterAudioFocusListener(this);
+        Cocos2dxHelper.onPause();
+        mGLSurfaceView.onPause();
+        mCocos2dxOrientationHelper.onPause();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+
+        // Workaround in https://stackoverflow.com/questions/16283079/re-launch-of-activity-on-home-button-but-only-the-first-time/16447508
+        if (!isTaskRoot()) {
+            return;
+        }
+
+        if(gainAudioFocus)
+            Cocos2dxAudioFocusManager.unregisterAudioFocusListener(this);
+        Cocos2dxHelper.unregisterBatteryLevelReceiver(this);;
+        CanvasRenderingContext2DImpl.destroy();
+
+        Log.d(TAG, "Cocos2dxActivity onDestroy: " + this + ", mGLSurfaceView" + mGLSurfaceView);
+        if (mGLSurfaceView != null) {
+            Cocos2dxHelper.terminateProcess();
+        }
+    }
+
+    @Override
+    public void showDialog(final String pTitle, final String pMessage) {
+        Message msg = new Message();
+        msg.what = Cocos2dxHandler.HANDLER_SHOW_DIALOG;
+        msg.obj = new Cocos2dxHandler.DialogMessage(pTitle, pMessage);
+        this.mHandler.sendMessage(msg);
+    }
+    
+    @Override
+    public void runOnGLThread(final Runnable runnable) {
+        this.mGLSurfaceView.queueEvent(runnable);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data)
+    {
+        for (OnActivityResultListener listener : Cocos2dxHelper.getOnActivityResultListeners()) {
+            listener.onActivityResult(requestCode, resultCode, data);
+        }
+
+        super.onActivityResult(requestCode, resultCode, data);
+    }
+
+    // ===========================================================
+    // Protected and private methods
+    // ===========================================================
+
+    protected void onLoadNativeLibraries() {
+        try {
+            ApplicationInfo ai = getPackageManager().getApplicationInfo(getPackageName(), PackageManager.GET_META_DATA);
+            Bundle bundle = ai.metaData;
+            String libName = bundle.getString("android.app.lib_name");
+            System.loadLibrary(libName);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Cocos2dxRenderer addSurfaceView() {
+        this.mGLSurfaceView = this.onCreateView();
+        this.mGLSurfaceView.setPreserveEGLContextOnPause(true);
+        // Should set to transparent, or it will hide EditText
+        // https://stackoverflow.com/questions/2978290/androids-edittext-is-hidden-when-the-virtual-keyboard-is-shown-and-a-surfacevie
+        mGLSurfaceView.setBackgroundColor(Color.TRANSPARENT);
+        // Switch to supported OpenGL (ARGB888) mode on emulator
+        if (isAndroidEmulator())
+            this.mGLSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
+
+        Cocos2dxRenderer renderer = new Cocos2dxRenderer();
+        this.mGLSurfaceView.setCocos2dxRenderer(renderer);
+
+        mFrameLayout.addView(this.mGLSurfaceView);
+
+        return renderer;
+    }
+
+    private void addDebugInfo(Cocos2dxRenderer renderer) {
+        LinearLayout.LayoutParams linearLayoutParam = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,
+                                                                                    LinearLayout.LayoutParams.WRAP_CONTENT);
+        linearLayoutParam.setMargins(30, 0, 0, 0);
+        Cocos2dxHelper.setOnGameInfoUpdatedListener(new Cocos2dxHelper.OnGameInfoUpdatedListener() {
+            @Override
+            public void onFPSUpdated(float fps) {
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mFPSTextView != null) {
+                            mFPSTextView.setText("FPS: " + (int)Math.ceil(fps));
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onJSBInvocationCountUpdated(int count) {
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mJSBInvocationTextView != null) {
+                            mJSBInvocationTextView.setText("JSB: " + count);
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onOpenDebugView() {
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mLinearLayoutForDebugView != null || mFrameLayout == null) {
+                            Log.e(TAG, "onOpenDebugView: failed!");
+                            return;
+                        }
+
+                        mLinearLayoutForDebugView = new LinearLayout(Cocos2dxActivity.this);
+                        mLinearLayoutForDebugView.setOrientation(LinearLayout.VERTICAL);
+                        mFrameLayout.addView(mLinearLayoutForDebugView);
+
+                        mFPSTextView = new TextView(Cocos2dxActivity.this);
+                        mFPSTextView.setBackgroundColor(Color.RED);
+                        mFPSTextView.setTextColor(Color.WHITE);
+                        mLinearLayoutForDebugView.addView(mFPSTextView, linearLayoutParam);
+
+                        mJSBInvocationTextView = new TextView(Cocos2dxActivity.this);
+                        mJSBInvocationTextView.setBackgroundColor(Color.GREEN);
+                        mJSBInvocationTextView.setTextColor(Color.WHITE);
+                        mLinearLayoutForDebugView.addView(mJSBInvocationTextView, linearLayoutParam);
+
+                        mGLOptModeTextView = new TextView(Cocos2dxActivity.this);
+                        mGLOptModeTextView.setBackgroundColor(Color.BLUE);
+                        mGLOptModeTextView.setTextColor(Color.WHITE);
+                        mGLOptModeTextView.setText("GL Opt: Enabled");
+                        mLinearLayoutForDebugView.addView(mGLOptModeTextView, linearLayoutParam);
+
+                        mGameInfoTextView_0 = new TextView(Cocos2dxActivity.this);
+                        mGameInfoTextView_0.setBackgroundColor(Color.RED);
+                        mGameInfoTextView_0.setTextColor(Color.WHITE);
+                        mLinearLayoutForDebugView.addView(mGameInfoTextView_0, linearLayoutParam);
+
+                        mGameInfoTextView_1 = new TextView(Cocos2dxActivity.this);
+                        mGameInfoTextView_1.setBackgroundColor(Color.GREEN);
+                        mGameInfoTextView_1.setTextColor(Color.WHITE);
+                        mLinearLayoutForDebugView.addView(mGameInfoTextView_1, linearLayoutParam);
+
+                        mGameInfoTextView_2 = new TextView(Cocos2dxActivity.this);
+                        mGameInfoTextView_2.setBackgroundColor(Color.BLUE);
+                        mGameInfoTextView_2.setTextColor(Color.WHITE);
+                        mLinearLayoutForDebugView.addView(mGameInfoTextView_2, linearLayoutParam);
+                    }
+                });
+
+                renderer.showFPS();
+            }
+
+            @Override
+            public void onDisableBatchGLCommandsToNative() {
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mGLOptModeTextView != null) {
+                            mGLOptModeTextView.setText("GL Opt: Disabled");
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onGameInfoUpdated_0(final String text) {
+
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mGameInfoTextView_0 != null) {
+                            mGameInfoTextView_0.setText(text);
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onGameInfoUpdated_1(String text) {
+
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mGameInfoTextView_1 != null) {
+                            mGameInfoTextView_1.setText(text);
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onGameInfoUpdated_2(String text) {
+
+                Cocos2dxActivity.this.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (mGameInfoTextView_2 != null) {
+                            mGameInfoTextView_2.setText(text);
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+   private final static boolean isAndroidEmulator() {
+      String model = Build.MODEL;
+      Log.d(TAG, "model=" + model);
+      String product = Build.PRODUCT;
+      Log.d(TAG, "product=" + product);
+      boolean isEmulator = false;
+      if (product != null) {
+         isEmulator = product.equals("sdk") || product.contains("_sdk") || product.contains("sdk_");
+      }
+      Log.d(TAG, "isEmulator=" + isEmulator);
+      return isEmulator;
+   }
+
+    // ===========================================================
+    // Native methods
+    // ===========================================================
+
+    //native method,call GLViewImpl::getGLContextAttrs() to get the OpenGL ES context attributions
+    private static native int[] getGLContextAttrs();
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxAudioFocusManager.java

@@ -0,0 +1,127 @@
+/****************************************************************************
+ * Copyright (c) 2016 Chukong Technologies Inc.
+ * Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+ *
+ * http://www.cocos2d-x.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ****************************************************************************/
+
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.util.Log;
+
+class Cocos2dxAudioFocusManager {
+
+    private final static String TAG = "AudioFocusManager";
+    // Audio focus values synchronized with which in cocos/platform/android/javaactivity-android.cpp
+    private final static int AUDIOFOCUS_GAIN = 0;
+    private final static int AUDIOFOCUS_LOST = 1;
+    private final static int AUDIOFOCUS_LOST_TRANSIENT = 2;
+    private final static int AUDIOFOCUS_LOST_TRANSIENT_CAN_DUCK = 3;
+
+    private static AudioManager.OnAudioFocusChangeListener sAfChangeListener =
+            new AudioManager.OnAudioFocusChangeListener() {
+                public void onAudioFocusChange(int focusChange) {
+
+                    Log.d(TAG, "onAudioFocusChange: " + focusChange + ", thread: " + Thread.currentThread().getName());
+
+                    if (focusChange == AudioManager.AUDIOFOCUS_LOSS) {
+                        // Permanent loss of audio focus
+                        // Pause playback immediately
+                        Log.d(TAG, "Pause music by AUDIOFOCUS_LOSS");
+                        Cocos2dxHelper.runOnGLThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                nativeOnAudioFocusChange(AUDIOFOCUS_LOST);
+                            }
+                        });
+
+                    } else if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT) {
+                        // Pause playback
+                        Log.d(TAG, "Pause music by AUDIOFOCUS_LOSS_TRANSILENT");
+                        Cocos2dxHelper.runOnGLThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                nativeOnAudioFocusChange(AUDIOFOCUS_LOST_TRANSIENT);
+                            }
+                        });
+                    } else if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK) {
+                        // Lower the volume, keep playing
+                        Log.d(TAG, "Lower the volume, keep playing by AUDIOFOCUS_LOSS_TRANSILENT_CAN_DUCK");
+                        Cocos2dxHelper.runOnGLThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                nativeOnAudioFocusChange(AUDIOFOCUS_LOST_TRANSIENT_CAN_DUCK);
+                            }
+                        });
+                    } else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
+                        // Your app has been granted audio focus again
+                        // Raise volume to normal, restart playback if necessary
+                        Log.d(TAG, "Resume music by AUDIOFOCUS_GAIN");
+                        Cocos2dxHelper.runOnGLThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                nativeOnAudioFocusChange(AUDIOFOCUS_GAIN);
+                            }
+                        });
+                    }
+                }
+            };
+
+    static boolean registerAudioFocusListener(Context context) {
+        AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+
+        // Request audio focus for playback
+        int result = am.requestAudioFocus(sAfChangeListener,
+                // Use the music stream.
+                AudioManager.STREAM_MUSIC,
+                // Request permanent focus.
+                AudioManager.AUDIOFOCUS_GAIN);
+
+        if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+            Log.d(TAG, "requestAudioFocus succeed");
+            return true;
+        }
+
+        Log.e(TAG, "requestAudioFocus failed!");
+        return false;
+    }
+
+    static void unregisterAudioFocusListener(Context context) {
+        AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+        int result = am.abandonAudioFocus(sAfChangeListener);
+        if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+            Log.d(TAG, "abandonAudioFocus succeed!");
+        } else {
+            Log.e(TAG, "abandonAudioFocus failed!");
+        }
+
+        Cocos2dxHelper.runOnGLThread(new Runnable() {
+            @Override
+            public void run() {
+                nativeOnAudioFocusChange(AUDIOFOCUS_GAIN);
+            }
+        });
+    }
+
+    private static native void nativeOnAudioFocusChange(int focusChange);
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxDownloader.java

@@ -0,0 +1,369 @@
+/****************************************************************************
+ Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+ worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+ not use Cocos Creator software for developing other software or tools that's
+ used for developing games. You are not granted to publish, distribute,
+ sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+package org.cocos2dx.lib;
+
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+// Rename package okhttp3 to org.cocos2dx.okhttp3
+// Github repo: https://github.com/PatriceJiang/okhttp/tree/cocos2dx-rename-3.12.x
+// and https://github.com/PatriceJiang/okio/tree/cocos2dx-rename-1.15.0
+import org.cocos2dx.okhttp3.Call;
+import org.cocos2dx.okhttp3.Callback;
+import org.cocos2dx.okhttp3.OkHttpClient;
+import org.cocos2dx.okhttp3.Request;
+import org.cocos2dx.okhttp3.Response;
+
+public class Cocos2dxDownloader {
+
+    private int _id;
+    private OkHttpClient _httpClient = null;
+
+    private String _tempFileNameSuffix;
+    private int _countOfMaxProcessingTasks;
+    private ConcurrentHashMap<Integer,Call> _taskMap = new ConcurrentHashMap<>();
+    private Queue<Runnable> _taskQueue = new LinkedList<>();
+    private int _runningTaskCount = 0;
+    private static ConcurrentHashMap<String, Boolean> _resumingSupport = new ConcurrentHashMap<>();
+
+    private void onProgress(final int id, final long downloadBytes, final long downloadNow, final long downloadTotal) {
+        Cocos2dxHelper.runOnGLThread(new Runnable() {
+            @Override
+            public void run() {
+                nativeOnProgress(_id, id, downloadBytes, downloadNow, downloadTotal);
+            }
+        });
+    }
+
+    private void onFinish(final int id, final int errCode, final String errStr, final byte[] data) {
+        Call task =_taskMap.get(id);
+        if (null == task) return;
+        _taskMap.remove(id);
+        _runningTaskCount -= 1;
+        Cocos2dxHelper.runOnGLThread(new Runnable() {
+            @Override
+            public void run() {
+                nativeOnFinish(_id, id, errCode, errStr, data);
+            }
+        });
+        runNextTaskIfExists();
+    }
+
+    public static Cocos2dxDownloader createDownloader(int id, int timeoutInSeconds, String tempFileSuffix, int maxProcessingTasks) {
+        Cocos2dxDownloader downloader = new Cocos2dxDownloader();
+        downloader._id = id;
+
+        if (timeoutInSeconds > 0) {
+            downloader._httpClient = new OkHttpClient().newBuilder()
+                    .followRedirects(true)
+                    .followSslRedirects(true)
+                    .callTimeout(timeoutInSeconds, TimeUnit.SECONDS)
+                    .build();
+        } else {
+            downloader._httpClient = new OkHttpClient().newBuilder()
+                    .followRedirects(true)
+                    .followSslRedirects(true)
+                    .build();
+        }
+
+
+        downloader._tempFileNameSuffix = tempFileSuffix;
+        downloader._countOfMaxProcessingTasks = maxProcessingTasks;
+        return downloader;
+    }
+
+    public static void createTask(final Cocos2dxDownloader downloader, int id_, String url_, String path_, String []header_) {
+        final int id = id_;
+        final String url = url_;
+        final String path = path_;
+        final String[] header = header_;
+
+        Runnable taskRunnable = new Runnable() {
+            String domain = null;
+            String host = null;
+            File tempFile = null;
+            File finalFile = null;
+            long downloadStart = 0;
+
+            @Override
+            public void run() {
+                Call task = null;
+
+                do {
+                    if (path.length() > 0) {
+                        try {
+                            URI uri = new URI(url);
+                            domain = uri.getHost();
+                        } catch (URISyntaxException e) {
+                            e.printStackTrace();
+                            break;
+                        } catch (NullPointerException e) {
+                            e.printStackTrace();
+                            break;
+                        }
+
+                        // file task
+                        tempFile = new File(path + downloader._tempFileNameSuffix);
+                        if (tempFile.isDirectory()) break;
+
+                        File parent = tempFile.getParentFile();
+                        if (!parent.isDirectory() && !parent.mkdirs()) break;
+
+                        finalFile = new File(path);
+                        if (finalFile.isDirectory()) break;
+                        long fileLen = tempFile.length();
+
+                        host = domain.startsWith("www.") ? domain.substring(4) : domain;
+                        if (fileLen > 0) {
+                            if (_resumingSupport.containsKey(host) && _resumingSupport.get(host)) {
+                                downloadStart = fileLen;
+                            } else {
+                                // Remove previous downloaded context
+                                try {
+                                    PrintWriter writer = new PrintWriter(tempFile);
+                                    writer.print("");
+                                    writer.close();
+                                }
+                                // Not found then nothing to do
+                                catch (FileNotFoundException e) {
+                                }
+                            }
+                        }
+                    }
+
+                    final Request.Builder builder = new Request.Builder().url(url);
+                    for (int i = 0; i < header.length / 2; i++) {
+                        builder.addHeader(header[i * 2], header[(i * 2) + 1]);
+                    }
+                    if (downloadStart > 0) {
+                        builder.addHeader("RANGE", "bytes=" + downloadStart + "-");
+                    }
+
+                    final Request request = builder.build();
+                    task = downloader._httpClient.newCall(request);
+                    if (null == task) {
+                        final String errStr = "Can't create DownloadTask for " + url;
+                        Cocos2dxHelper.runOnGLThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                downloader.nativeOnFinish(downloader._id, id, 0, errStr, null);
+                            }
+                        });
+                    } else {
+                        downloader._taskMap.put(id, task);
+                    }                    
+                    task.enqueue(new Callback() {
+                        @Override
+                        public void onFailure(Call call, IOException e) {
+                            downloader.onFinish(id, 0, e.toString(), null);
+                        }
+
+                        @Override
+                        public void onResponse(Call call, Response response) throws IOException {
+                            InputStream is = null;
+                            byte[] buf = new byte[4096];
+                            FileOutputStream fos = null;
+
+                            try {
+
+                                if(!(response.code() >= 200 && response.code() <= 206)) {
+                                    // it is encourage to delete the tmp file when requested range not satisfiable.
+                                    if (response.code() == 416) {
+                                        File file = new File(path + downloader._tempFileNameSuffix);
+                                        if (file.exists() && file.isFile()) {
+                                            file.delete();
+                                        }
+                                    }                                    
+                                    downloader.onFinish(id, -2, response.message(), null);
+                                    return;
+                                }
+
+                                long total = response.body().contentLength();
+                                if (path.length() > 0 && !_resumingSupport.containsKey(host)) {
+                                    if (total > 0) {
+                                        _resumingSupport.put(host, true);
+                                    } else {
+                                        _resumingSupport.put(host, false);
+                                    }
+                                }
+
+                                long current = downloadStart;
+                                is = response.body().byteStream();
+
+                                if (path.length() > 0) {
+                                    if (downloadStart > 0) {
+                                        fos = new FileOutputStream(tempFile, true);
+                                    } else {
+                                        fos = new FileOutputStream(tempFile, false);
+                                    }
+
+                                    int len;
+                                    while ((len = is.read(buf)) != -1) {
+                                        current += len;
+                                        fos.write(buf, 0, len);
+                                        downloader.onProgress(id, len, current, total);
+                                    }
+                                    fos.flush();
+
+                                    String errStr = null;
+                                    do {
+                                        // rename temp file to final file, if final file exist, remove it
+                                        if (finalFile.exists()) {
+                                            if (finalFile.isDirectory()) {
+                                                break;
+                                            }
+                                            if (!finalFile.delete()) {
+                                                errStr = "Can't remove old file:" + finalFile.getAbsolutePath();
+                                                break;
+                                            }
+                                        }
+                                        tempFile.renameTo(finalFile);
+                                    } while (false);
+
+                                    if (errStr == null) {
+                                        downloader.onFinish(id, 0, null, null);
+                                        downloader.runNextTaskIfExists();
+                                    }
+                                    else
+                                        downloader.onFinish(id, 0, errStr, null);
+                                } else {
+                                    // 非文件
+                                    ByteArrayOutputStream buffer;
+                                    if(total > 0) {
+                                        buffer = new ByteArrayOutputStream((int) total);
+                                    } else {
+                                        buffer = new ByteArrayOutputStream(4096);
+                                    }
+
+                                    int len;
+                                    while ((len = is.read(buf)) != -1) {
+                                        current += len;
+                                        buffer.write(buf, 0, len);
+                                        downloader.onProgress(id, len, current, total);
+                                    }
+                                    downloader.onFinish(id, 0, null, buffer.toByteArray());
+                                    downloader.runNextTaskIfExists();
+                                }
+                            } catch (IOException e) {
+                                e.printStackTrace();
+                                downloader.onFinish(id, 0, e.toString(), null);
+                            } finally {
+                                try {
+                                    if (is != null) {
+                                        is.close();
+                                    }
+                                    if (fos != null) {
+                                        fos.close();
+                                    }
+                                } catch (IOException e) {
+                                    Log.e("Cocos2dxDownloader", e.toString());
+                                }
+                            }
+                        }
+                    });
+                } while (false);
+            }
+        };
+        downloader.enqueueTask(taskRunnable);
+    }
+
+    public static void abort(final Cocos2dxDownloader downloader, final int id) {
+        Cocos2dxHelper.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Iterator iter = downloader._taskMap.entrySet().iterator();
+                while (iter.hasNext()) {
+                    Map.Entry entry = (Map.Entry) iter.next();
+                    Object key = entry.getKey();
+                    Call task = (Call) entry.getValue();
+                    if (null != task && Integer.parseInt(key.toString()) == id) {
+                        task.cancel();
+                        downloader._taskMap.remove(id);
+                        downloader.runNextTaskIfExists();
+                        break;
+                    }
+                }
+            }
+        });
+    }
+
+    public static void cancelAllRequests(final Cocos2dxDownloader downloader) {
+        Cocos2dxHelper.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                for (Object o : downloader._taskMap.entrySet()) {
+                    Map.Entry entry = (Map.Entry) o;
+                    Call task = (Call) entry.getValue();
+                    if (null != task) {
+                        task.cancel();
+                    }
+                }
+            }
+        });
+    }
+
+
+    private void enqueueTask(Runnable taskRunnable) {
+        synchronized (_taskQueue) {
+            if (_runningTaskCount < _countOfMaxProcessingTasks) {
+                Cocos2dxHelper.getActivity().runOnUiThread(taskRunnable);
+                _runningTaskCount++;
+            } else {
+                _taskQueue.add(taskRunnable);
+            }
+        }
+    }
+
+    private void runNextTaskIfExists() {
+        synchronized (_taskQueue) {
+            while (_runningTaskCount < _countOfMaxProcessingTasks && 
+                Cocos2dxDownloader.this._taskQueue.size() > 0) {
+                
+                Runnable taskRunnable = Cocos2dxDownloader.this._taskQueue.poll();
+                Cocos2dxHelper.getActivity().runOnUiThread(taskRunnable);
+                _runningTaskCount += 1;
+            }
+        }
+    }
+
+    native void nativeOnProgress(int id, int taskId, long dl, long dlnow, long dltotal);
+    native void nativeOnFinish(int id, int taskId, int errCode, String errStr, final byte[] data);
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxEditBox.java

@@ -0,0 +1,479 @@
+/****************************************************************************
+Copyright (c) 2010-2012 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.StateListDrawable;
+import android.graphics.drawable.shapes.RoundRectShape;
+import android.text.Editable;
+import android.text.InputFilter;
+import android.text.InputType;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.view.WindowManager;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+
+public class Cocos2dxEditBox {
+
+    // a color of dark green, was used for confirm button background
+    private static final int DARK_GREEN = Color.parseColor("#1fa014");
+    private static final int DARK_GREEN_PRESS = Color.parseColor("#008e26");
+
+    private static Cocos2dxEditBox sThis = null;
+    private Cocos2dxEditText mEditText = null;
+    private Button mButton = null;
+    private String mButtonTitle = null;
+    private boolean mConfirmHold = true;
+    private Cocos2dxActivity mActivity = null;
+    private RelativeLayout mButtonLayout = null;
+    private RelativeLayout.LayoutParams mButtonParams;
+    private int mEditTextID = 1;
+    private int mButtonLayoutID = 2;
+
+    /***************************************************************************************
+     Inner class.
+     **************************************************************************************/
+    class Cocos2dxEditText extends EditText {
+        private final String TAG = "Cocos2dxEditBox";
+        private boolean mIsMultiLine = false;
+        private TextWatcher mTextWatcher = null;
+        private Paint mPaint;
+        private int mLineColor = DARK_GREEN;
+        private float mLineWidth = 2f;
+        private boolean keyboardVisible = false;
+        private int mScreenHeight;
+        private int mTopMargin = 0;
+        private int mOrientation;
+
+        public  Cocos2dxEditText(Cocos2dxActivity context){
+            super(context);
+            //remove focus border
+            this.setBackground(null);
+            this.setTextColor(Color.BLACK);
+            mScreenHeight = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).
+                    getDefaultDisplay().getHeight();
+            mPaint = new Paint();
+            mPaint.setStrokeWidth(mLineWidth);
+            mPaint.setStyle(Paint.Style.FILL);
+            mPaint.setColor(mLineColor);
+            mOrientation = this.getResources().getConfiguration().orientation;
+
+            mTextWatcher = new TextWatcher() {
+                @Override
+                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+
+                }
+
+                @Override
+                public void onTextChanged(CharSequence s, int start, int before, int count) {
+
+                }
+
+                @Override
+                public void afterTextChanged(Editable s) {
+                    // Pass text to c++.
+                    Cocos2dxEditBox.this.onKeyboardInput(s.toString());
+                }
+            };
+            registKeyboardVisible();
+        }
+
+        /***************************************************************************************
+         Override functions.
+         **************************************************************************************/
+
+        @Override
+        protected void onDraw(Canvas canvas) {
+            // draw the underline
+            int padB = this.getPaddingBottom();
+            canvas.drawLine(getScrollX(), this.getHeight() - padB / 2 - mLineWidth,
+                    getScrollX() + this.getWidth(),
+                    this.getHeight() - padB / 2 - mLineWidth, mPaint);
+            super.onDraw(canvas);
+        }
+
+        @Override
+        protected void onConfigurationChanged(Configuration newConfig) {
+            super.onConfigurationChanged(newConfig);
+            int newOrientation = newConfig.orientation;
+            if (mOrientation != newOrientation) {
+                mOrientation = newOrientation;
+                mTopMargin = 0;  // clear top margin cache
+            }
+        }
+
+        /***************************************************************************************
+         Public functions.
+         **************************************************************************************/
+
+        public void show(String defaultValue, int maxLength, boolean isMultiline, boolean confirmHold, String confirmType, String inputType) {
+            mIsMultiLine = isMultiline;
+            this.setFilters(new InputFilter[]{new InputFilter.LengthFilter(maxLength) });
+            this.setText(defaultValue);
+            if (this.getText().length() >= defaultValue.length()) {
+                this.setSelection(defaultValue.length());
+            } else {
+                this.setSelection(this.getText().length());
+            }
+            this.setConfirmType(confirmType);
+            this.setInputType(inputType, mIsMultiLine);
+            this.setVisibility(View.VISIBLE);
+
+            // Open soft keyboard manually. Should request focus to open soft keyboard.
+            this.requestFocus();
+
+            this.addListeners();
+        }
+
+        public void hide() {
+            mEditText.setVisibility(View.INVISIBLE);
+            this.removeListeners();
+        }
+
+        /***************************************************************************************
+         Private functions.
+         **************************************************************************************/
+
+        private void setConfirmType(final String confirmType) {
+            if (confirmType.contentEquals("done")) {
+                this.setImeOptions(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
+                mButtonTitle = mActivity.getResources().getString(R.string.done);
+            } else if (confirmType.contentEquals("next")) {
+                this.setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
+                mButtonTitle = mActivity.getResources().getString(R.string.next);
+            } else if (confirmType.contentEquals("search")) {
+                this.setImeOptions(EditorInfo.IME_ACTION_SEARCH | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
+                mButtonTitle = mActivity.getResources().getString(R.string.search);
+            } else if (confirmType.contentEquals("go")) {
+                this.setImeOptions(EditorInfo.IME_ACTION_GO | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
+                mButtonTitle = mActivity.getResources().getString(R.string.go);
+            } else if (confirmType.contentEquals("send")) {
+                this.setImeOptions(EditorInfo.IME_ACTION_SEND | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
+                mButtonTitle = mActivity.getResources().getString(R.string.send);
+            } else{
+                mButtonTitle = null;
+                Log.e(TAG, "unknown confirm type " + confirmType);
+            }
+        }
+
+        private void setInputType(final String inputType, boolean isMultiLine){
+            if (inputType.contentEquals("text")) {
+                if (isMultiLine)
+                    this.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_MULTI_LINE);
+                else
+                    this.setInputType(InputType.TYPE_CLASS_TEXT);
+            }
+            else if (inputType.contentEquals("email"))
+                this.setInputType(InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS);
+            else if (inputType.contentEquals("number"))
+                this.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_NUMBER_FLAG_SIGNED);
+            else if (inputType.contentEquals("phone"))
+                this.setInputType(InputType.TYPE_CLASS_PHONE);
+            else if (inputType.contentEquals("password"))
+                this.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
+            else
+                Log.e(TAG, "unknown input type " + inputType);
+        }
+
+        private void addListeners() {
+
+            this.setOnEditorActionListener(new TextView.OnEditorActionListener() {
+                @Override
+                public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+                    if (! mIsMultiLine) {
+                        Cocos2dxEditBox.this.hide();
+                    }
+
+                    return false; // pass on to other listeners.
+                }
+            });
+
+
+            this.addTextChangedListener(mTextWatcher);
+        }
+
+        private void removeListeners() {
+            this.setOnEditorActionListener(null);
+            this.removeTextChangedListener(mTextWatcher);
+        }
+
+        private void registKeyboardVisible() {
+            getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
+                @Override
+                public void onGlobalLayout() {
+                    Rect r = new Rect();
+                    getWindowVisibleDisplayFrame(r);
+                    int heightDiff = getRootView().getHeight() - (r.bottom - r.top);
+                    // if more than a quarter of the screen, its probably a keyboard
+                    if (heightDiff > mScreenHeight/4) {
+                        if (!keyboardVisible) {
+                            keyboardVisible = true;
+                        }
+                    } else {
+                        if (keyboardVisible) {
+                            keyboardVisible = false;
+                            Cocos2dxEditBox.this.hide();
+                        }
+                    }
+
+                    if (Cocos2dxEditText.this.mTopMargin == 0 && r.bottom != getRootView().getHeight()) {
+                        Cocos2dxEditText.this.setTopMargin(r.bottom);
+                    }
+                }
+            });
+        }
+
+        private void setTopMargin(int topMargin) {
+            mTopMargin = topMargin;
+            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) mEditText.getLayoutParams();
+            layoutParams.topMargin = mTopMargin - getHeight();
+            setLayoutParams(layoutParams);
+            requestLayout();
+        }
+    }
+
+    public Cocos2dxEditBox(Cocos2dxActivity context, FrameLayout layout) {
+        Cocos2dxEditBox.sThis = this;
+        mActivity = context;
+        this.addItems(context, layout);
+    }
+
+    /***************************************************************************************
+     Public functions.
+     **************************************************************************************/
+
+    // Invoked by surface view to send a complete message to CPP.
+    public static void complete() {
+        Cocos2dxEditBox.sThis.hide();
+    }
+
+    /***************************************************************************************
+     Private functions.
+     **************************************************************************************/
+    private void addItems(Cocos2dxActivity context, FrameLayout layout) {
+        RelativeLayout myLayout = new RelativeLayout(context);
+        myLayout.setFitsSystemWindows(true);
+        this.addEditText(context, myLayout);
+        this.addButton(context, myLayout);
+
+        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+        layoutParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
+        layout.addView(myLayout, layoutParams);
+
+        //FXI ME: Is it needed?
+        // When touch area outside EditText and soft keyboard, then hide.
+//        layout.setOnTouchListener(new View.OnTouchListener() {
+//            @Override
+//            public boolean onTouch(View v, MotionEvent event) {
+//                Cocos2dxEditBox.this.hide();
+//                return true;
+//            }
+//
+//        });
+    }
+
+    private void addEditText(Cocos2dxActivity context, RelativeLayout layout) {
+        mEditText = new Cocos2dxEditText(context);
+        mEditText.setVisibility(View.INVISIBLE);
+        mEditText.setBackgroundColor(Color.WHITE);
+        mEditText.setId(mEditTextID);
+        RelativeLayout.LayoutParams editParams = new RelativeLayout.LayoutParams(
+                ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+        editParams.addRule(RelativeLayout.LEFT_OF, mButtonLayoutID);
+        layout.addView(mEditText, editParams);
+    }
+
+    private void addButton(Cocos2dxActivity context, RelativeLayout layout) {
+        mButton = new Button(context);
+        mButtonParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+        mButton.setTextColor(Color.WHITE);
+        mButton.setBackground(getRoundRectShape());
+        mButtonLayout = new RelativeLayout(Cocos2dxHelper.getActivity());
+        mButtonLayout.setVisibility(View.INVISIBLE);
+        mButtonLayout.setBackgroundColor(Color.WHITE);
+        RelativeLayout.LayoutParams buttonLayoutParams = new RelativeLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+        buttonLayoutParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
+        buttonLayoutParams.addRule(RelativeLayout.ALIGN_BOTTOM, mEditTextID);
+        buttonLayoutParams.addRule(RelativeLayout.ALIGN_TOP, mEditTextID);
+        mButtonLayout.addView(mButton, mButtonParams);
+        mButtonLayout.setId(mButtonLayoutID);
+        layout.addView(mButtonLayout, buttonLayoutParams);
+
+        mButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Cocos2dxEditBox.this.onKeyboardConfirm(mEditText.getText().toString());
+
+                if (!Cocos2dxEditBox.this.mConfirmHold)
+                    Cocos2dxEditBox.this.hide();
+            }
+        });
+    }
+
+    private Drawable getRoundRectShape() {
+        int radius = 7;
+        float[] outerRadii = new float[]{radius, radius, radius, radius, radius, radius, radius, radius};
+        RoundRectShape roundRectShape = new RoundRectShape(outerRadii, null, null);
+        ShapeDrawable shapeDrawableNormal = new ShapeDrawable();
+        shapeDrawableNormal.setShape(roundRectShape);
+        shapeDrawableNormal.getPaint().setStyle(Paint.Style.FILL);
+        shapeDrawableNormal.getPaint().setColor(DARK_GREEN);
+        ShapeDrawable shapeDrawablePress = new ShapeDrawable();
+        shapeDrawablePress.setShape(roundRectShape);
+        shapeDrawablePress.getPaint().setStyle(Paint.Style.FILL);
+        shapeDrawablePress.getPaint().setColor(DARK_GREEN_PRESS);
+        StateListDrawable drawable = new StateListDrawable();
+        drawable.addState(new int[]{android.R.attr.state_pressed}, shapeDrawablePress);
+        drawable.addState(new int[]{}, shapeDrawableNormal);
+        return drawable;
+    }
+
+
+    private void hide() {
+        Utils.hideVirtualButton();
+        mEditText.hide();
+        mButtonLayout.setVisibility(View.INVISIBLE);
+        this.closeKeyboard();
+
+        mActivity.getGLSurfaceView().requestFocus();
+        mActivity.getGLSurfaceView().setStopHandleTouchAndKeyEvents(false);
+    }
+
+    private void show(String defaultValue, int maxLength, boolean isMultiline, boolean confirmHold, String confirmType, String inputType) {
+        mConfirmHold = confirmHold;
+        mEditText.show(defaultValue, maxLength, isMultiline, confirmHold, confirmType, inputType);
+        int editPaddingBottom = mEditText.getPaddingBottom();
+        int editPadding = mEditText.getPaddingTop();
+        mEditText.setPadding(editPadding, editPadding, editPadding, editPaddingBottom);
+        mButton.setText(mButtonTitle);
+        if (TextUtils.isEmpty(mButtonTitle)) {
+            mButton.setPadding(0, 0, 0, 0);
+            mButtonParams.setMargins(0, 0, 0, 0);
+            mButtonLayout.setVisibility(View.INVISIBLE);
+        } else {
+            int buttonTextPadding = mEditText.getPaddingBottom() / 2;
+            mButton.setPadding(editPadding, buttonTextPadding, editPadding, buttonTextPadding);
+            mButtonParams.setMargins(0, buttonTextPadding, 2, 0);
+            mButtonLayout.setVisibility(View.VISIBLE);
+        }
+        mActivity.getGLSurfaceView().setStopHandleTouchAndKeyEvents(true);
+        this.openKeyboard();
+    }
+
+    private void closeKeyboard() {
+        InputMethodManager imm = (InputMethodManager) Cocos2dxEditBox.this.mActivity.getSystemService(Cocos2dxEditBox.this.mActivity.INPUT_METHOD_SERVICE);
+        imm.hideSoftInputFromWindow(mEditText.getWindowToken(), 0);
+
+        this.onKeyboardComplete(mEditText.getText().toString());
+    }
+
+    private void openKeyboard() {
+        InputMethodManager imm = (InputMethodManager) Cocos2dxEditBox.this.mActivity.getSystemService(Cocos2dxEditBox.this.mActivity.INPUT_METHOD_SERVICE);
+        imm.showSoftInput(mEditText, InputMethodManager.SHOW_IMPLICIT);
+    }
+
+    /***************************************************************************************
+     Functions invoked by CPP.
+     **************************************************************************************/
+
+    private static void showNative(String defaultValue, int maxLength, boolean isMultiline, boolean confirmHold, String confirmType, String inputType) {
+        if (null != Cocos2dxEditBox.sThis) {
+            Cocos2dxEditBox.sThis.mActivity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    Cocos2dxEditBox.sThis.show(defaultValue, maxLength, isMultiline, confirmHold, confirmType, inputType);
+                }
+            });
+        }
+    }
+
+    private static void hideNative() {
+        if (null != Cocos2dxEditBox.sThis) {
+            Cocos2dxEditBox.sThis.mActivity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    Cocos2dxEditBox.sThis.hide();
+                }
+            });
+        }
+    }
+
+    /***************************************************************************************
+     Native functions invoked by UI.
+     **************************************************************************************/
+    private void onKeyboardInput(String text) {
+        mActivity.runOnGLThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxEditBox.onKeyboardInputNative(text);
+            }
+        });
+    }
+
+    private void onKeyboardComplete(String text) {
+        mActivity.getGLSurfaceView().requestFocus();
+        mActivity.getGLSurfaceView().setStopHandleTouchAndKeyEvents(false);
+        mActivity.runOnGLThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxEditBox.onKeyboardCompleteNative(text);
+            }
+        });
+    }
+
+    private void onKeyboardConfirm(String text) {
+        mActivity.runOnGLThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxEditBox.onKeyboardConfirmNative(text);
+            }
+        });
+    }
+
+    private static native void onKeyboardInputNative(String text);
+    private static native void onKeyboardCompleteNative(String text);
+    private static native void onKeyboardConfirmNative(String text);
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxGLSurfaceView.java

@@ -0,0 +1,343 @@
+/****************************************************************************
+Copyright (c) 2010-2013 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.os.Handler;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+public class Cocos2dxGLSurfaceView extends GLSurfaceView {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+
+    private static final String TAG = Cocos2dxGLSurfaceView.class.getSimpleName();
+
+    private final static int HANDLER_OPEN_IME_KEYBOARD = 2;
+    private final static int HANDLER_CLOSE_IME_KEYBOARD = 3;
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+
+    // REFINE: Static handler -> Potential leak!
+    private static Handler sHandler;
+    private static Cocos2dxGLSurfaceView mCocos2dxGLSurfaceView;
+
+    private Cocos2dxRenderer mCocos2dxRenderer;
+    private boolean mStopHandleTouchAndKeyEvents = false;
+
+    public static native void nativeOnSizeChanged(int width, int height);
+
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+
+    public Cocos2dxGLSurfaceView(final Context context) {
+        super(context);
+
+        this.initView();
+    }
+
+    public Cocos2dxGLSurfaceView(final Context context, final AttributeSet attrs) {
+        super(context, attrs);
+        
+        this.initView();
+    }
+
+    protected void initView() {
+        this.setEGLContextClientVersion(2);
+        this.setFocusableInTouchMode(true);
+
+        Cocos2dxGLSurfaceView.mCocos2dxGLSurfaceView = this;
+    }
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+
+
+       public static Cocos2dxGLSurfaceView getInstance() {
+       return mCocos2dxGLSurfaceView;
+       }
+
+       public static void queueAccelerometer(final float x, final float y, final float z, final long timestamp) {
+           mCocos2dxGLSurfaceView.queueEvent(new Runnable() {
+            @Override
+                public void run() {
+                    Cocos2dxAccelerometer.onSensorChanged(x, y, z, timestamp);
+            }
+        });
+    }
+
+    public void setCocos2dxRenderer(final Cocos2dxRenderer renderer) {
+        this.mCocos2dxRenderer = renderer;
+        this.setRenderer(this.mCocos2dxRenderer);
+    }
+
+    private String getContentText() {
+        return this.mCocos2dxRenderer.getContentText();
+    }
+
+    // ===========================================================
+    // Methods for/from SuperClass/Interfaces
+    // ===========================================================
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        this.setRenderMode(RENDERMODE_CONTINUOUSLY);
+        this.queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleOnResume();
+            }
+        });
+        mCocos2dxRenderer.setPauseInMainThread(false);
+    }
+
+    @Override
+    public void onPause() {
+        this.queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleOnPause();
+            }
+        });
+        this.setRenderMode(RENDERMODE_WHEN_DIRTY);
+        mCocos2dxRenderer.setPauseInMainThread(true);
+        //super.onPause();
+    }
+
+    @Override
+    public boolean onTouchEvent(final MotionEvent pMotionEvent) {
+        // these data are used in ACTION_MOVE and ACTION_CANCEL
+        final int pointerNumber = pMotionEvent.getPointerCount();
+        final int[] ids = new int[pointerNumber];
+        final float[] xs = new float[pointerNumber];
+        final float[] ys = new float[pointerNumber];
+
+        for (int i = 0; i < pointerNumber; i++) {
+            ids[i] = pMotionEvent.getPointerId(i);
+            xs[i] = pMotionEvent.getX(i);
+            ys[i] = pMotionEvent.getY(i);
+        }
+
+        switch (pMotionEvent.getAction() & MotionEvent.ACTION_MASK) {
+            case MotionEvent.ACTION_POINTER_DOWN:
+                if (mStopHandleTouchAndKeyEvents) {
+                    Cocos2dxEditBox.complete();
+                    return true;
+                }
+
+                final int indexPointerDown = pMotionEvent.getAction() >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+                final int idPointerDown = pMotionEvent.getPointerId(indexPointerDown);
+                final float xPointerDown = pMotionEvent.getX(indexPointerDown);
+                final float yPointerDown = pMotionEvent.getY(indexPointerDown);
+
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleActionDown(idPointerDown, xPointerDown, yPointerDown);
+                    }
+                });
+                break;
+
+            case MotionEvent.ACTION_DOWN:
+                if (mStopHandleTouchAndKeyEvents) {
+                    Cocos2dxEditBox.complete();
+                    return true;
+                }
+
+                // there are only one finger on the screen
+                final int idDown = pMotionEvent.getPointerId(0);
+                final float xDown = xs[0];
+                final float yDown = ys[0];
+
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleActionDown(idDown, xDown, yDown);
+                    }
+                });
+                break;
+
+            case MotionEvent.ACTION_MOVE:
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleActionMove(ids, xs, ys);
+                    }
+                });
+                break;
+
+            case MotionEvent.ACTION_POINTER_UP:
+                final int indexPointUp = pMotionEvent.getAction() >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+                final int idPointerUp = pMotionEvent.getPointerId(indexPointUp);
+                final float xPointerUp = pMotionEvent.getX(indexPointUp);
+                final float yPointerUp = pMotionEvent.getY(indexPointUp);
+
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleActionUp(idPointerUp, xPointerUp, yPointerUp);
+                    }
+                });
+                break;
+
+            case MotionEvent.ACTION_UP:
+                // there are only one finger on the screen
+                final int idUp = pMotionEvent.getPointerId(0);
+                final float xUp = xs[0];
+                final float yUp = ys[0];
+
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleActionUp(idUp, xUp, yUp);
+                    }
+                });
+                break;
+
+            case MotionEvent.ACTION_CANCEL:
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleActionCancel(ids, xs, ys);
+                    }
+                });
+                break;
+        }
+
+        /*
+        if (BuildConfig.DEBUG) {
+            Cocos2dxGLSurfaceView.dumpMotionEvent(pMotionEvent);
+        }
+        */
+        return true;
+    }
+
+    /*
+     * This function is called before Cocos2dxRenderer.nativeInit(), so the
+     * width and height is correct.
+     */
+    @Override
+    protected void onSizeChanged(final int pNewSurfaceWidth, final int pNewSurfaceHeight, final int pOldSurfaceWidth, final int pOldSurfaceHeight) {
+        if(!this.isInEditMode()) {
+            this.mCocos2dxRenderer.setScreenWidthAndHeight(pNewSurfaceWidth, pNewSurfaceHeight);
+            nativeOnSizeChanged(pNewSurfaceWidth, pNewSurfaceHeight);
+        }
+    }
+
+    @Override
+    public boolean onKeyDown(final int pKeyCode, final KeyEvent pKeyEvent) {
+        switch (pKeyCode) {
+            case KeyEvent.KEYCODE_BACK:
+                Cocos2dxVideoHelper.mVideoHandler.sendEmptyMessage(Cocos2dxVideoHelper.KeyEventBack);
+            case KeyEvent.KEYCODE_MENU:
+            case KeyEvent.KEYCODE_DPAD_LEFT:
+            case KeyEvent.KEYCODE_DPAD_RIGHT:
+            case KeyEvent.KEYCODE_DPAD_UP:
+            case KeyEvent.KEYCODE_DPAD_DOWN:
+            case KeyEvent.KEYCODE_ENTER:
+            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
+            case KeyEvent.KEYCODE_DPAD_CENTER:
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleKeyDown(pKeyCode);
+                    }
+                });
+                return true;
+            default:
+                return super.onKeyDown(pKeyCode, pKeyEvent);
+        }
+    }
+
+    @Override
+    public boolean onKeyUp(final int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_BACK:
+            case KeyEvent.KEYCODE_MENU:
+            case KeyEvent.KEYCODE_DPAD_LEFT:
+            case KeyEvent.KEYCODE_DPAD_RIGHT:
+            case KeyEvent.KEYCODE_DPAD_UP:
+            case KeyEvent.KEYCODE_DPAD_DOWN:
+            case KeyEvent.KEYCODE_ENTER:
+            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
+            case KeyEvent.KEYCODE_DPAD_CENTER:
+                this.queueEvent(new Runnable() {
+                    @Override
+                    public void run() {
+                        Cocos2dxGLSurfaceView.this.mCocos2dxRenderer.handleKeyUp(keyCode);
+                    }
+                });
+                return true;
+            default:
+                return super.onKeyUp(keyCode, event);
+        }
+    }
+
+    // ===========================================================
+    // Methods
+    // ===========================================================
+
+    public void setStopHandleTouchAndKeyEvents(boolean value) {
+        mStopHandleTouchAndKeyEvents = value;
+    }
+
+    // ===========================================================
+    // Inner and Anonymous Classes
+    // ===========================================================
+
+    private static void dumpMotionEvent(final MotionEvent event) {
+        final String names[] = { "DOWN", "UP", "MOVE", "CANCEL", "OUTSIDE", "POINTER_DOWN", "POINTER_UP", "7?", "8?", "9?" };
+        final StringBuilder sb = new StringBuilder();
+        final int action = event.getAction();
+        final int actionCode = action & MotionEvent.ACTION_MASK;
+        sb.append("event ACTION_").append(names[actionCode]);
+        if (actionCode == MotionEvent.ACTION_POINTER_DOWN || actionCode == MotionEvent.ACTION_POINTER_UP) {
+            sb.append("(pid ").append(action >> MotionEvent.ACTION_POINTER_INDEX_SHIFT);
+            sb.append(")");
+        }
+        sb.append("[");
+        for (int i = 0; i < event.getPointerCount(); i++) {
+            sb.append("#").append(i);
+            sb.append("(pid ").append(event.getPointerId(i));
+            sb.append(")=").append((int) event.getX(i));
+            sb.append(",").append((int) event.getY(i));
+            if (i + 1 < event.getPointerCount()) {
+                sb.append(";");
+            }
+        }
+        sb.append("]");
+        Log.d(Cocos2dxGLSurfaceView.TAG, sb.toString());
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxHandler.java

@@ -0,0 +1,104 @@
+/****************************************************************************
+Copyright (c) 2010-2013 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+
+package org.cocos2dx.lib;
+
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.os.Handler;
+import android.os.Message;
+
+import java.lang.ref.WeakReference;
+
+public class Cocos2dxHandler extends Handler {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+    public final static int HANDLER_SHOW_DIALOG = 1;
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+    private WeakReference<Cocos2dxActivity> mActivity;
+    
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+    public Cocos2dxHandler(Cocos2dxActivity activity) {
+        this.mActivity = new WeakReference<Cocos2dxActivity>(activity);
+    }
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+
+    // ===========================================================
+    // Methods for/from SuperClass/Interfaces
+    // ===========================================================
+    
+    // ===========================================================
+    // Methods
+    // ===========================================================
+
+    public void handleMessage(Message msg) {
+        switch (msg.what) {
+        case Cocos2dxHandler.HANDLER_SHOW_DIALOG:
+            showDialog(msg);
+            break;
+        }
+    }
+
+    private void showDialog(Message msg) {
+        Cocos2dxActivity theActivity = this.mActivity.get();
+        DialogMessage dialogMessage = (DialogMessage)msg.obj;
+        new AlertDialog.Builder(theActivity)
+        .setTitle(dialogMessage.title)
+        .setMessage(dialogMessage.message)
+        .setPositiveButton("Ok", 
+                new DialogInterface.OnClickListener() {
+
+                    @Override
+                    public void onClick(DialogInterface dialog, int which) {
+                        // REFINE: Auto-generated method stub
+
+                    }
+                }).create().show();
+    }
+
+    // ===========================================================
+    // Inner and Anonymous Classes
+    // ===========================================================
+
+    public static class DialogMessage {
+        public String title;
+        public String message;
+        
+        public DialogMessage(String title, String message) {
+            this.title = title;
+            this.message = message;
+        }
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxHelper.java

@@ -0,0 +1,664 @@
+/****************************************************************************
+Copyright (c) 2010-2012 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.AssetManager;
+import android.media.AudioManager;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.Uri;
+import android.os.BatteryManager;
+import android.os.Build;
+import android.os.Environment;
+import android.os.ParcelFileDescriptor;
+import android.os.Vibrator;
+import android.preference.PreferenceManager.OnActivityResultListener;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.Display;
+import android.view.Surface;
+import android.view.WindowInsets;
+import android.view.WindowManager;
+
+import com.android.vending.expansion.zipfile.APKExpansionSupport;
+import com.android.vending.expansion.zipfile.ZipResourceFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.LinkedHashSet;
+import java.util.Locale;
+import java.util.Set;
+
+
+public class Cocos2dxHelper {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+    private static final String PREFS_NAME = "Cocos2dxPrefsFile";
+    private static final int RUNNABLES_PER_FRAME = 5;
+    private static final String TAG = Cocos2dxHelper.class.getSimpleName();
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+
+    private static AssetManager sAssetManager;
+    private static Cocos2dxAccelerometer sCocos2dxAccelerometer;
+    private static boolean sAccelerometerEnabled;
+    private static boolean sCompassEnabled;
+    private static boolean sActivityVisible;
+    private static String sPackageName;
+    private static String sFileDirectory;
+    private static Activity sActivity = null;
+    private static Cocos2dxHelperListener sCocos2dxHelperListener;
+    private static Set<OnActivityResultListener> onActivityResultListeners = new LinkedHashSet<OnActivityResultListener>();
+    private static Vibrator sVibrateService = null;
+
+    // The absolute path to the OBB if it exists, else the absolute path to the APK.
+    private static String sAssetsPath = "";
+    
+    // The OBB file
+    private static ZipResourceFile sOBBFile = null;
+
+    /**
+     * Battery receiver to getting battery level.
+     */
+    static class BatteryReceiver extends BroadcastReceiver {
+        public float sBatteryLevel = 0.0f;
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            setBatteryLevelByIntent(intent);
+        }
+
+        public void setBatteryLevelByIntent(Intent intent) {
+            if (null != intent) {
+                int current = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0);
+                int total = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 1);
+                float level = current * 1.0f / total;
+                // clamp to 0~1
+                sBatteryLevel = Math.min(Math.max(level, 0.0f), 1.0f);
+            }
+        }
+    }
+
+    private static BatteryReceiver sBatteryReceiver = new BatteryReceiver();
+
+    static void registerBatteryLevelReceiver(Context context) {
+        Intent intent = context.registerReceiver(sBatteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+        sBatteryReceiver.setBatteryLevelByIntent(intent);
+    }
+
+    static void unregisterBatteryLevelReceiver(Context context) {
+        context.unregisterReceiver(sBatteryReceiver);
+    }
+
+    public static float getBatteryLevel() {
+        return sBatteryReceiver.sBatteryLevel;
+    }
+
+    public static final int NETWORK_TYPE_NONE = 0;
+    public static final int NETWORK_TYPE_LAN  = 1;
+    public static final int NETWORK_TYPE_WWAN = 2;
+
+    public static int getNetworkType() {
+        int status = NETWORK_TYPE_NONE;
+        NetworkInfo networkInfo;
+        try {
+            ConnectivityManager connMgr = (ConnectivityManager) sActivity.getSystemService(Context.CONNECTIVITY_SERVICE);
+            networkInfo = connMgr.getActiveNetworkInfo();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return status;
+        }
+        if (networkInfo == null) {
+            return status;
+        }
+        int nType = networkInfo.getType();
+        if (nType == ConnectivityManager.TYPE_MOBILE) {
+            status = NETWORK_TYPE_WWAN;
+        } else if (nType == ConnectivityManager.TYPE_WIFI) {
+            status = NETWORK_TYPE_LAN;
+        }
+        return status;
+    }
+
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+
+    public static void runOnGLThread(final Runnable r) {
+        ((Cocos2dxActivity)sActivity).runOnGLThread(r);
+    }
+
+    private static boolean sInited = false;
+    public static void init(final Activity activity) {
+        sActivity = activity;
+        Cocos2dxHelper.sCocos2dxHelperListener = (Cocos2dxHelperListener)activity;
+        if (!sInited) {
+
+            PackageManager pm = activity.getPackageManager();
+            boolean isSupportLowLatency = pm.hasSystemFeature(PackageManager.FEATURE_AUDIO_LOW_LATENCY);
+
+            Log.d(TAG, "isSupportLowLatency:" + isSupportLowLatency);
+
+            int sampleRate = 44100;
+            int bufferSizeInFrames = 192;
+
+            if (Build.VERSION.SDK_INT >= 17) {
+                AudioManager am = (AudioManager) activity.getSystemService(Context.AUDIO_SERVICE);
+                // use reflection to remove dependence of API 17 when compiling
+
+                // AudioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE);
+                final Class audioManagerClass = AudioManager.class;
+                Object[] parameters = new Object[]{Cocos2dxReflectionHelper.<String>getConstantValue(audioManagerClass, "PROPERTY_OUTPUT_SAMPLE_RATE")};
+                final String strSampleRate = Cocos2dxReflectionHelper.<String>invokeInstanceMethod(am, "getProperty", new Class[]{String.class}, parameters);
+
+                // AudioManager.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER);
+                parameters = new Object[]{Cocos2dxReflectionHelper.<String>getConstantValue(audioManagerClass, "PROPERTY_OUTPUT_FRAMES_PER_BUFFER")};
+                final String strBufferSizeInFrames = Cocos2dxReflectionHelper.<String>invokeInstanceMethod(am, "getProperty", new Class[]{String.class}, parameters);
+
+                sampleRate = Integer.parseInt(strSampleRate);
+                bufferSizeInFrames = Integer.parseInt(strBufferSizeInFrames);
+
+                Log.d(TAG, "sampleRate: " + sampleRate + ", framesPerBuffer: " + bufferSizeInFrames);
+            } else {
+                Log.d(TAG, "android version is lower than 17");
+            }
+
+            nativeSetAudioDeviceInfo(isSupportLowLatency, sampleRate, bufferSizeInFrames);
+
+            final ApplicationInfo applicationInfo = activity.getApplicationInfo();
+            
+            Cocos2dxHelper.sPackageName = applicationInfo.packageName;
+            Cocos2dxHelper.sFileDirectory = activity.getFilesDir().getAbsolutePath();
+            
+            Cocos2dxHelper.nativeSetApkPath(Cocos2dxHelper.getAssetsPath());
+    
+            Cocos2dxHelper.sCocos2dxAccelerometer = new Cocos2dxAccelerometer(activity);
+            Cocos2dxHelper.sAssetManager = activity.getAssets();
+            Cocos2dxHelper.nativeSetContext((Context)activity, Cocos2dxHelper.sAssetManager);
+            Cocos2dxHelper.sVibrateService = (Vibrator)activity.getSystemService(Context.VIBRATOR_SERVICE);
+
+            sInited = true;
+            
+            int versionCode = 1;
+            try {
+                versionCode = Cocos2dxActivity.getContext().getPackageManager().getPackageInfo(Cocos2dxHelper.getPackageName(), 0).versionCode;
+            } catch (NameNotFoundException e) {
+                e.printStackTrace();
+            }
+            try {
+                Cocos2dxHelper.sOBBFile = APKExpansionSupport.getAPKExpansionZipFile(Cocos2dxActivity.getContext(), versionCode, 0);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+    
+    // This function returns the absolute path to the OBB if it exists,
+    // else it returns the absolute path to the APK.
+    public static String getAssetsPath()
+    {
+        if (Cocos2dxHelper.sAssetsPath == "") {
+            int versionCode = 1;
+            try {
+                versionCode = Cocos2dxHelper.sActivity.getPackageManager().getPackageInfo(Cocos2dxHelper.sPackageName, 0).versionCode;
+            } catch (NameNotFoundException e) {
+                e.printStackTrace();
+            }
+            String pathToOBB = Environment.getExternalStorageDirectory().getAbsolutePath() + "/Android/obb/" + Cocos2dxHelper.sPackageName + "/main." + versionCode + "." + Cocos2dxHelper.sPackageName + ".obb";
+            File obbFile = new File(pathToOBB);
+            if (obbFile.exists())
+                Cocos2dxHelper.sAssetsPath = pathToOBB;
+            else
+                Cocos2dxHelper.sAssetsPath = Cocos2dxHelper.sActivity.getApplicationInfo().sourceDir;
+        }
+        
+        return Cocos2dxHelper.sAssetsPath;
+    }
+    
+    public static ZipResourceFile getObbFile()
+    {
+        return Cocos2dxHelper.sOBBFile;
+    }
+    
+    public static Activity getActivity() {
+        return sActivity;
+    }
+    
+    public static void addOnActivityResultListener(OnActivityResultListener listener) {
+        onActivityResultListeners.add(listener);
+    }
+    
+    public static Set<OnActivityResultListener> getOnActivityResultListeners() {
+        return onActivityResultListeners;
+    }
+    
+    public static boolean isActivityVisible(){
+        return sActivityVisible;
+    }
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+
+    // ===========================================================
+    // Methods for/from SuperClass/Interfaces
+    // ===========================================================
+
+    // ===========================================================
+    // Methods
+    // ===========================================================
+
+    private static native void nativeSetApkPath(final String pApkPath);
+
+    private static native void nativeSetEditTextDialogResult(final byte[] pBytes);
+
+    private static native void nativeSetContext(final Context pContext, final AssetManager pAssetManager);
+
+    private static native void nativeSetAudioDeviceInfo(boolean isSupportLowLatency, int deviceSampleRate, int audioBufferSizeInFames);
+
+    public static String getPackageName() {
+        return Cocos2dxHelper.sPackageName;
+    }
+    public static String getWritablePath() {
+        return Cocos2dxHelper.sFileDirectory;
+    }
+
+    public static String getCurrentLanguage() {
+        return Locale.getDefault().getLanguage();
+    }
+
+    public static String getCurrentLanguageCode() {
+        return Locale.getDefault().toString();
+    }
+
+    public static String getDeviceModel(){
+        return Build.MODEL;
+    }
+
+    public static AssetManager getAssetManager() {
+        return Cocos2dxHelper.sAssetManager;
+    }
+
+    public static void enableAccelerometer() {
+        Cocos2dxHelper.sAccelerometerEnabled = true;
+        Cocos2dxHelper.sCocos2dxAccelerometer.enable();
+    }
+
+    public static void setAccelerometerInterval(float interval) {
+        Cocos2dxHelper.sCocos2dxAccelerometer.setInterval(interval);
+    }
+
+    public static void disableAccelerometer() {
+        Cocos2dxHelper.sAccelerometerEnabled = false;
+        Cocos2dxHelper.sCocos2dxAccelerometer.disable();
+    }
+
+    public static void setKeepScreenOn(boolean value) {
+        ((Cocos2dxActivity)sActivity).setKeepScreenOn(value);
+    }
+
+    public static void vibrate(float duration) {
+        try {
+            if (sVibrateService != null && sVibrateService.hasVibrator()) {
+                if (android.os.Build.VERSION.SDK_INT >= 26) {
+                    Class<?> vibrationEffectClass = Class.forName("android.os.VibrationEffect");
+                    if(vibrationEffectClass != null) {
+                        final int DEFAULT_AMPLITUDE = Cocos2dxReflectionHelper.<Integer>getConstantValue(vibrationEffectClass,
+                                "DEFAULT_AMPLITUDE");
+                        //VibrationEffect.createOneShot(long milliseconds, int amplitude)
+                        final Method method = vibrationEffectClass.getMethod("createOneShot",
+                                new Class[]{Long.TYPE, Integer.TYPE});
+                        Class<?> type = method.getReturnType();
+
+                        Object effect =  method.invoke(vibrationEffectClass,
+                                new Object[]{(long) (duration * 1000), DEFAULT_AMPLITUDE});
+                        //sVibrateService.vibrate(VibrationEffect effect);
+                        Cocos2dxReflectionHelper.invokeInstanceMethod(sVibrateService,"vibrate",
+                                new Class[]{type}, new Object[]{(effect)});
+                    }
+                } else {
+                    sVibrateService.vibrate((long) (duration * 1000));
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+ 	public static String getVersion() {
+ 		try {
+ 			String version = Cocos2dxActivity.getContext().getPackageManager().getPackageInfo(Cocos2dxActivity.getContext().getPackageName(), 0).versionName;
+ 			return version;
+ 		} catch(Exception e) {
+ 			return "";
+ 		}
+ 	}
+
+    public static boolean openURL(String url) { 
+        boolean ret = false;
+        try {
+            Intent i = new Intent(Intent.ACTION_VIEW);
+            i.setData(Uri.parse(url));
+            sActivity.startActivity(i);
+            ret = true;
+        } catch (Exception e) {
+        }
+        return ret;
+    }
+
+    // 复制文本到剪切板
+    public static void copyTextToClipboard(final String text){
+        sActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                ClipboardManager myClipboard = (ClipboardManager)sActivity.getSystemService(Context.CLIPBOARD_SERVICE);
+                ClipData myClip = ClipData.newPlainText("text", text);
+                myClipboard.setPrimaryClip(myClip);
+            }
+        });
+    }
+    
+    public static long[] getObbAssetFileDescriptor(final String path) {
+        long[] array = new long[3];
+        if (Cocos2dxHelper.sOBBFile != null) {
+            AssetFileDescriptor descriptor = Cocos2dxHelper.sOBBFile.getAssetFileDescriptor(path);
+            if (descriptor != null) {
+                try {
+                    ParcelFileDescriptor parcel = descriptor.getParcelFileDescriptor();
+                    Method method = parcel.getClass().getMethod("getFd", new Class[] {});
+                    array[0] = (Integer)method.invoke(parcel);
+                    array[1] = descriptor.getStartOffset();
+                    array[2] = descriptor.getLength();
+                } catch (NoSuchMethodException e) {
+                    Log.e(Cocos2dxHelper.TAG, "Accessing file descriptor directly from the OBB is only supported from Android 3.1 (API level 12) and above.");
+                } catch (IllegalAccessException e) {
+                    Log.e(Cocos2dxHelper.TAG, e.toString());
+                } catch (InvocationTargetException e) {
+                    Log.e(Cocos2dxHelper.TAG, e.toString());
+                }
+            }
+        }
+        return array;
+    }
+
+    public static void endApplication() {
+        if (sActivity != null)
+            sActivity.finish();
+    }
+
+    public static void onResume() {
+        sActivityVisible = true;
+        if (Cocos2dxHelper.sAccelerometerEnabled) {
+            Cocos2dxHelper.sCocos2dxAccelerometer.enable();
+        }
+    }
+
+    public static void onPause() {
+        sActivityVisible = false;
+        if (Cocos2dxHelper.sAccelerometerEnabled) {
+            Cocos2dxHelper.sCocos2dxAccelerometer.disable();
+        }
+    }
+
+    public static void onEnterBackground() {
+
+    }
+    
+    public static void onEnterForeground() {
+
+    }
+    
+    public static void terminateProcess() {
+        android.os.Process.killProcess(android.os.Process.myPid());
+    }
+
+    private static void showDialog(final String pTitle, final String pMessage) {
+        Cocos2dxHelper.sCocos2dxHelperListener.showDialog(pTitle, pMessage);
+    }
+
+    public static void setEditTextDialogResult(final String pResult) {
+        try {
+            final byte[] bytesUTF8 = pResult.getBytes("UTF8");
+
+            Cocos2dxHelper.sCocos2dxHelperListener.runOnGLThread(new Runnable() {
+                @Override
+                public void run() {
+                    Cocos2dxHelper.nativeSetEditTextDialogResult(bytesUTF8);
+                }
+            });
+        } catch (UnsupportedEncodingException pUnsupportedEncodingException) {
+            /* Nothing. */
+        }
+    }
+
+    private static int displayMetricsToDPI(DisplayMetrics metrics)
+    {
+        if(metrics.xdpi != metrics.ydpi) {
+            Log.w(Cocos2dxHelper.TAG, "xdpi != ydpi, use (xdpi + ydpi)/2 instead.");
+            return (int) ((metrics.xdpi + metrics.ydpi) / 2.0);
+        } else {
+            return (int)metrics.xdpi;
+        }
+    }
+
+    public static int getDPI()
+    {
+        if (sActivity != null)
+        {
+            DisplayMetrics metrics = new DisplayMetrics();
+            WindowManager wm = sActivity.getWindowManager();
+            if (wm != null)
+            {
+                Display d = wm.getDefaultDisplay();
+                if (d != null)
+                {
+                    try {
+                        Method getRealMetrics = d.getClass().getMethod("getRealMetrics", metrics.getClass());
+                        getRealMetrics.invoke(d, metrics);
+                        return displayMetricsToDPI(metrics);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                    d.getMetrics(metrics);
+                    return displayMetricsToDPI(metrics);
+                }
+            }
+        }
+        return -1;
+    }
+
+    public static byte[] conversionEncoding(byte[] text, String fromCharset,String newCharset)
+    {
+        try {
+            String str = new String(text,fromCharset);
+            return str.getBytes(newCharset);
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    private static void setGameInfoDebugViewText(int index, String text) {
+        if (sOnGameInfoUpdatedListener != null) {
+            if (index == 0) {
+                sOnGameInfoUpdatedListener.onGameInfoUpdated_0(text);
+            }
+            else if (index == 1) {
+                sOnGameInfoUpdatedListener.onGameInfoUpdated_1(text);
+            }
+            else if (index == 2) {
+                sOnGameInfoUpdatedListener.onGameInfoUpdated_2(text);
+            }
+        }
+    }
+
+    private static void setJSBInvocationCount(int count) {
+        if (sOnGameInfoUpdatedListener != null) {
+            sOnGameInfoUpdatedListener.onJSBInvocationCountUpdated(count);
+        }
+    }
+
+    private static void openDebugView() {
+        if (sOnGameInfoUpdatedListener != null) {
+            sOnGameInfoUpdatedListener.onOpenDebugView();
+        }
+    }
+
+    private static void disableBatchGLCommandsToNative() {
+        if (sOnGameInfoUpdatedListener != null) {
+            sOnGameInfoUpdatedListener.onDisableBatchGLCommandsToNative();
+        }
+    }
+
+    public interface OnGameInfoUpdatedListener {
+        void onFPSUpdated(float fps);
+        void onJSBInvocationCountUpdated(int count);
+        void onOpenDebugView();
+        void onDisableBatchGLCommandsToNative();
+        void onGameInfoUpdated_0(String text);
+        void onGameInfoUpdated_1(String text);
+        void onGameInfoUpdated_2(String text);
+    }
+
+    private static OnGameInfoUpdatedListener sOnGameInfoUpdatedListener;
+
+    public static void setOnGameInfoUpdatedListener(OnGameInfoUpdatedListener listener) {
+        sOnGameInfoUpdatedListener = listener;
+    }
+
+    public static OnGameInfoUpdatedListener getOnGameInfoUpdatedListener() {
+        return sOnGameInfoUpdatedListener;
+    }
+
+    // ===========================================================
+    // Inner and Anonymous Classes
+    // ===========================================================
+
+    public static interface Cocos2dxHelperListener {
+        public void showDialog(final String pTitle, final String pMessage);
+
+        public void runOnGLThread(final Runnable pRunnable);
+    }
+
+    private static float[] sDeviceMotionValues = new float[9];
+
+    private static float[] getDeviceMotionValue() {
+        Cocos2dxAccelerometer.DeviceMotionEvent event = Cocos2dxHelper.sCocos2dxAccelerometer.getDeviceMotionEvent();
+        sDeviceMotionValues[0] = event.acceleration.x;
+        sDeviceMotionValues[1] = event.acceleration.y;
+        // Issue https://github.com/cocos-creator/2d-tasks/issues/2532
+        // use negative event.acceleration.z to match iOS value
+        sDeviceMotionValues[2] = - event.acceleration.z;
+
+        sDeviceMotionValues[3] = event.accelerationIncludingGravity.x;
+        sDeviceMotionValues[4] = event.accelerationIncludingGravity.y;
+        sDeviceMotionValues[5] = event.accelerationIncludingGravity.z;
+
+        sDeviceMotionValues[6] = event.rotationRate.alpha;
+        sDeviceMotionValues[7] = event.rotationRate.beta;
+        sDeviceMotionValues[8] = event.rotationRate.gamma;
+
+        return sDeviceMotionValues;
+    }
+
+    public static int getSDKVersion() {
+        return Build.VERSION.SDK_INT;
+    }
+
+    public static String getSystemVersion() {
+        return Build.VERSION.RELEASE;
+    }
+
+
+    public static int getDeviceRotation() {
+        try {
+            Display display = ((WindowManager) sActivity.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
+            return display.getRotation();
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+        return Surface.ROTATION_0;
+    }
+
+    public static float[] getSafeArea() {
+
+        if (android.os.Build.VERSION.SDK_INT >= 28) {
+
+            do {
+                Object windowInsectObj = getActivity().getWindow().getDecorView().getRootWindowInsets();
+
+                if(windowInsectObj == null) break;
+
+                Class<?> windowInsets = WindowInsets.class;
+                try {
+                    Method wiGetDisplayCutout = windowInsets.getMethod("getDisplayCutout");
+                    Object cutout = wiGetDisplayCutout.invoke(windowInsectObj);
+
+                    if(cutout == null) break;
+
+                    Class<?> displayCutout = cutout.getClass();
+                    Method dcGetLeft = displayCutout.getMethod("getSafeInsetLeft");
+                    Method dcGetRight = displayCutout.getMethod("getSafeInsetRight");
+                    Method dcGetBottom = displayCutout.getMethod("getSafeInsetBottom");
+                    Method dcGetTop = displayCutout.getMethod("getSafeInsetTop");
+
+                    if (dcGetLeft != null && dcGetRight != null && dcGetBottom != null && dcGetTop != null) {
+                        int left = (Integer) dcGetLeft.invoke(cutout);
+                        int right = (Integer) dcGetRight.invoke(cutout);
+                        int top = (Integer) dcGetTop.invoke(cutout);
+                        int bottom = (Integer) dcGetBottom.invoke(cutout);
+                        return new float[]{top, left, bottom, right};
+                    }
+                } catch (NoSuchMethodException e) {
+                    e.printStackTrace();
+                } catch (IllegalAccessException e) {
+                    e.printStackTrace();
+                } catch (InvocationTargetException e) {
+                    e.printStackTrace();
+                }
+            }while(false);
+        }
+        return new float[]{0,0,0,0};
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxHttpURLConnection.java

@@ -0,0 +1,413 @@
+/****************************************************************************
+Copyright (c) 2010-2014 cocos2d-x.org
+Copyright (c) 2014-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.util.Log;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.InflaterInputStream;
+
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManagerFactory;
+
+public class Cocos2dxHttpURLConnection
+{
+    private static String TAG = "Cocos2dxHttpURLConnection";
+    private static final String POST_METHOD = "POST" ;
+    private static final String PUT_METHOD = "PUT" ;
+
+    static HttpURLConnection createHttpURLConnection(String linkURL) {
+        URL url;
+        HttpURLConnection urlConnection;
+        try {
+            url = new URL(linkURL);
+            urlConnection = (HttpURLConnection) url.openConnection();
+            //Accept-Encoding
+            urlConnection.setRequestProperty("Accept-Encoding", "identity");
+            urlConnection.setDoInput(true);
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "createHttpURLConnection:" + e.toString());
+            return null;
+        }
+
+        return urlConnection;
+    }
+
+    static void setReadAndConnectTimeout(HttpURLConnection urlConnection, int readMiliseconds, int connectMiliseconds) {
+        urlConnection.setReadTimeout(readMiliseconds);
+        urlConnection.setConnectTimeout(connectMiliseconds);
+    }
+
+    static void setRequestMethod(HttpURLConnection urlConnection, String method){
+        try {
+            urlConnection.setRequestMethod(method);
+            if(method.equalsIgnoreCase(POST_METHOD) || method.equalsIgnoreCase(PUT_METHOD)) {
+                urlConnection.setDoOutput(true);
+            }
+        } catch (ProtocolException e) {
+            Log.e(TAG, "setRequestMethod:" + e.toString());
+        }
+
+    }
+
+    static void setVerifySSL(HttpURLConnection urlConnection, String sslFilename) {
+        if(!(urlConnection instanceof HttpsURLConnection))
+            return;
+
+
+        HttpsURLConnection httpsURLConnection = (HttpsURLConnection)urlConnection;
+
+        try {
+            InputStream caInput = null;
+            if (sslFilename.startsWith("/")) {
+                caInput = new BufferedInputStream(new FileInputStream(sslFilename));
+            }else {
+                String assetString = "assets/";
+                String assetsfilenameString = sslFilename.substring(assetString.length());
+                caInput = new BufferedInputStream(Cocos2dxHelper.getActivity().getAssets().open(assetsfilenameString));
+            }
+
+            CertificateFactory cf = CertificateFactory.getInstance("X.509");
+            Certificate ca;
+            ca = cf.generateCertificate(caInput);
+            System.out.println("ca=" + ((X509Certificate) ca).getSubjectDN());
+            caInput.close();
+
+            // Create a KeyStore containing our trusted CAs
+            String keyStoreType = KeyStore.getDefaultType();
+            KeyStore keyStore = KeyStore.getInstance(keyStoreType);
+            keyStore.load(null, null);
+            keyStore.setCertificateEntry("ca", ca);
+
+            // Create a TrustManager that trusts the CAs in our KeyStore
+            String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+            TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
+            tmf.init(keyStore);
+
+            // Create an SSLContext that uses our TrustManager
+            SSLContext context = SSLContext.getInstance("TLS");
+            context.init(null, tmf.getTrustManagers(), null);
+
+            httpsURLConnection.setSSLSocketFactory(context.getSocketFactory());
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "setVerifySSL:" + e.toString());
+        }
+    }
+
+    //Add header
+    static void addRequestHeader(HttpURLConnection urlConnection, String key, String value) {
+        urlConnection.setRequestProperty(key, value);
+    }
+
+    static int connect(HttpURLConnection http) {
+        int suc = 0;
+
+        try {
+            http.connect();
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "connect" + e.toString());
+            suc = 1;
+        }
+
+        return suc;
+    }
+
+    static void disconnect(HttpURLConnection http) {
+        http.disconnect();
+    }
+
+    static void sendRequest(HttpURLConnection http, byte[] byteArray) {
+        try {
+            OutputStream out = http.getOutputStream();
+            if(null !=  byteArray) {
+                out.write(byteArray);
+                out.flush();
+            }
+            out.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "sendRequest:" + e.toString());
+        }
+    }
+
+    static String getResponseHeaders(HttpURLConnection http) {
+        Map<String, List<String>> headers = http.getHeaderFields();
+        if (null == headers) {
+            return null;
+        }
+
+        String header = "";
+
+        for (Entry<String, List<String>> entry: headers.entrySet()) {
+            String key = entry.getKey();
+            if (null == key) {
+                header += listToString(entry.getValue(), ",") + "\n";
+            } else {
+                header += key + ":" + listToString(entry.getValue(), ",") + "\n";
+            }
+        }
+
+        return header;
+    }
+
+    static String getResponseHeaderByIdx(HttpURLConnection http, int idx) {
+        Map<String, List<String>> headers = http.getHeaderFields();
+        if (null == headers) {
+            return null;
+        }
+
+        String header = null;
+
+        int counter = 0;
+        for (Entry<String, List<String>> entry: headers.entrySet()) {
+            if (counter == idx) {
+                String key = entry.getKey();
+                if (null == key) {
+                    header = listToString(entry.getValue(), ",") + "\n";
+                } else {
+                    header = key + ":" + listToString(entry.getValue(), ",") + "\n";
+                }
+                break;
+            }
+            counter++;
+        }
+
+        return header;
+    }
+
+    static String getResponseHeaderByKey(HttpURLConnection http, String key) {
+        if (null == key) {
+            return null;
+        }
+
+        Map<String, List<String>> headers = http.getHeaderFields();
+        if (null == headers) {
+            return null;
+        }
+
+        String header = null;
+
+        for (Entry<String, List<String>> entry: headers.entrySet()) {
+            if (key.equalsIgnoreCase(entry.getKey())) {
+                if ("set-cookie".equalsIgnoreCase(key)) {
+                    header = combinCookies(entry.getValue(), http.getURL().getHost());
+                } else {
+                    header = listToString(entry.getValue(), ",");
+                }
+                break;
+            }
+        }
+
+        return header;
+    }
+
+    static int getResponseHeaderByKeyInt(HttpURLConnection http, String key) {
+        String value = http.getHeaderField(key);
+
+        if (null == value) {
+            return 0;
+        } else {
+            return Integer.parseInt(value);
+        }
+    }
+
+    static byte[] getResponseContent(HttpURLConnection http) {
+        InputStream in;
+        try {
+            in = http.getInputStream();
+            String contentEncoding = http.getContentEncoding();
+            if (contentEncoding != null) {
+                if(contentEncoding.equalsIgnoreCase("gzip")){
+                    in = new GZIPInputStream(http.getInputStream()); //reads 2 bytes to determine GZIP stream!
+                }
+                else if(contentEncoding.equalsIgnoreCase("deflate")){
+                    in = new InflaterInputStream(http.getInputStream());
+                }
+            }
+        } catch (IOException e) {
+            in = http.getErrorStream();
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "1 getResponseContent: " + e.toString());
+            return null;
+        }
+
+        try {
+            byte[] buffer = new byte[1024];
+            int size   = 0;
+            ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
+            while((size = in.read(buffer, 0 , 1024)) != -1)
+            {
+                bytestream.write(buffer, 0, size);
+            }
+            byte retbuffer[] = bytestream.toByteArray();
+            bytestream.close();
+            return retbuffer;
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "2 getResponseContent:" + e.toString());
+        }
+
+        return null;
+    }
+
+    static int getResponseCode(HttpURLConnection http) {
+        int code = 0;
+        try {
+            code = http.getResponseCode();
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(TAG, "getResponseCode:" + e.toString());
+        }
+        return code;
+    }
+
+    static String getResponseMessage(HttpURLConnection http) {
+        String msg;
+        try {
+            msg = http.getResponseMessage();
+        } catch (Exception e) {
+            e.printStackTrace();
+            msg = e.toString();
+            Log.e(TAG, "getResponseMessage: " + msg);
+        }
+
+        return msg;
+    }
+
+    public static String listToString(List<String> list, String strInterVal) {
+        if (list == null) {
+            return null;
+        }
+        StringBuilder result = new StringBuilder();
+        boolean flag = false;
+        for (String str : list) {
+            if (flag) {
+                result.append(strInterVal);
+            }
+            if (null == str) {
+                str = "";
+            }
+            result.append(str);
+            flag = true;
+        }
+        return result.toString();
+    }
+
+    public static String combinCookies(List<String> list, String hostDomain) {
+        StringBuilder sbCookies = new StringBuilder();
+        String domain    = hostDomain;
+        String tailmatch = "FALSE";
+        String path      = "/";
+        String secure    = "FALSE";
+        String key = null;
+        String value = null;
+        String expires = null;
+        for (String str : list) {
+            String[] parts = str.split(";");
+            for (String part : parts) {
+                int firstIndex = part.indexOf("=");
+                if (-1 == firstIndex)
+                    continue;
+
+                String[] item =  {part.substring(0, firstIndex), part.substring(firstIndex + 1)};
+                if ("expires".equalsIgnoreCase(item[0].trim())) {
+                    expires = str2Seconds(item[1].trim());
+                } else if("path".equalsIgnoreCase(item[0].trim())) {
+                    path = item[1];
+                } else if("secure".equalsIgnoreCase(item[0].trim())) {
+                    secure = item[1];
+                } else if("domain".equalsIgnoreCase(item[0].trim())) {
+                    domain = item[1];
+                } else if("version".equalsIgnoreCase(item[0].trim()) || "max-age".equalsIgnoreCase(item[0].trim())) {
+                    //do nothing
+                } else {
+                    key = item[0];
+                    value = item[1];
+                }
+            }
+
+            if (null == domain) {
+                domain = "none";
+            }
+
+            sbCookies.append(domain);
+            sbCookies.append('\t');
+            sbCookies.append(tailmatch);  //access
+            sbCookies.append('\t');
+            sbCookies.append(path);      //path
+            sbCookies.append('\t');
+            sbCookies.append(secure);    //secure
+            sbCookies.append('\t');
+            sbCookies.append(expires);   //expires
+            sbCookies.append("\t");
+            sbCookies.append(key);       //key
+            sbCookies.append("\t");
+            sbCookies.append(value);     //value
+            sbCookies.append('\n');
+        }
+
+        return sbCookies.toString();
+    }
+
+    private static String str2Seconds(String strTime) {
+        Calendar c = Calendar.getInstance();
+        long milliseconds = 0;
+
+        try {
+            c.setTime(new SimpleDateFormat("EEE, dd-MMM-yy hh:mm:ss zzz", Locale.US).parse(strTime));
+            milliseconds = c.getTimeInMillis() / 1000;
+        } catch (ParseException e) {
+            Log.e(TAG, "str2Seconds: " + e.toString());
+        }
+
+        return Long.toString(milliseconds);
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxJavascriptJavaBridge.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2013-2016 Chukong Technologies Inc.
+ * Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package org.cocos2dx.lib;
+
+public class Cocos2dxJavascriptJavaBridge {
+    public static native int evalString(String value);
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxLocalStorage.java

@@ -0,0 +1,174 @@
+/****************************************************************************
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+public class Cocos2dxLocalStorage {
+
+    private static final String TAG = "Cocos2dxLocalStorage";
+
+    private static String DATABASE_NAME = "jsb.sqlite";
+    private static String TABLE_NAME = "data";
+    private static final int DATABASE_VERSION = 1;
+
+    private static DBOpenHelper mDatabaseOpenHelper = null;
+    private static SQLiteDatabase mDatabase = null;
+    /**
+     * Constructor
+     * @param context The Context within which to work, used to create the DB
+     * @return 
+     */
+    public static boolean init(String dbName, String tableName) {
+        if (Cocos2dxActivity.getContext() != null) {
+            DATABASE_NAME = dbName;
+            TABLE_NAME = tableName;
+            mDatabaseOpenHelper = new DBOpenHelper(Cocos2dxActivity.getContext());
+            mDatabase = mDatabaseOpenHelper.getWritableDatabase();
+            return true;
+        }
+        return false;
+    }
+    
+    public static void destroy() {
+        if (mDatabase != null) {
+            mDatabase.close();
+        }
+    }
+
+    public static void setItem(String key, String value) {
+        try {
+            String sql = "replace into "+TABLE_NAME+"(key,value)values(?,?)";
+            mDatabase.execSQL(sql, new Object[] { key, value });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String getItem(String key) {
+        String ret = null;
+        try {
+            String sql = "select value from "+TABLE_NAME+" where key=?";
+            Cursor c = mDatabase.rawQuery(sql, new String[]{key});
+            while (c.moveToNext()) {
+                // only return the first value
+                if (ret != null)
+                {
+                    Log.e(TAG, "The key contains more than one value.");
+                    break;
+                }
+                ret = c.getString(c.getColumnIndex("value"));
+            }
+            c.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return ret;
+    }
+
+    public static void removeItem(String key) {
+        try {
+            String sql = "delete from "+TABLE_NAME+" where key=?";
+            mDatabase.execSQL(sql, new Object[] {key});
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void clear() {
+        try {
+            String sql = "delete from "+TABLE_NAME;
+            mDatabase.execSQL(sql);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String getKey(int nIndex) {
+        String ret = null;
+        try {
+            int nCount = 0;
+            String sql = "select key from "+TABLE_NAME + " order by rowid asc";
+            Cursor c = mDatabase.rawQuery(sql, null);
+            if(nIndex < 0 || nIndex >= c.getCount()) {
+                return null;
+            }
+
+            while (c.moveToNext()) {
+                if(nCount == nIndex) {
+                    ret = c.getString(c.getColumnIndex("key"));
+                    break;
+                }
+                nCount++;
+            }
+            c.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return ret;
+    }
+
+    public  static int getLength() {
+        int res = 0;
+        try {
+            String sql = "select count(*) as nums from "+TABLE_NAME;
+            Cursor c = mDatabase.rawQuery(sql, null);
+            if (c.moveToNext()){
+                res = c.getInt(c.getColumnIndex("nums"));
+            }
+            c.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return res;
+    }
+
+    /**
+     * This creates/opens the database.
+     */
+    private static class DBOpenHelper extends SQLiteOpenHelper {
+
+        DBOpenHelper(Context context) {
+            super(context, DATABASE_NAME, null, DATABASE_VERSION);
+        }
+
+        @Override
+        public void onCreate(SQLiteDatabase db) {
+            db.execSQL("CREATE TABLE IF NOT EXISTS "+TABLE_NAME+"(key TEXT PRIMARY KEY,value TEXT);");
+        }
+
+        @Override
+        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+            Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
+                    + newVersion + ", which will destroy all old data");
+            //db.execSQL("DROP TABLE IF EXISTS " + VIRTUAL_TABLE);
+            //onCreate(db);
+        }
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxOrientationHelper.java

@@ -0,0 +1,33 @@
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.view.OrientationEventListener;
+
+public class Cocos2dxOrientationHelper extends OrientationEventListener {
+
+    private int currentOrientation;
+
+    public Cocos2dxOrientationHelper(Context context) {
+        super(context);
+        currentOrientation = Cocos2dxHelper.getDeviceRotation();
+    }
+
+    public void onPause() {
+        this.disable();
+    }
+
+    public void onResume() {
+        this.enable();
+    }
+
+    @Override
+    public void onOrientationChanged(int orientation) {
+        int curOrientation = Cocos2dxHelper.getDeviceRotation();
+        if (curOrientation != currentOrientation) {
+            currentOrientation = Cocos2dxHelper.getDeviceRotation();
+            nativeOnOrientationChanged(currentOrientation);
+        }
+    }
+
+    public static native void nativeOnOrientationChanged(int rotation);
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxReflectionHelper.java

@@ -0,0 +1,134 @@
+/****************************************************************************
+Copyright (c) 2016 cocos2d-x.org
+Copyright (c) 2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.util.Log;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+public class Cocos2dxReflectionHelper {
+    public static <T> T getConstantValue(final Class aClass, final String constantName) {
+        try {
+            return (T)aClass.getDeclaredField(constantName).get(null);
+        } catch (NoSuchFieldException e) {
+            Log.e("error", "can not find " + constantName + " in " + aClass.getName());
+        }
+        catch (IllegalAccessException e) {
+            Log.e("error", constantName + " is not accessable");
+        }
+        catch (IllegalArgumentException e) {
+            Log.e("error", "arguments error when get " + constantName);
+        }
+        catch (Exception e) {
+            Log.e("error", "can not get constant" + constantName);
+        }
+
+        return null;
+    }
+
+    public static <T> T invokeInstanceMethod(final Object instance, final String methodName,
+                                             final Class[] parameterTypes, final Object[] parameters) {
+
+        final Class aClass = instance.getClass();
+        try {
+            final Method method = aClass.getMethod(methodName, parameterTypes);
+            return (T)method.invoke(instance, parameters);
+        } catch (NoSuchMethodException e) {
+            Log.e("error", "can not find " + methodName + " in " + aClass.getName());
+        }
+        catch (IllegalAccessException e) {
+            Log.e("error", methodName + " is not accessible");
+        }
+        catch (IllegalArgumentException e) {
+            Log.e("error", "arguments are error when invoking " + methodName);
+        }
+        catch (InvocationTargetException e) {
+            Log.e("error", "an exception was thrown by the invoked method when invoking " + methodName);
+        }
+
+        return null;
+    }
+
+    public static <T> T invokeInterfaceMethod(final Class clazz, final String methodName,
+                                             final Class[] parameterTypes, final Object[] parameters) {
+
+        try {
+            final Method method = clazz.getMethod(methodName, parameterTypes);
+            return (T)method.invoke(null, parameters);
+        } catch (NoSuchMethodException e) {
+            Log.e("error", "can not find " + methodName + " in " + clazz.getName());
+        }
+        catch (IllegalAccessException e) {
+            Log.e("error", methodName + " is not accessible");
+        }
+        catch (IllegalArgumentException e) {
+            Log.e("error", "arguments are error when invoking " + methodName);
+        }
+        catch (InvocationTargetException e) {
+            Log.e("error", "an exception was thrown by the invoked method when invoking " + methodName);
+        }
+
+        return null;
+    }
+
+    public static Object createInstanceInterface(final String className, final String interfaceName) {
+        try {
+            final Class clazz = Class.forName(className + "$" + interfaceName);
+            return Proxy.newProxyInstance(clazz.getClassLoader(),
+                    new Class<?>[]{clazz}, new InvocationHandler() {
+                        @Override
+                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                            return null;
+                        }
+                    });
+        } catch (ClassNotFoundException ex) {
+            Log.e("error", "can not find " + className + "." + interfaceName);
+        }
+
+        return null;
+    }
+
+    public static Class getClassByName(final String className) {
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException ex) {
+            Log.e("error", "can not find " + className);
+        }
+        return null;
+    }
+
+    public static Class getInterfaceByName(final String className, final String interfaceName) {
+        try {
+            return Class.forName(className + "$" + interfaceName);
+        } catch (ClassNotFoundException ex) {
+            Log.e("error", "can not find " + className + "." + interfaceName);
+        }
+        return null;
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxRenderer.java

@@ -0,0 +1,270 @@
+/****************************************************************************
+Copyright (c) 2010-2011 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.opengl.GLSurfaceView;
+
+import java.lang.ref.WeakReference;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+public class Cocos2dxRenderer implements GLSurfaceView.Renderer {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+    private final static String TAG = "Cocos2dxRenderer";
+
+    private final static long NANOSECONDSPERSECOND = 1000000000L;
+    private final static long NANOSECONDSPERMICROSECOND = 1000000;
+
+    private static final long INTERVAL_60_FPS = (long) (1.0 / 60 * Cocos2dxRenderer.NANOSECONDSPERSECOND);
+    private static long sAnimationInterval = INTERVAL_60_FPS;
+    private static WeakReference<Cocos2dxRenderer> sRenderer;
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+
+    private long mLastTickInNanoSeconds;
+    private int mScreenWidth;
+    private int mScreenHeight;
+    private boolean mNativeInitCompleted = false;
+    private boolean mNeedShowFPS = false;
+    private String mDefaultResourcePath = "";
+    private long mOldNanoTime = 0;
+    private long mFrameCount = 0;
+    private boolean mNeedToPause = false;
+
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+
+    public static void setPreferredFramesPerSecond(int fps) {
+        Cocos2dxRenderer.sAnimationInterval = (long) (1.0 / fps * Cocos2dxRenderer.NANOSECONDSPERSECOND);
+    }
+
+    public void setScreenWidthAndHeight(final int surfaceWidth, final int surfaceHeight) {
+        this.mScreenWidth = surfaceWidth;
+        this.mScreenHeight = surfaceHeight;
+    }
+
+    public void setDefaultResourcePath(String path) {
+        if (path == null)
+            return;
+        mDefaultResourcePath = path;
+    }
+
+    public void showFPS() {
+        mNeedShowFPS = true;
+    }
+
+    public interface OnGameEngineInitializedListener {
+        void onGameEngineInitialized();
+    }
+
+    private OnGameEngineInitializedListener mGameEngineInitializedListener;
+
+    public void setOnGameEngineInitializedListener(OnGameEngineInitializedListener listener) {
+        mGameEngineInitializedListener = listener;
+    }
+
+    // ===========================================================
+    // Methods for/from SuperClass/Interfaces
+    // ===========================================================
+
+    @Override
+    public void onSurfaceCreated(final GL10 GL10, final EGLConfig EGLConfig) {
+        mNativeInitCompleted = false;
+        Cocos2dxRenderer.nativeInit(this.mScreenWidth, this.mScreenHeight, mDefaultResourcePath);
+        mOldNanoTime = System.nanoTime();
+        this.mLastTickInNanoSeconds = System.nanoTime();
+        mNativeInitCompleted = true;
+        if (mGameEngineInitializedListener != null) {
+            Cocos2dxHelper.getActivity().runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    mGameEngineInitializedListener.onGameEngineInitialized();
+                }
+            });
+        }
+    }
+
+    @Override
+    public void onSurfaceChanged(final GL10 GL10, final int width, final int height) {
+        Cocos2dxRenderer.nativeOnSurfaceChanged(width, height);
+    }
+
+    @Override
+    public void onDrawFrame(final GL10 gl) {
+        if (mNeedToPause)
+            return;
+
+        if (mNeedShowFPS) {
+            /////////////////////////////////////////////////////////////////////
+            //IDEA: show FPS in Android Text control rather than outputing log.
+            ++mFrameCount;
+            long nowFpsTime = System.nanoTime();
+            long fpsTimeInterval = nowFpsTime - mOldNanoTime;
+            if (fpsTimeInterval > 1000000000L) {
+                double frameRate = 1000000000.0 * mFrameCount / fpsTimeInterval;
+                Cocos2dxHelper.OnGameInfoUpdatedListener listener = Cocos2dxHelper.getOnGameInfoUpdatedListener();
+                if (listener != null) {
+                    listener.onFPSUpdated((float) frameRate);
+                }
+                mFrameCount = 0;
+                mOldNanoTime = System.nanoTime();
+            }
+            /////////////////////////////////////////////////////////////////////
+        }
+        /*
+         * No need to use algorithm in default(60 FPS) situation,
+         * since onDrawFrame() was called by system 60 times per second by default.
+         */
+        if (sAnimationInterval <= INTERVAL_60_FPS) {
+            Cocos2dxRenderer.nativeRender();
+        } else {
+            final long now = System.nanoTime();
+            final long interval = now - this.mLastTickInNanoSeconds;
+
+            if (interval < Cocos2dxRenderer.sAnimationInterval) {
+                try {
+                    Thread.sleep((Cocos2dxRenderer.sAnimationInterval - interval) / Cocos2dxRenderer.NANOSECONDSPERMICROSECOND);
+                } catch (final Exception e) {
+                }
+            }
+            /*
+             * Render time MUST be counted in, or the FPS will slower than appointed.
+            */
+            this.mLastTickInNanoSeconds = System.nanoTime();
+            Cocos2dxRenderer.nativeRender();
+        }
+    }
+
+    // ===========================================================
+    // Methods
+    // ===========================================================
+
+    private static native void nativeTouchesBegin(final int id, final float x, final float y);
+    private static native void nativeTouchesEnd(final int id, final float x, final float y);
+    private static native void nativeTouchesMove(final int[] ids, final float[] xs, final float[] ys);
+    private static native void nativeTouchesCancel(final int[] ids, final float[] xs, final float[] ys);
+    private static native boolean nativeKeyEvent(final int keyCode,boolean isPressed);
+    private static native void nativeRender();
+    private static native void nativeInit(final int width, final int height, final String resourcePath);
+    private static native void nativeOnSurfaceChanged(final int width, final int height);
+    private static native void nativeOnPause();
+    private static native void nativeOnResume();
+
+    // This function will be invoked in main thread.
+    public void setPauseInMainThread(boolean value) {
+        mNeedToPause = value;
+    }
+
+    public void handleActionDown(final int id, final float x, final float y) {
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxRenderer.nativeTouchesBegin(id, x, y);
+    }
+
+    public void handleActionUp(final int id, final float x, final float y) {
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxRenderer.nativeTouchesEnd(id, x, y);
+    }
+
+    public void handleActionCancel(final int[] ids, final float[] xs, final float[] ys) {
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxRenderer.nativeTouchesCancel(ids, xs, ys);
+    }
+
+    public void handleActionMove(final int[] ids, final float[] xs, final float[] ys) {
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxRenderer.nativeTouchesMove(ids, xs, ys);
+    }
+
+    public void handleKeyDown(final int keyCode) {
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxRenderer.nativeKeyEvent(keyCode, true);
+    }
+
+    public void handleKeyUp(final int keyCode) {
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxRenderer.nativeKeyEvent(keyCode, false);
+    }
+
+    public void handleOnPause() {
+        /**
+         * onPause may be invoked before onSurfaceCreated,
+         * and engine will be initialized correctly after
+         * onSurfaceCreated is invoked. Can not invoke any
+         * native method before onSurfaceCreated is invoked
+         */
+        if (! mNativeInitCompleted)
+            return;
+
+        Cocos2dxHelper.onEnterBackground();
+        Cocos2dxRenderer.nativeOnPause();
+    }
+
+    public void handleOnResume() {
+        Cocos2dxHelper.onEnterForeground();
+        Cocos2dxRenderer.nativeOnResume();
+    }
+
+    private static native void nativeInsertText(final String text);
+    private static native void nativeDeleteBackward();
+    private static native String nativeGetContentText();
+
+    public void handleInsertText(final String text) {
+        Cocos2dxRenderer.nativeInsertText(text);
+    }
+
+    public void handleDeleteBackward() {
+        Cocos2dxRenderer.nativeDeleteBackward();
+    }
+
+    public String getContentText() {
+        return Cocos2dxRenderer.nativeGetContentText();
+    }
+
+    // ===========================================================
+    // Inner and Anonymous Classes
+    // ===========================================================
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxTypefaces.java

@@ -0,0 +1,81 @@
+/****************************************************************************
+Copyright (c) 2010-2012 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.graphics.Typeface;
+
+import java.util.HashMap;
+
+public class Cocos2dxTypefaces {
+    // ===========================================================
+    // Constants
+    // ===========================================================
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+
+    private static final HashMap<String, Typeface> sTypefaceCache = new HashMap<String, Typeface>();
+
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+
+    // ===========================================================
+    // Methods for/from SuperClass/Interfaces
+    // ===========================================================
+
+    // ===========================================================
+    // Methods
+    // ===========================================================
+
+    public static synchronized Typeface get(final Context context, final String assetName) {
+        if (!Cocos2dxTypefaces.sTypefaceCache.containsKey(assetName)) {
+            Typeface typeface = null;
+            if (assetName.startsWith("/"))
+            {
+                typeface = Typeface.createFromFile(assetName);
+            }
+            else
+            {
+                typeface = Typeface.createFromAsset(context.getAssets(), assetName);
+            }
+            Cocos2dxTypefaces.sTypefaceCache.put(assetName, typeface);
+        }
+
+        return Cocos2dxTypefaces.sTypefaceCache.get(assetName);
+    }
+
+    // ===========================================================
+    // Inner and Anonymous Classes
+    // ===========================================================
+
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxVideoHelper.java

@@ -0,0 +1,575 @@
+/****************************************************************************
+Copyright (c) 2014-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+
+package org.cocos2dx.lib;
+
+import android.graphics.Rect;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.util.SparseArray;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import org.cocos2dx.lib.Cocos2dxVideoView.OnVideoEventListener;
+
+import java.lang.ref.WeakReference;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.FutureTask;
+
+public class Cocos2dxVideoHelper {
+
+    private FrameLayout mLayout = null;
+    private Cocos2dxActivity mActivity = null;  
+    private static SparseArray<Cocos2dxVideoView> sVideoViews = null;
+    static VideoHandler mVideoHandler = null;
+    private static Handler sHandler = null;
+    
+    Cocos2dxVideoHelper(Cocos2dxActivity activity, FrameLayout layout)
+    {
+        mActivity = activity;
+        mLayout = layout;
+        
+        mVideoHandler = new VideoHandler(this);
+        sVideoViews = new SparseArray<Cocos2dxVideoView>();
+        sHandler = new Handler(Looper.myLooper());
+    }
+
+    private static int videoTag = 0;
+    private final static int VideoTaskCreate = 0;
+    private final static int VideoTaskRemove = 1;
+    private final static int VideoTaskSetSource = 2;
+    private final static int VideoTaskSetRect = 3;
+    private final static int VideoTaskStart = 4;
+    private final static int VideoTaskPause = 5;
+    private final static int VideoTaskResume = 6;
+    private final static int VideoTaskStop = 7;
+    private final static int VideoTaskSeek = 8;
+    private final static int VideoTaskSetVisible = 9;
+    private final static int VideoTaskRestart = 10;
+    private final static int VideoTaskKeepRatio = 11;
+    private final static int VideoTaskFullScreen = 12;
+    private final static int VideoTaskSetVolume = 13;
+
+    final static int KeyEventBack = 1000;
+
+    static class VideoHandler extends Handler{
+        WeakReference<Cocos2dxVideoHelper> mReference;
+
+        VideoHandler(Cocos2dxVideoHelper helper){
+            mReference = new WeakReference<Cocos2dxVideoHelper>(helper);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            Cocos2dxVideoHelper helper = mReference.get();
+            switch (msg.what) {
+            case VideoTaskCreate: {
+                helper._createVideoView(msg.arg1);
+                break;
+            }
+            case VideoTaskRemove: {
+                helper._removeVideoView(msg.arg1);
+                break;
+            }
+            case VideoTaskSetSource: {
+                helper._setVideoURL(msg.arg1, msg.arg2, (String)msg.obj);
+                break;
+            }
+            case VideoTaskStart: {
+                helper._startVideo(msg.arg1);
+                break;
+            }
+            case VideoTaskSetRect: {
+                Rect rect = (Rect)msg.obj;
+                helper._setVideoRect(msg.arg1, rect.left, rect.top, rect.right, rect.bottom);
+                break;
+            }
+            case VideoTaskFullScreen:{
+                if (msg.arg2 == 1) {
+                    helper._setFullScreenEnabled(msg.arg1, true);
+                } else {
+                    helper._setFullScreenEnabled(msg.arg1, false);
+                }
+                break;
+            }
+            case VideoTaskPause: {
+                helper._pauseVideo(msg.arg1);
+                break;
+            }
+
+            case VideoTaskStop: {
+                helper._stopVideo(msg.arg1);
+                break;
+            }
+            case VideoTaskSeek: {
+                helper._seekVideoTo(msg.arg1, msg.arg2);
+                break;
+            }
+            case VideoTaskSetVisible: {
+                if (msg.arg2 == 1) {
+                    helper._setVideoVisible(msg.arg1, true);
+                } else {
+                    helper._setVideoVisible(msg.arg1, false);
+                }
+                break;
+            }
+            case VideoTaskKeepRatio: {
+                if (msg.arg2 == 1) {
+                    helper._setVideoKeepRatio(msg.arg1, true);
+                } else {
+                    helper._setVideoKeepRatio(msg.arg1, false);
+                }
+                break;
+            }
+            case KeyEventBack: {
+                helper.onBackKeyEvent();
+                break;
+            }
+            case VideoTaskSetVolume: {
+                float volume = (float) msg.arg2 / 10;
+                helper._setVolume(msg.arg1, volume);
+                break;
+            }
+            default:
+                break;
+            }
+
+            super.handleMessage(msg);
+        }
+    }
+
+    private class VideoEventRunnable implements Runnable
+    {
+        private int mVideoTag;
+        private int mVideoEvent;
+
+        public VideoEventRunnable(int tag,int event) {
+            mVideoTag = tag;
+            mVideoEvent = event;
+        }
+        @Override
+        public void run() {
+            nativeExecuteVideoCallback(mVideoTag, mVideoEvent);
+        }
+
+    }
+
+    public static native void nativeExecuteVideoCallback(int index,int event);
+
+    OnVideoEventListener videoEventListener = new OnVideoEventListener() {
+
+        @Override
+        public void onVideoEvent(int tag,int event) {
+            mActivity.runOnGLThread(new VideoEventRunnable(tag, event));
+        }
+    };
+
+    public static int createVideoWidget() {
+        Message msg = new Message();
+        msg.what = VideoTaskCreate;
+        msg.arg1 = videoTag;
+        mVideoHandler.sendMessage(msg);
+        
+        return videoTag++;
+    }
+
+    private void _createVideoView(int index) {
+        Cocos2dxVideoView videoView = new Cocos2dxVideoView(mActivity,index);
+        sVideoViews.put(index, videoView);
+        FrameLayout.LayoutParams lParams = new FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.WRAP_CONTENT,
+                FrameLayout.LayoutParams.WRAP_CONTENT);
+        mLayout.addView(videoView, lParams);
+        videoView.setZOrderOnTop(true);
+        videoView.setVideoViewEventListener(videoEventListener);
+    }
+
+    public static void removeVideoWidget(int index){
+        Message msg = new Message();
+        msg.what = VideoTaskRemove;
+        msg.arg1 = index;
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _removeVideoView(int index) {
+        Cocos2dxVideoView view = sVideoViews.get(index);
+        if (view != null) {
+            view.stopPlayback();
+            sVideoViews.remove(index);
+            mLayout.removeView(view);
+        }
+    }
+
+    public static void setVideoUrl(int index, int videoSource, String videoUrl) {
+        Message msg = new Message();
+        msg.what = VideoTaskSetSource;
+        msg.arg1 = index;
+        msg.arg2 = videoSource;
+        msg.obj = videoUrl;
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _setVideoURL(int index, int videoSource, String videoUrl) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            switch (videoSource) {
+            case 0:
+                videoView.setVideoFileName(videoUrl);
+                break;
+            case 1:
+                videoView.setVideoURL(videoUrl);
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    public static void setVideoRect(int index, int left, int top, int maxWidth, int maxHeight) {
+        Message msg = new Message();
+        msg.what = VideoTaskSetRect;
+        msg.arg1 = index;
+        msg.obj = new Rect(left, top, maxWidth, maxHeight);
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _setVideoRect(int index, int left, int top, int maxWidth, int maxHeight) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.setVideoRect(left,top,maxWidth,maxHeight);
+        }
+    }
+
+    public static void setFullScreenEnabled(int index, boolean enabled) {
+        Message msg = new Message();
+        msg.what = VideoTaskFullScreen;
+        msg.arg1 = index;
+        if (enabled) {
+            msg.arg2 = 1;
+        } else {
+            msg.arg2 = 0;
+        }
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _setFullScreenEnabled(int index, boolean enabled) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.setFullScreenEnabled(enabled);
+        }
+    }
+
+    private void onBackKeyEvent() {
+        int viewCount = sVideoViews.size();
+        for (int i = 0; i < viewCount; i++) {
+            int key = sVideoViews.keyAt(i);
+            Cocos2dxVideoView videoView = sVideoViews.get(key);
+            if (videoView != null) {
+                videoView.setFullScreenEnabled(false);
+                mActivity.runOnGLThread(new VideoEventRunnable(key, KeyEventBack));
+            }
+        }
+    }
+
+    public static void startVideo(int index) {
+        Message msg = new Message();
+        msg.what = VideoTaskStart;
+        msg.arg1 = index;
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _startVideo(int index) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.start();
+        }
+    }
+
+    public static void pauseVideo(int index) {
+        Message msg = new Message();
+        msg.what = VideoTaskPause;
+        msg.arg1 = index;
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _pauseVideo(int index) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.pause();
+        }
+    }
+
+    public static void stopVideo(int index) {
+        Message msg = new Message();
+        msg.what = VideoTaskStop;
+        msg.arg1 = index;
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _stopVideo(int index) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.stop();
+        }
+    }
+
+    public static void seekVideoTo(int index,int msec) {
+        Message msg = new Message();
+        msg.what = VideoTaskSeek;
+        msg.arg1 = index;
+        msg.arg2 = msec;
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _seekVideoTo(int index,int msec) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.seekTo(msec);
+        }
+    }
+
+
+    public static <T> T callInMainThread(Callable<T> call) throws ExecutionException, InterruptedException {
+        FutureTask<T> task = new FutureTask<T>(call);
+        sHandler.post(task);
+        return task.get();
+    }
+
+    public static float getCurrentTime(final int index) {
+        Callable<Float> callable = new Callable<Float>() {
+            @Override
+            public Float call() throws Exception {
+                Cocos2dxVideoView video = sVideoViews.get(index);
+                float currentPosition = -1;
+                if (video != null) {
+                    currentPosition = video.getCurrentPosition() / 1000.0f;
+                }
+                return new Float(currentPosition);
+            }
+        };
+
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return -1;
+        } catch (InterruptedException e) {
+            return -1;
+        }
+    }
+
+    public  static  float getDuration(final int index) {
+        Callable<Float> callable = new Callable<Float>() {
+            @Override
+            public Float call() throws Exception {
+                Cocos2dxVideoView video = sVideoViews.get(index);
+                float duration = -1;
+                if (video != null) {
+                    duration = video.getDuration() / 1000.0f;
+                }
+                if (duration <= 0) {
+                    Log.w("Cocos2dxVideoHelper", "Video player's duration is not ready to get now!");
+                }
+                return new Float(duration);
+            }
+        };
+
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return -1;
+        } catch (InterruptedException e) {
+            return -1;
+        }
+    }
+
+    public static void setVideoVisible(int index, boolean visible) {
+        Message msg = new Message();
+        msg.what = VideoTaskSetVisible;
+        msg.arg1 = index;
+        if (visible) {
+            msg.arg2 = 1;
+        } else {
+            msg.arg2 = 0;
+        }
+        
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _setVideoVisible(int index, boolean visible) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            if (visible) {
+                videoView.fixSize();
+                videoView.setVisibility(View.VISIBLE);
+            } else {
+                videoView.setVisibility(View.INVISIBLE);
+            }
+        }
+    }
+
+    public static void setVideoKeepRatioEnabled(int index, boolean enable) {
+        Message msg = new Message();
+        msg.what = VideoTaskKeepRatio;
+        msg.arg1 = index;
+        if (enable) {
+            msg.arg2 = 1;
+        } else {
+            msg.arg2 = 0;
+        }
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private void _setVideoKeepRatio(int index, boolean enable) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.setKeepRatio(enable);
+        }
+    }
+
+    private void _setVolume(final int index, final float volume) {
+        Cocos2dxVideoView videoView = sVideoViews.get(index);
+        if (videoView != null) {
+            videoView.setVolume(volume);
+        }
+    }
+
+    public static void setVolume(final int index, final float volume) {
+        Message msg = new Message();
+        msg.what = VideoTaskSetVolume;
+        msg.arg1 = index;
+        msg.arg2 = (int) (volume * 10);
+        mVideoHandler.sendMessage(msg);
+    }
+
+    private byte[] getFrame(final int index) {
+        Callable<byte[]> callable = new Callable<byte[]>() {
+            @Override
+            public byte[] call() throws Exception {
+                Cocos2dxVideoView video = sVideoViews.get(index);
+                byte datas[] = null;
+                if (video != null) datas = video.getFrame();
+                if (datas == null) {
+                    Log.w("Cocos2dxVideoHelper", "Video player's frame is not ready to get now!");
+                }
+                return datas;
+            }
+        };
+
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            Log.w("ExecutionException", e.getMessage());
+            return null;
+        } catch (InterruptedException e) {
+            Log.w("InterruptedException", e.getMessage());
+            return null;
+        }
+    }
+
+    private float getFrameChannel(final int index) {
+        Callable<Float> callable = new Callable<Float>() {
+            @Override
+            public Float call() throws Exception {
+                Cocos2dxVideoView video = sVideoViews.get(index);
+                int channel = 0;
+                if (video != null) {
+                    channel = video.getFrameChannel();
+                }
+                if (channel == 0) {
+                    Log.w("Cocos2dxVideoHelper", "Video player's frame channel is unknown!");
+                }
+                return new Float((float)channel);
+            }
+        };
+
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return -1.0f;
+        } catch (InterruptedException e) {
+            return -1.0f;
+        }
+    }
+
+    private float getFrameWidth(final int index) {
+        Callable<Float> callable = new Callable<Float>() {
+            @Override
+            public Float call() {
+                Cocos2dxVideoView video = sVideoViews.get(index);
+                int width = 0;
+                if (video != null) {
+                    width = video.getFrameWidth();
+                }
+                if (width == 0) {
+                    Log.w("Cocos2dxVideoHelper", "Video player's frame width is not ready to get now!");
+                }
+                return new Float((float)width);
+            }
+        };
+
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return -1.0f;
+        } catch (InterruptedException e) {
+            return -1.0f;
+        }
+    }
+
+    private float getFrameHeight(final int index) {
+        Callable<Float> callable = new Callable<Float>() {
+            @Override
+            public Float call() {
+                Cocos2dxVideoView video = sVideoViews.get(index);
+                int height = 0;
+                if (video != null) {
+                    height = video.getFrameHeight();
+                }
+                if (height == 0) {
+                    Log.w("Cocos2dxVideoHelper", "Video player's frame height is not ready to get now!");
+                }
+                return new Float((float)height);
+            }
+        };
+
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return -1.0f;
+        } catch (InterruptedException e) {
+            return -1.0f;
+        }
+    }
+
+    private void setShowRawFrame(final int index, final boolean show) {
+        Cocos2dxVideoView video = sVideoViews.get(index);
+        if (video != null) {
+            video.setShowRawFrame(show);
+        }
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxVideoView.java

@@ -0,0 +1,717 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ * Copyright (c) 2014-2016 Chukong Technologies Inc.
+ * Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+ *
+ * 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 org.cocos2dx.lib;
+
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.Resources;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.widget.FrameLayout;
+import android.graphics.Bitmap;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.HashMap;
+import java.util.Map;
+import java.nio.ByteBuffer;
+
+public class Cocos2dxVideoView extends SurfaceView {
+
+    // ===========================================================
+    // Internal classes and interfaces.
+    // ===========================================================
+
+    public interface OnVideoEventListener
+    {
+        void onVideoEvent(int tag,int event);
+    }
+
+    private enum State{
+        IDLE,
+        ERROR,
+        INITIALIZED,
+        PREPARING,
+        PREPARED,
+        STARTED,
+        PAUSED,
+        STOPPED,
+        PLAYBACK_COMPLETED,
+    }
+
+    // ===========================================================
+    // Constants
+    // ===========================================================
+    private static final String AssetResourceRoot = "@assets/";
+
+    // ===========================================================
+    // Fields
+    // ===========================================================
+
+    private String TAG = "Cocos2dxVideoView";
+
+    private Uri         mVideoUri;
+    private int         mDuration;
+
+    private State mCurrentState = State.IDLE;
+
+    // All the stuff we need for playing and showing a video
+    private SurfaceHolder mSurfaceHolder = null;
+    private MediaPlayer mMediaPlayer = null;
+    private int         mVideoWidth = 0;
+    private int         mVideoHeight = 0;
+
+    private OnVideoEventListener mOnVideoEventListener;
+
+    // recording the seek position while preparing
+    private int         mSeekWhenPrepared = 0;
+
+    protected Cocos2dxActivity mCocos2dxActivity = null;
+
+    protected int mViewLeft = 0;
+    protected int mViewTop = 0;
+    protected int mViewWidth = 0;
+    protected int mViewHeight = 0;
+
+    protected int mVisibleLeft = 0;
+    protected int mVisibleTop = 0;
+    protected int mVisibleWidth = 0;
+    protected int mVisibleHeight = 0;
+
+    protected boolean mFullScreenEnabled = false;
+    protected int mFullScreenWidth = 0;
+    protected int mFullScreenHeight = 0;
+
+    private boolean mIsAssetRouse = false;
+    private String mVideoFilePath = null;
+
+    private int mViewTag = 0;
+    private boolean mKeepRatio = false;
+    private boolean mMetaUpdated = false;
+
+    private MediaMetadataRetriever mRetriever = null;
+    private ByteBuffer mFrameBuf = null;
+    private byte mPixels[] = null;
+    private Bitmap mFrame = null;
+    private Bitmap mCurFrame = null;
+    private boolean mShowRaw = true;
+    private Object mCopyListener = null;
+
+    private Surface mSurface = null;
+
+    private static final int PX_INVALID = 0;
+    private static final int PX_ALPHA = 1;
+    private static final int PX_ARGB_4444 = 2;
+    private static final int PX_ARGB_8888 = 3;
+    private static final int PX_HARDWARE = 4;
+    private static final int PX_RGBA_F16 = 5;
+    private static final int PX_RGB_565 = 6;
+
+    // MediaPlayer will be released when surface view is destroyed, so should record the position,
+    // and use it to play after MedialPlayer is created again.
+    private int mPositionBeforeRelease = 0;
+
+    // ===========================================================
+    // Constructors
+    // ===========================================================
+
+    public Cocos2dxVideoView(Cocos2dxActivity activity,int tag) {
+        super(activity);
+
+        mViewTag = tag;
+        mCocos2dxActivity = activity;
+        initVideoView();
+        setShowRawFrame(true); // Show mediaplayer window.
+    }
+
+    // ===========================================================
+    // Getter & Setter
+    // ===========================================================
+
+    public void setVideoRect(int left, int top, int maxWidth, int maxHeight) {
+        if (mViewLeft == left && mViewTop == top && mViewWidth == maxWidth && mViewHeight == maxHeight)
+            return;
+
+        mViewLeft = left;
+        mViewTop = top;
+        mViewWidth = maxWidth;
+        mViewHeight = maxHeight;
+
+        fixSize(mViewLeft, mViewTop, mViewWidth, mViewHeight);
+    }
+
+    public void setFullScreenEnabled(boolean enabled) {
+        if (mFullScreenEnabled != enabled) {
+            mFullScreenEnabled = enabled;
+            fixSize();
+        }
+    }
+
+    public void setVolume (float volume) {
+        if (mMediaPlayer != null) {
+            mMediaPlayer.setVolume(volume, volume);
+        }
+    }
+
+    public void setKeepRatio(boolean enabled) {
+        mKeepRatio = enabled;
+        fixSize();
+    }
+
+    public void setVideoURL(String url) {
+        mIsAssetRouse = false;
+        setVideoURI(Uri.parse(url), null);
+    }
+
+    public void setVideoFileName(String path) {
+        if (path.startsWith(AssetResourceRoot)) {
+            path = path.substring(AssetResourceRoot.length());
+        }
+
+        if (path.startsWith("/")) {
+            mIsAssetRouse = false;
+            setVideoURI(Uri.parse(path),null);
+        }
+        else {
+
+            mVideoFilePath = path;
+            mIsAssetRouse = true;
+            setVideoURI(Uri.parse(path), null);
+        }
+    }
+
+    public int getCurrentPosition() {
+        if (! (mCurrentState == State.ERROR |
+                mMediaPlayer == null) ) {
+            return mMediaPlayer.getCurrentPosition();
+        }
+
+        return -1;
+    }
+
+    public int getDuration() {
+        if (! (mCurrentState == State.IDLE ||
+                mCurrentState == State.ERROR ||
+                mCurrentState == State.INITIALIZED ||
+                mMediaPlayer == null) ) {
+            mDuration = mMediaPlayer.getDuration();
+        }
+
+        return mDuration;
+    }
+
+    /**
+     * Register a callback to be invoked when some video event triggered.
+     *
+     * @param l The callback that will be run
+     */
+    public void setVideoViewEventListener(OnVideoEventListener l)
+    {
+        mOnVideoEventListener = l;
+    }
+
+    // ===========================================================
+    // Overrides
+    // ===========================================================
+
+    @Override
+    public void setVisibility(int visibility) {
+        super.setVisibility(visibility);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        setMeasuredDimension(mVisibleWidth, mVisibleHeight);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_UP) {
+            this.sendEvent(EVENT_CLICKED);
+        }
+        return true;
+    }
+
+    // ===========================================================
+    // Public functions
+    // ===========================================================
+
+    public void stop() {
+        if (!(mCurrentState == State.IDLE || mCurrentState == State.INITIALIZED || mCurrentState == State.ERROR || mCurrentState == State.STOPPED)
+                && mMediaPlayer != null) {
+            mCurrentState = State.STOPPED;
+            mMediaPlayer.stop();
+            this.sendEvent(EVENT_STOPPED);
+
+            // after the video is stop, it shall prepare to be playable again
+            try {
+                mMediaPlayer.prepare();
+                this.showFirstFrame();
+            } catch (Exception ex) {}
+        }
+    }
+
+    public void stopPlayback() {
+        this.release();
+    }
+
+    public void start() {
+        if ((mCurrentState == State.PREPARED ||
+                mCurrentState == State.PAUSED ||
+                mCurrentState == State.PLAYBACK_COMPLETED) &&
+                mMediaPlayer != null) {
+
+            mCurrentState = State.STARTED;
+            mMediaPlayer.start();
+            this.sendEvent(EVENT_PLAYING);
+        }
+    }
+
+    public void pause() {
+        if ((mCurrentState == State.STARTED || mCurrentState == State.PLAYBACK_COMPLETED) &&
+                mMediaPlayer != null) {
+            mCurrentState = State.PAUSED;
+            mMediaPlayer.pause();
+            this.sendEvent(EVENT_PAUSED);
+        }
+    }
+
+    public void seekTo(int ms) {
+        if (mCurrentState == State.IDLE || mCurrentState == State.INITIALIZED ||
+                mCurrentState == State.STOPPED || mCurrentState == State.ERROR ||
+                mMediaPlayer == null) {
+            return;
+        }
+
+        mMediaPlayer.seekTo(ms);
+    }
+
+    public void fixSize() {
+        if (mFullScreenEnabled) {
+            mFullScreenWidth = mCocos2dxActivity.getGLSurfaceView().getWidth();
+            mFullScreenHeight = mCocos2dxActivity.getGLSurfaceView().getHeight();
+
+            fixSize(0, 0, mFullScreenWidth, mFullScreenHeight);
+        } else {
+            fixSize(mViewLeft, mViewTop, mViewWidth, mViewHeight);
+        }
+    }
+
+    public void fixSize(int left, int top, int width, int height) {
+        if (mVideoWidth == 0 || mVideoHeight == 0) {
+            mVisibleLeft = left;
+            mVisibleTop = top;
+            mVisibleWidth = width;
+            mVisibleHeight = height;
+        }
+        else if (width != 0 && height != 0) {
+            if (mKeepRatio && !mFullScreenEnabled) {
+                if ( mVideoWidth * height  > width * mVideoHeight ) {
+                    mVisibleWidth = width;
+                    mVisibleHeight = width * mVideoHeight / mVideoWidth;
+                } else if ( mVideoWidth * height  < width * mVideoHeight ) {
+                    mVisibleWidth = height * mVideoWidth / mVideoHeight;
+                    mVisibleHeight = height;
+                }
+                mVisibleLeft = left + (width - mVisibleWidth) / 2;
+                mVisibleTop = top + (height - mVisibleHeight) / 2;
+            } else {
+                mVisibleLeft = left;
+                mVisibleTop = top;
+                mVisibleWidth = width;
+                mVisibleHeight = height;
+            }
+        }
+        else {
+            mVisibleLeft = left;
+            mVisibleTop = top;
+            mVisibleWidth = mVideoWidth;
+            mVisibleHeight = mVideoHeight;
+        }
+
+        getHolder().setFixedSize(mVisibleWidth, mVisibleHeight);
+
+        FrameLayout.LayoutParams lParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT);
+        lParams.leftMargin = mVisibleLeft;
+        lParams.topMargin = mVisibleTop;
+        setLayoutParams(lParams);
+    }
+
+    public int resolveAdjustedSize(int desiredSize, int measureSpec) {
+        int result = desiredSize;
+        int specMode = MeasureSpec.getMode(measureSpec);
+        int specSize =  MeasureSpec.getSize(measureSpec);
+
+        switch (specMode) {
+            case MeasureSpec.UNSPECIFIED:
+                /* Parent says we can be as big as we want. Just don't be larger
+                 * than max size imposed on ourselves.
+                 */
+                result = desiredSize;
+                break;
+
+            case MeasureSpec.AT_MOST:
+                /* Parent says we can be as big as we want, up to specSize.
+                 * Don't be larger than specSize, and don't be larger than
+                 * the max size imposed on ourselves.
+                 */
+                result = Math.min(desiredSize, specSize);
+                break;
+
+            case MeasureSpec.EXACTLY:
+                // No choice. Do what we are told.
+                result = specSize;
+                break;
+        }
+
+        return result;
+    }
+
+    public byte[] getFrame() {
+        if(mRetriever == null) {
+            return null;
+        } else {
+            try {
+                if (Build.VERSION.SDK_INT < 24) {
+                    mFrame = mRetriever.getFrameAtTime(mMediaPlayer.getCurrentPosition() * 1000, MediaMetadataRetriever.OPTION_CLOSEST);
+                } else {
+                    if(mFrame == null) {
+                        Bitmap firstFrame = mRetriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST);
+                        mFrame = Bitmap.createBitmap(getWidth(), getHeight(), firstFrame.getConfig());
+                    }
+
+                    if (mCopyListener == null) {
+                        mCopyListener = Cocos2dxReflectionHelper.createInstanceInterface("android.view.PixelCopy", "OnPixelCopyFinishedListener");
+                    }
+
+                    final Class clazz = Cocos2dxReflectionHelper.getClassByName("android.view.PixelCopy");
+                    final Class intef = Cocos2dxReflectionHelper.getInterfaceByName("android.view.PixelCopy", "OnPixelCopyFinishedListener");
+                    final Class types[] =  {SurfaceView.class, Bitmap.class, intef, Handler.class};
+                    final Object params[] = {this, mFrame, mCopyListener, this.getHandler()};
+
+                    Cocos2dxReflectionHelper.invokeInterfaceMethod(clazz, "request", types, params);
+                }
+            } catch (Exception e) {
+                Log.e("Grab error", e.getStackTrace().toString());
+                return mPixels;
+            }
+
+            if(mFrame == null) {
+                return mPixels;
+            }
+
+            mCurFrame = mFrame;
+
+            if(mFrameBuf == null) {
+                mFrameBuf = ByteBuffer.allocate(mCurFrame.getByteCount());
+            }
+            mFrameBuf.position(0);
+            mCurFrame.copyPixelsToBuffer(mFrameBuf);
+            mPixels = mFrameBuf.array();
+
+            return mPixels;
+        }
+    }
+
+    public int getFrameChannel() throws NoSuchFieldException, IllegalAccessException {
+        if (mCurFrame == null) {
+            return 0;
+        } else {
+            Bitmap.Config cfg = mCurFrame.getConfig();
+            if(Build.VERSION.SDK_INT > 26) {
+                Field hardware = Bitmap.Config.class.getDeclaredField("HARDWARE");
+                Field rgba_f16 = Bitmap.Config.class.getDeclaredField("RGBA_F16");
+                if(hardware != null && cfg == hardware.get(null)) return PX_HARDWARE;
+                if(rgba_f16 != null && cfg == rgba_f16.get(null)) return PX_RGBA_F16;
+            }
+
+            switch (cfg) {
+                case ALPHA_8:
+                    return PX_ALPHA;
+                case ARGB_4444:
+                    return PX_ARGB_4444;
+                case ARGB_8888:
+                    return PX_ARGB_8888;
+                case RGB_565:
+                    return PX_RGB_565;
+                default:
+                    return PX_INVALID;
+            }
+        }
+    }
+
+    public int getFrameWidth() {
+        if (mCurFrame != null) {
+            return mCurFrame.getWidth();
+        } else {
+            return 0;
+        }
+    }
+
+    public int getFrameHeight() {
+        if(mCurFrame != null) {
+            return mCurFrame.getHeight();
+        } else {
+            return 0;
+        }
+    }
+
+    public void setShowRawFrame(boolean show) {
+        if(mShowRaw == show) { // Now show state == Before show state
+            return; // Do nothing
+        }
+        setTranslationY(0); // Show view
+        if(!show) {
+            setTranslationY(-1000); // Hide view
+        }
+        mShowRaw = show;
+    }
+
+    // ===========================================================
+    // Private functions
+    // ===========================================================
+
+    private void initVideoView() {
+        mVideoWidth = 0;
+        mVideoHeight = 0;
+        getHolder().addCallback(mSHCallback);
+        //Fix issue#11516:Can't play video on Android 2.3.x
+        getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
+        setFocusable(true);
+        setFocusableInTouchMode(true);
+        mCurrentState = State.IDLE;
+    }
+
+    /**
+     * @hide
+     */
+    private void setVideoURI(Uri uri, Map<String, String> headers) {
+        mVideoUri = uri;
+        mVideoWidth = 0;
+        mVideoHeight = 0;
+    }
+
+    private void openVideo() {
+        if (mSurfaceHolder == null) {
+            // not ready for playback just yet, will try again later
+            return;
+        }
+        if (mIsAssetRouse) {
+            if(mVideoFilePath == null)
+                return;
+        } else if(mVideoUri == null) {
+            return;
+        }
+
+        this.pausePlaybackService();
+
+        try {
+            mMediaPlayer = new MediaPlayer();
+            mMediaPlayer.setOnPreparedListener(mPreparedListener);
+            mMediaPlayer.setOnCompletionListener(mCompletionListener);
+            mMediaPlayer.setOnErrorListener(mErrorListener);
+            mMediaPlayer.setDisplay(mSurfaceHolder);
+            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
+            mMediaPlayer.setScreenOnWhilePlaying(true);
+
+            mRetriever = new MediaMetadataRetriever();
+            mFrameBuf = null;
+            mPixels = null;
+            mCurFrame = null;
+            mFrame = null;
+
+            if (mIsAssetRouse) {
+                AssetFileDescriptor afd = mCocos2dxActivity.getAssets().openFd(mVideoFilePath);
+                mMediaPlayer.setDataSource(afd.getFileDescriptor(),afd.getStartOffset(),afd.getLength());
+                mRetriever.setDataSource(afd.getFileDescriptor(),afd.getStartOffset(),afd.getLength());
+            } else {
+                mMediaPlayer.setDataSource(mVideoUri.toString());
+                if (mVideoUri.getHost().length() > 0) {
+                    mRetriever.setDataSource(mVideoUri.toString(), new HashMap<String, String>());
+                } else {
+                    mRetriever.setDataSource(mCocos2dxActivity.getContext(), mVideoUri);
+                }
+            }
+            mCurrentState = State.INITIALIZED;
+
+
+            // Use Prepare() instead of PrepareAsync to make things easy.
+            mMediaPlayer.prepare();
+            this.showFirstFrame();
+
+//            mMediaPlayer.prepareAsync();
+        } catch (IOException ex) {
+            Log.w(TAG, "Unable to open content: " + mVideoUri, ex);
+            mCurrentState = State.ERROR;
+            mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0);
+            return;
+        } catch (IllegalArgumentException ex) {
+            Log.w(TAG, "Unable to open content: " + mVideoUri, ex);
+            mCurrentState = State.ERROR;
+            mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0);
+            return;
+        }
+    }
+
+    MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {
+        public void onPrepared(MediaPlayer mp) {
+            mVideoWidth = mp.getVideoWidth();
+            mVideoHeight = mp.getVideoHeight();
+
+            if (mVideoWidth != 0 && mVideoHeight != 0) {
+                fixSize();
+            }
+
+            if(!mMetaUpdated) {
+                Cocos2dxVideoView.this.sendEvent(EVENT_META_LOADED);
+                Cocos2dxVideoView.this.sendEvent(EVENT_READY_TO_PLAY);
+                mMetaUpdated = true;
+            }
+
+            mCurrentState = State.PREPARED;
+        }
+    };
+
+    private MediaPlayer.OnCompletionListener mCompletionListener =
+        new MediaPlayer.OnCompletionListener() {
+        public void onCompletion(MediaPlayer mp) {
+            mCurrentState = State.PLAYBACK_COMPLETED;
+            Cocos2dxVideoView.this.sendEvent(EVENT_COMPLETED);
+        }
+    };
+
+
+    private static final int EVENT_PLAYING = 0;
+    private static final int EVENT_PAUSED = 1;
+    private static final int EVENT_STOPPED = 2;
+    private static final int EVENT_COMPLETED = 3;
+    private static final int EVENT_META_LOADED = 4;
+    private static final int EVENT_CLICKED = 5;
+    private static final int EVENT_READY_TO_PLAY = 6;
+
+    private MediaPlayer.OnErrorListener mErrorListener =
+        new MediaPlayer.OnErrorListener() {
+        public boolean onError(MediaPlayer mp, int framework_err, int impl_err) {
+            Log.d(TAG, "Error: " + framework_err + "," + impl_err);
+            mCurrentState = State.ERROR;
+
+            /* Otherwise, pop up an error dialog so the user knows that
+             * something bad has happened. Only try and pop up the dialog
+             * if we're attached to a window. When we're going away and no
+             * longer have a window, don't bother showing the user an error.
+             */
+            if (getWindowToken() != null) {
+                Resources r = mCocos2dxActivity.getResources();
+                int messageId;
+
+                if (framework_err == MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK) {
+                    // messageId = com.android.internal.R.string.VideoView_error_text_invalid_progressive_playback;
+                    messageId = r.getIdentifier("VideoView_error_text_invalid_progressive_playback", "string", "android");
+                } else {
+                    // messageId = com.android.internal.R.string.VideoView_error_text_unknown;
+                    messageId = r.getIdentifier("VideoView_error_text_unknown", "string", "android");
+                }
+
+                int titleId = r.getIdentifier("VideoView_error_title", "string", "android");
+                int buttonStringId = r.getIdentifier("VideoView_error_button", "string", "android");
+
+                new AlertDialog.Builder(mCocos2dxActivity)
+                        .setTitle(r.getString(titleId))
+                        .setMessage(messageId)
+                        .setPositiveButton(r.getString(buttonStringId),
+                                new DialogInterface.OnClickListener() {
+                                    public void onClick(DialogInterface dialog, int whichButton) {
+                                        /* If we get here, there is no onError listener, so
+                                         * at least inform them that the video is over.
+                                         */
+                                        Cocos2dxVideoView.this.sendEvent(EVENT_COMPLETED);
+                                    }
+                                })
+                        .setCancelable(false)
+                        .show();
+            }
+            return true;
+        }
+    };
+
+    SurfaceHolder.Callback mSHCallback = new SurfaceHolder.Callback()
+    {
+        public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+        }
+
+        public void surfaceCreated(SurfaceHolder holder) {
+            mSurfaceHolder = holder;
+            Cocos2dxVideoView.this.openVideo();
+
+            if (mPositionBeforeRelease > 0)
+                mMediaPlayer.seekTo(mPositionBeforeRelease);
+        }
+
+        public void surfaceDestroyed(SurfaceHolder holder) {
+            // after we return from this we can't use the surface any more
+            mSurfaceHolder = null;
+            mPositionBeforeRelease = getCurrentPosition();
+            Cocos2dxVideoView.this.release();
+        }
+    };
+
+    /*
+     * release the media player in any state
+     */
+    private void release() {
+        if (mMediaPlayer != null) {
+            mMediaPlayer.release();
+            mMediaPlayer = null;
+        }
+    }
+
+    private void showFirstFrame() {
+        mMediaPlayer.seekTo(1);
+    }
+
+    private void sendEvent(int event) {
+        if (this.mOnVideoEventListener != null) {
+            this.mOnVideoEventListener.onVideoEvent(this.mViewTag, event);
+        }
+    }
+
+    // Tell the music playback service to pause
+    // REFINE: these constants need to be published somewhere in the framework.
+    private void pausePlaybackService() {
+        Intent i = new Intent("com.android.music.musicservicecommand");
+        i.putExtra("command", "pause");
+        mCocos2dxActivity.sendBroadcast(i);
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxWebView.java

@@ -0,0 +1,174 @@
+/****************************************************************************
+ Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos.com
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+ worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+ not use Cocos Creator software for developing other software or tools that's
+ used for developing games. You are not granted to publish, distribute,
+ sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+package org.cocos2dx.lib;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.util.Log;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.FrameLayout;
+
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.util.concurrent.CountDownLatch;
+
+class ShouldStartLoadingWorker implements Runnable {
+    private CountDownLatch mLatch;
+    private boolean[] mResult;
+    private final int mViewTag;
+    private final String mUrlString;
+
+    ShouldStartLoadingWorker(CountDownLatch latch, boolean[] result, int viewTag, String urlString) {
+        this.mLatch = latch;
+        this.mResult = result;
+        this.mViewTag = viewTag;
+        this.mUrlString = urlString;
+    }
+
+    @Override
+    public void run() {
+        this.mResult[0] = Cocos2dxWebViewHelper._shouldStartLoading(mViewTag, mUrlString);
+        this.mLatch.countDown(); // notify that result is ready
+    }
+}
+
+public class Cocos2dxWebView extends WebView {
+    private static final String TAG = Cocos2dxWebViewHelper.class.getSimpleName();
+
+    private int mViewTag;
+    private String mJSScheme;
+
+    public Cocos2dxWebView(Context context) {
+        this(context, -1);
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    public Cocos2dxWebView(Context context, int viewTag) {
+        super(context);
+        this.mViewTag = viewTag;
+        this.mJSScheme = "";
+
+        this.setFocusable(true);
+        this.setFocusableInTouchMode(true);
+
+        this.getSettings().setSupportZoom(false);
+
+        this.getSettings().setDomStorageEnabled(true);
+        this.getSettings().setJavaScriptEnabled(true);
+
+        // `searchBoxJavaBridge_` has big security risk. http://jvn.jp/en/jp/JVN53768697
+        try {
+            Method method = this.getClass().getMethod("removeJavascriptInterface", new Class[]{String.class});
+            method.invoke(this, "searchBoxJavaBridge_");
+        } catch (Exception e) {
+            Log.d(TAG, "This API level do not support `removeJavascriptInterface`");
+        }
+
+        this.setWebViewClient(new Cocos2dxWebViewClient());
+        this.setWebChromeClient(new WebChromeClient());
+    }
+
+    public void setJavascriptInterfaceScheme(String scheme) {
+        this.mJSScheme = scheme != null ? scheme : "";
+    }
+
+    public void setScalesPageToFit(boolean scalesPageToFit) {
+        this.getSettings().setSupportZoom(scalesPageToFit);
+    }
+
+    class Cocos2dxWebViewClient extends WebViewClient {
+        @Override
+        public boolean shouldOverrideUrlLoading(WebView view, final String urlString) {
+            Cocos2dxActivity activity = (Cocos2dxActivity)getContext();
+
+            try {
+                URI uri = URI.create(urlString);
+                if (uri != null && uri.getScheme().equals(mJSScheme)) {
+                    activity.runOnGLThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            Cocos2dxWebViewHelper._onJsCallback(mViewTag, urlString);
+                        }
+                    });
+                    return true;
+                }
+            } catch (Exception e) {
+                Log.d(TAG, "Failed to create URI from url");
+            }
+
+            boolean[] result = new boolean[] { true };
+            CountDownLatch latch = new CountDownLatch(1);
+
+            // run worker on cocos thread
+            activity.runOnGLThread(new ShouldStartLoadingWorker(latch, result, mViewTag, urlString));
+
+            // wait for result from cocos thread
+            try {
+                latch.await();
+            } catch (InterruptedException ex) {
+                Log.d(TAG, "'shouldOverrideUrlLoading' failed");
+            }
+
+            return result[0];
+        }
+
+        @Override
+        public void onPageFinished(WebView view, final String url) {
+            super.onPageFinished(view, url);
+            Cocos2dxActivity activity = (Cocos2dxActivity)getContext();
+            activity.runOnGLThread(new Runnable() {
+                @Override
+                public void run() {
+                    Cocos2dxWebViewHelper._didFinishLoading(mViewTag, url);
+                }
+            });
+        }
+
+        @Override
+        public void onReceivedError(WebView view, int errorCode, String description, final String failingUrl) {
+            super.onReceivedError(view, errorCode, description, failingUrl);
+            Cocos2dxActivity activity = (Cocos2dxActivity)getContext();
+            activity.runOnGLThread(new Runnable() {
+                @Override
+                public void run() {
+                    Cocos2dxWebViewHelper._didFailLoading(mViewTag, failingUrl);
+                }
+            });
+        }
+    }
+
+    public void setWebViewRect(int left, int top, int maxWidth, int maxHeight) {
+        FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT);
+        layoutParams.leftMargin = left;
+        layoutParams.topMargin = top;
+        layoutParams.width = maxWidth;
+        layoutParams.height = maxHeight;
+        this.setLayoutParams(layoutParams);
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Cocos2dxWebViewHelper.java

@@ -0,0 +1,323 @@
+/****************************************************************************
+Copyright (c) 2010-2011 cocos2d-x.org
+Copyright (c) 2013-2016 Chukong Technologies Inc.
+Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.graphics.Color;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.SparseArray;
+import android.view.View;
+import android.webkit.WebView;
+import android.widget.FrameLayout;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.FutureTask;
+
+
+public class Cocos2dxWebViewHelper {
+    private static final String TAG = Cocos2dxWebViewHelper.class.getSimpleName();
+    private static Handler sHandler;
+    private static Cocos2dxActivity sCocos2dxActivity;
+    private static FrameLayout sLayout;
+
+    private static SparseArray<Cocos2dxWebView> webViews;
+    private static int viewTag = 0;
+
+    public Cocos2dxWebViewHelper(FrameLayout layout) {
+        Cocos2dxWebViewHelper.sLayout = layout;
+        Cocos2dxWebViewHelper.sHandler = new Handler(Looper.myLooper());
+
+        Cocos2dxWebViewHelper.sCocos2dxActivity = (Cocos2dxActivity) Cocos2dxActivity.getContext();
+        Cocos2dxWebViewHelper.webViews = new SparseArray<Cocos2dxWebView>();
+    }
+
+    private static native boolean shouldStartLoading(int index, String message);
+
+    public static boolean _shouldStartLoading(int index, String message) {
+        return !shouldStartLoading(index, message);
+    }
+
+    private static native void didFinishLoading(int index, String message);
+
+    public static void _didFinishLoading(int index, String message) {
+        didFinishLoading(index, message);
+    }
+
+    private static native void didFailLoading(int index, String message);
+
+    public static void _didFailLoading(int index, String message) {
+        didFailLoading(index, message);
+    }
+
+    private static native void onJsCallback(int index, String message);
+
+    public static void _onJsCallback(int index, String message) {
+        onJsCallback(index, message);
+    }
+
+    public static int createWebView() {
+        final int index = viewTag;
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = new Cocos2dxWebView(sCocos2dxActivity, index);
+                FrameLayout.LayoutParams lParams = new FrameLayout.LayoutParams(
+                        FrameLayout.LayoutParams.WRAP_CONTENT,
+                        FrameLayout.LayoutParams.WRAP_CONTENT);
+                sLayout.addView(webView, lParams);
+
+                webViews.put(index, webView);
+            }
+        });
+        return viewTag++;
+    }
+
+    public static void removeWebView(final int index) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webViews.remove(index);
+                    sLayout.removeView(webView);
+                    webView.destroy();
+                    webView = null;
+                }
+            }
+        });
+    }
+
+    public static void setVisible(final int index, final boolean visible) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.setVisibility(visible ? View.VISIBLE : View.GONE);
+                }
+            }
+        });
+    }
+
+    public static void setWebViewRect(final int index, final int left, final int top, final int maxWidth, final int maxHeight) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.setWebViewRect(left, top, maxWidth, maxHeight);
+                }
+            }
+        });
+    }
+
+    public static void setBackgroundTransparent(final int index, final boolean isTransparent) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.setBackgroundColor(isTransparent ? Color.TRANSPARENT : Color.WHITE);
+                    webView.setLayerType(WebView.LAYER_TYPE_SOFTWARE, null);
+                }
+            }
+        });
+    }
+
+    public static void setJavascriptInterfaceScheme(final int index, final String scheme) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.setJavascriptInterfaceScheme(scheme);
+                }
+            }
+        });
+    }
+
+    public static void loadData(final int index, final String data, final String mimeType, final String encoding, final String baseURL) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.loadDataWithBaseURL(baseURL, data, mimeType, encoding, null);
+                }
+            }
+        });
+    }
+
+    public static void loadHTMLString(final int index, final String data, final String baseUrl) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.loadDataWithBaseURL(baseUrl, data, null, null, null);
+                }
+            }
+        });
+    }
+
+    public static void loadUrl(final int index, final String url) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.loadUrl(url);
+                }
+            }
+        });
+    }
+
+    public static void loadFile(final int index, final String filePath) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.loadUrl(filePath);
+                }
+            }
+        });
+    }
+
+    public static void stopLoading(final int index) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.stopLoading();
+                }
+            }
+        });
+
+    }
+
+    public static void reload(final int index) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.reload();
+                }
+            }
+        });
+    }
+
+    public static <T> T callInMainThread(Callable<T> call) throws ExecutionException, InterruptedException {
+        FutureTask<T> task = new FutureTask<T>(call);
+        sHandler.post(task);
+        return task.get();
+    }
+
+    public static boolean canGoBack(final int index) {
+        Callable<Boolean> callable = new Callable<Boolean>() {
+            @Override
+            public Boolean call() throws Exception {
+                Cocos2dxWebView webView = webViews.get(index);
+                return webView != null && webView.canGoBack();
+            }
+        };
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return false;
+        } catch (InterruptedException e) {
+            return false;
+        }
+    }
+
+    public static boolean canGoForward(final int index) {
+        Callable<Boolean> callable = new Callable<Boolean>() {
+            @Override
+            public Boolean call() throws Exception {
+                Cocos2dxWebView webView = webViews.get(index);
+                return webView != null && webView.canGoForward();
+            }
+        };
+        try {
+            return callInMainThread(callable);
+        } catch (ExecutionException e) {
+            return false;
+        } catch (InterruptedException e) {
+            return false;
+        }
+    }
+
+    public static void goBack(final int index) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.goBack();
+                }
+            }
+        });
+    }
+
+    public static void goForward(final int index) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.goForward();
+                }
+            }
+        });
+    }
+
+    public static void evaluateJS(final int index, final String js) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.loadUrl("javascript:" + js);
+                }
+            }
+        });
+    }
+
+    public static void setScalesPageToFit(final int index, final boolean scalesPageToFit) {
+        sCocos2dxActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Cocos2dxWebView webView = webViews.get(index);
+                if (webView != null) {
+                    webView.setScalesPageToFit(scalesPageToFit);
+                }
+            }
+        });
+    }
+}

cocos2d-x/cocos/platform/android/java/src/org/cocos2dx/lib/Utils.java

@@ -0,0 +1,63 @@
+/****************************************************************************
+ Copyright (c) 2018 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib;
+
+import android.app.Activity;
+import android.os.Build;
+import android.view.View;
+
+public class Utils {
+    private static Activity sActivity = null;
+
+    public static void setActivity(final Activity activity) {
+        Utils.sActivity = activity;
+    }
+
+    public static void hideVirtualButton() {
+        if (Build.VERSION.SDK_INT >= 19 &&
+                null != Utils.sActivity) {
+            // use reflection to remove dependence of API level
+
+            Class viewClass = View.class;
+            final int SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION = Cocos2dxReflectionHelper.<Integer>getConstantValue(viewClass, "SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION");
+            final int SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN = Cocos2dxReflectionHelper.<Integer>getConstantValue(viewClass, "SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN");
+            final int SYSTEM_UI_FLAG_HIDE_NAVIGATION = Cocos2dxReflectionHelper.<Integer>getConstantValue(viewClass, "SYSTEM_UI_FLAG_HIDE_NAVIGATION");
+            final int SYSTEM_UI_FLAG_FULLSCREEN = Cocos2dxReflectionHelper.<Integer>getConstantValue(viewClass, "SYSTEM_UI_FLAG_FULLSCREEN");
+            final int SYSTEM_UI_FLAG_IMMERSIVE_STICKY = Cocos2dxReflectionHelper.<Integer>getConstantValue(viewClass, "SYSTEM_UI_FLAG_IMMERSIVE_STICKY");
+            final int SYSTEM_UI_FLAG_LAYOUT_STABLE = Cocos2dxReflectionHelper.<Integer>getConstantValue(viewClass, "SYSTEM_UI_FLAG_LAYOUT_STABLE");
+
+            // getWindow().getDecorView().setSystemUiVisibility();
+            final Object[] parameters = new Object[]{SYSTEM_UI_FLAG_LAYOUT_STABLE
+                    | SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                    | SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                    | SYSTEM_UI_FLAG_HIDE_NAVIGATION // hide nav bar
+                    | SYSTEM_UI_FLAG_FULLSCREEN // hide status bar
+                    | SYSTEM_UI_FLAG_IMMERSIVE_STICKY};
+            Cocos2dxReflectionHelper.<Void>invokeInstanceMethod(Utils.sActivity.getWindow().getDecorView(),
+                    "setSystemUiVisibility",
+                    new Class[]{Integer.TYPE},
+                    parameters);
+        }
+    }
+}