diff --git a/build.gradle b/build.gradle
index 59660130..5890fd0c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.3.3'
+        classpath 'com.android.tools.build:gradle:3.0.0-alpha6'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
diff --git a/cgeDemo/src/main/java/org/wysaid/cgeDemo/CameraDemoActivity.java b/cgeDemo/src/main/java/org/wysaid/cgeDemo/CameraDemoActivity.java
index 3acd7287..eb90485c 100755
--- a/cgeDemo/src/main/java/org/wysaid/cgeDemo/CameraDemoActivity.java
+++ b/cgeDemo/src/main/java/org/wysaid/cgeDemo/CameraDemoActivity.java
@@ -4,6 +4,7 @@
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.PointF;
 import android.hardware.Camera;
 import android.net.Uri;
 import android.os.Bundle;
@@ -18,12 +19,17 @@
 import android.widget.LinearLayout;
 import android.widget.SeekBar;
 
+import com.sensetime.stmobileapi.STMobileFaceAction;
+import com.sensetime.stmobileapi.STMobileMultiTrack106;
+import com.sensetime.stmobileapi.STUtils;
+
 import org.wysaid.camera.CameraInstance;
 import org.wysaid.myUtils.FileUtil;
 import org.wysaid.myUtils.ImageUtil;
 import org.wysaid.myUtils.MsgUtil;
 import org.wysaid.nativePort.CGEFrameRecorder;
 import org.wysaid.nativePort.CGENativeLibrary;
+import org.wysaid.stmobile.Accelerometer;
 import org.wysaid.view.CameraRecordGLSurfaceView;
 
 public class CameraDemoActivity extends AppCompatActivity {
@@ -338,12 +344,110 @@ public void onAutoFocus(boolean success, Camera camera) {
         });
 
         mCameraView.setPictureSize(600, 800, true);
+
+        Button faceDetectBtn = (Button) findViewById(R.id.face_detect_btn);
+        faceDetectBtn.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                CameraInstance.getInstance().getCameraDevice().setPreviewCallback(new Camera.PreviewCallback() {
+                    @Override
+                    public void onPreviewFrame(byte[] data, Camera camera) {
+                        if (mNV21Data == null) {
+                            mNV21Data = new byte[CameraInstance.getInstance().previewHeight() * CameraInstance.getInstance().previewWidth() * 2];
+                        }
+                        synchronized (mNV21Data) {
+                            System.arraycopy(data, 0, mNV21Data, 0, data.length);
+                            mIsNV21ready = true;
+                        }
+                    }
+                });
+                mCameraView.setFilterWithConfig("@facedetect");
+            }
+        });
+        mAcc = new Accelerometer(this);
+        mAcc.start();
+    }
+
+    private byte[] mNV21Data;
+    private boolean mIsFaceDetectThreadKilled = false;
+    private Thread mFaceDetectThread;
+    private boolean mIsNV21ready = false;
+    private Accelerometer mAcc;
+    private STMobileMultiTrack106 mTracker = null;
+    private static final int ST_MOBILE_TRACKING_ENABLE_FACE_ACTION = 0x00000020;
+    private byte[] tmp = null;
+
+    private void stopFaceDetectThread() {
+        mIsFaceDetectThreadKilled = true;
+        if (mFaceDetectThread != null) {
+            try {
+                mFaceDetectThread.join(1000);
+            } catch (InterruptedException e1) {
+                e1.printStackTrace();
+            }
+        }
+    }
+
+    private void startFaceDetectThread() {
+        mIsFaceDetectThreadKilled = false;
+
+        mFaceDetectThread = new Thread() {
+            @Override
+            public void run() {
+                while (!mIsFaceDetectThreadKilled) {
+                    if (!mIsNV21ready) {
+                        continue;
+                    }
+                    if (tmp == null) {
+                        tmp = new byte[CameraInstance.getInstance().previewHeight() * CameraInstance.getInstance().previewWidth() * 2];
+                    }
+                    synchronized (mNV21Data) {
+                        System.arraycopy(mNV21Data, 0, tmp, 0, mNV21Data.length);
+                        mIsNV21ready = false;
+                    }
+                    boolean frontCamera = (CameraInstance.getInstance().getFacing() == Camera.CameraInfo.CAMERA_FACING_FRONT);
+                    int dir = Accelerometer.getDirection();
+                    /**
+                     * 请注意前置摄像头与后置摄像头旋转定义不同
+                     * 请注意不同手机摄像头旋转定义不同
+                     */
+                    if (frontCamera &&
+                            ((CameraInstance.getInstance().getCameraInfo().orientation == 270 && (dir & 1) == 1) ||
+                                    (CameraInstance.getInstance().getCameraInfo().orientation == 90 && (dir & 1) == 0))) {
+                        dir = (dir ^ 2);
+                    }
+                    STMobileFaceAction[] faceActions = mTracker.trackFaceAction(tmp, dir, CameraInstance.getInstance().previewWidth(), CameraInstance.getInstance().previewHeight());
+                    boolean rotate270 = CameraInstance.getInstance().getCameraInfo().orientation == 270;
+                    Log.e("xuezi", "rotate270" + rotate270);
+                    if (faceActions != null && faceActions.length > 0) {
+                        STMobileFaceAction r = faceActions[0];
+                        PointF[] points = r.getFace().getPointsArray();
+                        float[] pointArray = new float[212];
+                        for (int i = 0; i < points.length; i++) {
+                            if (rotate270) {
+                                points[i] = STUtils.RotateDeg270(points[i], CameraInstance.getInstance().previewWidth(), CameraInstance.getInstance().previewHeight(), frontCamera);
+                            } else {
+                                points[i] = STUtils.RotateDeg90(points[i], CameraInstance.getInstance().previewWidth(), CameraInstance.getInstance().previewHeight(), frontCamera);
+                            }
+                            pointArray[2*i] = points[i].x / CameraInstance.getInstance().previewHeight();
+                            pointArray[2*i+1] = points[i].y / CameraInstance.getInstance().previewWidth();
+                        }
+                        mCameraView.setFaceDetectPoints(pointArray);
+                    }
+                    else {
+                        mCameraView.clearFaceDetectPoints();
+                    }
+                }
+            }
+        };
+        mFaceDetectThread.start();
     }
 
     private View.OnClickListener mFilterSwitchListener = new View.OnClickListener() {
         @Override
         public void onClick(View v) {
-            MyButtons btn = (MyButtons) v;
+            CameraInstance.getInstance().getCameraDevice().setPreviewCallback(null);
+            MyButtons btn = (MyButtons)v;
             mCameraView.setFilterWithConfig(btn.filterConfig);
             mCurrentConfig = btn.filterConfig;
         }
@@ -388,6 +492,13 @@ public void onPause() {
         Log.i(LOG_TAG, "activity onPause...");
         mCameraView.release(null);
         mCameraView.onPause();
+        mAcc.stop();
+        stopFaceDetectThread();
+        if (mTracker != null) {
+            System.out.println("destroy tracker");
+            mTracker.destory();
+            mTracker = null;
+        }
     }
 
     @Override
@@ -395,6 +506,18 @@ public void onResume() {
         super.onResume();
 
         mCameraView.onResume();
+        mAcc.start();
+        if (mTracker == null) {
+//            long start_init = System.currentTimeMillis();
+//			int config = 0; //default config
+            int config = ST_MOBILE_TRACKING_ENABLE_FACE_ACTION;
+            mTracker = new STMobileMultiTrack106(this, config);
+            int max = 1;
+            mTracker.setMaxDetectableFaces(max);
+//            long end_init = System.currentTimeMillis();
+//            Log.i("track106", "init cost "+(end_init - start_init) +" ms");
+        }
+        startFaceDetectThread();
     }
 
     @Override
diff --git a/cgeDemo/src/main/res/layout/activity_camera_demo.xml b/cgeDemo/src/main/res/layout/activity_camera_demo.xml
index 6122be06..44cd87f7 100755
--- a/cgeDemo/src/main/res/layout/activity_camera_demo.xml
+++ b/cgeDemo/src/main/res/layout/activity_camera_demo.xml
@@ -29,6 +29,7 @@
     </FrameLayout>
 
     <HorizontalScrollView
+        android:id="@+id/hsl"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_alignParentBottom="true">
@@ -123,4 +124,10 @@
         </LinearLayout>
     </HorizontalScrollView>
 
+    <Button
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="FaceDetect"
+        android:id="@+id/face_detect_btn"
+        android:layout_above="@id/hsl"/>
 </RelativeLayout>
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 819de7a9..f6243487 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Fri Jun 16 17:02:18 CST 2017
+#Fri Jul 14 16:02:35 CST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-milestone-1-all.zip
diff --git a/library/build.gradle b/library/build.gradle
index 6e946d7f..31e9149d 100644
--- a/library/build.gradle
+++ b/library/build.gradle
@@ -39,4 +39,5 @@ android {
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.android.support:appcompat-v7:25.2.0'
+    compile project(":stmobile")
 }
diff --git a/library/src/main/java/org/wysaid/camera/CameraInstance.java b/library/src/main/java/org/wysaid/camera/CameraInstance.java
index 8a84a340..eccc6ae7 100644
--- a/library/src/main/java/org/wysaid/camera/CameraInstance.java
+++ b/library/src/main/java/org/wysaid/camera/CameraInstance.java
@@ -28,6 +28,10 @@ public class CameraInstance {
 
     private Camera mCameraDevice;
     private Camera.Parameters mParams;
+    protected Camera.CameraInfo mCameraInfo = null;
+    public Camera.CameraInfo getCameraInfo() {
+        return mCameraInfo;
+    }
 
     public static final int DEFAULT_PREVIEW_RATE = 30;
 
@@ -96,6 +100,8 @@ public synchronized boolean tryOpenCamera(CameraOpenCallback callback, int facin
                     if (cameraInfo.facing == facing) {
                         mDefaultCameraID = i;
                         mFacing = facing;
+                        mCameraInfo = cameraInfo;
+                        break;
                     }
                 }
             }
@@ -305,6 +311,7 @@ public void initCamera(int previewRate) {
 
         Log.i(LOG_TAG, String.format("Camera Picture Size: %d x %d", szPic.width, szPic.height));
         Log.i(LOG_TAG, String.format("Camera Preview Size: %d x %d", szPrev.width, szPrev.height));
+
     }
 
     public synchronized void setFocusMode(String focusMode) {
diff --git a/library/src/main/java/org/wysaid/nativePort/CGEFrameRenderer.java b/library/src/main/java/org/wysaid/nativePort/CGEFrameRenderer.java
index 4cf66a67..4fa6b109 100644
--- a/library/src/main/java/org/wysaid/nativePort/CGEFrameRenderer.java
+++ b/library/src/main/java/org/wysaid/nativePort/CGEFrameRenderer.java
@@ -82,7 +82,7 @@ public void setRenderFlipScale(float x, float y) {
     //initialize the filters width config string
     public void setFilterWidthConfig(final String config) {
         if(mNativeAddress != 0)
-            nativeSetFilterWidthConfig(mNativeAddress, config);
+            nativeSetFilterWithConfig(mNativeAddress, config);
     }
 
     //set the mask rotation (radian)
@@ -95,7 +95,6 @@ public void setMaskRotation(float rot) {
     public void setMaskFlipScale(float x, float y) {
         if(mNativeAddress != 0)
             nativeSetMaskFlipScale(mNativeAddress, x, y);
-
     }
 
 
@@ -152,6 +151,14 @@ public void setNativeFilter(long nativeFilter) {
         nativeSetFilterWithAddr(mNativeAddress, nativeFilter);
     }
 
+    public void setFaceDetectPoints(float[] keyPoints) {
+        nativeSetFaceDetectPoints(mNativeAddress, keyPoints);
+    }
+
+    public void clearFaceDetectPoints() {
+        nativeClearFaceDetectPoints(mNativeAddress);
+    }
+
     /////////////////      protected         ///////////////////////
 
     protected native long nativeCreateRenderer();
@@ -166,7 +173,7 @@ public void setNativeFilter(long nativeFilter) {
     protected native void nativeSetSrcFlipScale(long holder, float x, float y);
     protected native void nativeSetRenderRotation(long holder, float rad);
     protected native void nativeSetRenderFlipScale(long holder, float x, float y);
-    protected native void nativeSetFilterWidthConfig(long holder, String config);
+    protected native void nativeSetFilterWithConfig(long holder, String config);
     protected native void nativeSetFilterIntensity(long holder, float value);
     protected native void nativeSetMaskRotation(long holder, float value);
     protected native void nativeSetMaskFlipScale(long holder, float x, float y);
@@ -188,4 +195,6 @@ public void setNativeFilter(long nativeFilter) {
 
     //特殊用法, 谨慎使用, 使用不当可能造成程序运行异常.
     protected native void nativeSetFilterWithAddr(long holder, long filter);
+    protected native void nativeSetFaceDetectPoints(long holder, float[] keyPoints);
+    protected native void nativeClearFaceDetectPoints(long holder);
 }
diff --git a/library/src/main/java/org/wysaid/stmobile/Accelerometer.java b/library/src/main/java/org/wysaid/stmobile/Accelerometer.java
new file mode 100644
index 00000000..b30741f8
--- /dev/null
+++ b/library/src/main/java/org/wysaid/stmobile/Accelerometer.java
@@ -0,0 +1,138 @@
+package org.wysaid.stmobile;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+
+/**
+ * 
+ * @author MatrixCV
+ *
+ * Accelerometer 用于开启重力传感器，以获得当前手机朝向
+ * 
+ */
+public class Accelerometer {
+	/**
+	 * 
+	 * @author MatrixCV
+	 *
+	 * CLOCKWISE_ANGLE为手机旋转角度
+	 * 其Deg0定义如下图所示
+	 *  ___________________
+	 * | +--------------+  |
+	 * | |              |  |
+	 * | |              |  |
+	 * | |              | O|
+	 * | |              |  |
+	 * | |______________|  |
+	 * ---------------------
+	 * 顺时针旋转后得到Deg90，即手机竖屏向上，如下图所示
+	 *  ___________
+	 * |           |
+	 * |+---------+|
+	 * ||         ||
+	 * ||         ||
+	 * ||         ||
+	 * ||         ||
+	 * ||         ||
+	 * |+---------+|
+	 * |_____O_____|
+	 */
+	public enum CLOCKWISE_ANGLE {
+		Deg0(0), Deg90(1), Deg180(2), Deg270(3); 
+		private int value;
+		private CLOCKWISE_ANGLE(int value){
+			this.value = value;
+		}
+		public int getValue() {
+			return value;
+		}
+	}
+
+	private SensorManager sensorManager = null;
+
+	private boolean hasStarted = false;
+	
+	private static CLOCKWISE_ANGLE rotation;
+
+	/**
+	 * 
+	 * @param ctx
+	 * 用Activity初始化获得传感器
+	 */
+	public Accelerometer(Context ctx) {
+		sensorManager = (SensorManager) ctx
+				.getSystemService(Context.SENSOR_SERVICE);
+		rotation = CLOCKWISE_ANGLE.Deg0;
+	}
+	
+	/**
+	 * 开始对传感器的监听
+	 */
+	public void start() {
+		if (hasStarted) return;
+		hasStarted = true;
+		rotation = CLOCKWISE_ANGLE.Deg0;
+		sensorManager.registerListener(accListener,
+				sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
+				SensorManager.SENSOR_DELAY_NORMAL);
+	}
+
+	/**
+	 * 结束对传感器的监听
+	 */
+	public void stop() {
+		if (!hasStarted) return;
+		hasStarted = false;
+		sensorManager.unregisterListener(accListener);
+	}
+
+	/**
+	 * 
+	 * @return
+	 * 返回当前手机转向
+	 */
+	static public int getDirection() {
+		return rotation.getValue();
+	}
+
+	/**
+	 * 传感器与手机转向之间的逻辑
+	 */
+	private SensorEventListener accListener = new SensorEventListener() {
+
+		@Override
+		public void onAccuracyChanged(Sensor arg0, int arg1) {
+		}
+
+		@Override
+		public void onSensorChanged(SensorEvent arg0) {
+			if (arg0.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+				float x = arg0.values[0];
+				float y = arg0.values[1];
+				float z = arg0.values[2];
+				if (Math.abs(x)>3 || Math.abs(y)>3) {
+					if (Math.abs(x)>Math.abs(y)) {
+						if (x > 0) {
+							rotation = CLOCKWISE_ANGLE.Deg0;
+							//Log.d("ROTATION","CLOCKWISE_ANGLE: Deg0");
+						} else {
+							rotation = CLOCKWISE_ANGLE.Deg180;
+							//Log.d("ROTATION","CLOCKWISE_ANGLE: Deg180");
+						}
+					} else {
+						if (y > 0) {
+							rotation = CLOCKWISE_ANGLE.Deg90;
+							//Log.d("ROTATION","CLOCKWISE_ANGLE: Deg90");
+						} else {
+							rotation = CLOCKWISE_ANGLE.Deg270;
+							//Log.d("ROTATION","CLOCKWISE_ANGLE: Deg270");
+						}
+					}
+				}
+			}
+		}
+	};
+}
diff --git a/library/src/main/java/org/wysaid/view/CameraGLSurfaceView.java b/library/src/main/java/org/wysaid/view/CameraGLSurfaceView.java
index 28a50d31..0ddd3c9f 100644
--- a/library/src/main/java/org/wysaid/view/CameraGLSurfaceView.java
+++ b/library/src/main/java/org/wysaid/view/CameraGLSurfaceView.java
@@ -228,6 +228,32 @@ public synchronized boolean setFlashLightMode(String mode) {
         return true;
     }
 
+    public synchronized void setFaceDetectPoints(final float[] keyPoints) {
+        queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                if(mFrameRecorder != null) {
+                    mFrameRecorder.setFaceDetectPoints(keyPoints);
+                } else {
+                    Log.e(LOG_TAG, "setFaceDetectPoints");
+                }
+            }
+        });
+    }
+
+    public synchronized void clearFaceDetectPoints() {
+        queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                if(mFrameRecorder != null) {
+                    mFrameRecorder.clearFaceDetectPoints();
+                } else {
+                    Log.e(LOG_TAG, "clearFaceDetectPoints");
+                }
+            }
+        });
+    }
+
     public synchronized void setFilterWithConfig(final String config) {
         queueEvent(new Runnable() {
             @Override
diff --git a/library/src/main/jni/Android.mk b/library/src/main/jni/Android.mk
index 4ba346d2..b9dfa4ef 100644
--- a/library/src/main/jni/Android.mk
+++ b/library/src/main/jni/Android.mk
@@ -84,6 +84,7 @@ LOCAL_SRC_FILES :=  \
 			$(CGE_SOURCE)/filters/cgeDynamicWaveFilter.cpp \
 			$(CGE_SOURCE)/filters/cgeMotionFlowFilter.cpp \
 			$(CGE_SOURCE)/filters/cgeColorMappingFilter.cpp \
+            $(CGE_SOURCE)/filters/cgeFaceDetectFilter.cpp \
 			$(CGE_SOURCE)/extends/cgeThread.cpp \
 			\
 			$(CGE_ROOT)/interface/cgeNativeLibrary.cpp \
diff --git a/library/src/main/jni/cge/common/cgeImageHandler.cpp b/library/src/main/jni/cge/common/cgeImageHandler.cpp
index 6b31c95c..fdbb80d4 100644
--- a/library/src/main/jni/cge/common/cgeImageHandler.cpp
+++ b/library/src/main/jni/cge/common/cgeImageHandler.cpp
@@ -787,4 +787,11 @@ namespace CGE
 		return true;
 	}
 
+	void CGEImageHandler::setFaceDetectKeyPoint(float *keyPoints) {
+        m_keyPoints = keyPoints;
+    }
+
+    float* CGEImageHandler::getFaceDetectKeyPoint() {
+        return m_keyPoints;
+    }
 }
diff --git a/library/src/main/jni/cge/filters/cgeDataParsingEngine.cpp b/library/src/main/jni/cge/filters/cgeDataParsingEngine.cpp
index a82f4686..af7e3ed8 100755
--- a/library/src/main/jni/cge/filters/cgeDataParsingEngine.cpp
+++ b/library/src/main/jni/cge/filters/cgeDataParsingEngine.cpp
@@ -13,11 +13,13 @@
 #include "cgeFilterBasic.h"
 #include "cgeDynamicFilters.h"
 #include "cgeColorMappingFilter.h"
+#include "cgeFaceDetectFilter.h"
 
 #include <cstring>
 #include <cctype>
 #include <sstream>
 
+
 //为了加快处理速度，使用固定大小的buffer来存储Parser所需参数。
 //每个method后面的参数长度都不应该超过BUFFER_LEN。
 //如果你的Parser所需参数超过此长度，请将BUFFER_LEN增加到合适的长度。
@@ -74,13 +76,13 @@ tableParserHelper(vec, pstr + n, i - n); \
 				CGE_LOG_ERROR("CGEDataParsingEngine::curveParser Create Curve filter Failed!\n");
 				return nullptr;
 			}
-		}		
+		}
 
 		for(int i = 0; pstr[i] != '\0' && pstr[i] != '@';)
 		{
 			switch (pstr[i])
 			{
-			case 'R': case 'r':				
+			case 'R': case 'r':
 				if(toupper(pstr[i + 1]) == 'G' && toupper(pstr[i + 2]) == 'B')
 				{
 					vecRGB.clear();
@@ -101,7 +103,7 @@ tableParserHelper(vec, pstr + n, i - n); \
 					vecR.clear();
 					++i;
 					int n = i;
-					for(char c = toupper(pstr[i]); 
+					for(char c = toupper(pstr[i]);
 						c != '\0' && c != 'R' && c != 'G' && c != 'B' && c != '@'; c = toupper(pstr[i])) ++i;
 						tableParserHelper(vecR, pstr + n, i - n);
 					if(vecR.size() < 2)
@@ -125,7 +127,7 @@ tableParserHelper(vec, pstr + n, i - n); \
 				else
 				{
 					proc->pushPointsG(vecG.data(), vecG.size());
-				}				
+				}
 				break;
 			case 'B': case 'b':
 				vecB.clear();
@@ -138,9 +140,9 @@ tableParserHelper(vec, pstr + n, i - n); \
 				else
 				{
 					proc->pushPointsB(vecB.data(), vecB.size());
-				}				
+				}
 				break;
-			default:				
+			default:
 				++i;
 				break;
 			}
@@ -161,7 +163,7 @@ tableParserHelper(vec, pstr + n, i - n); \
 	{
 		using namespace std;
 		using namespace CGE;
-		
+
 		float vignetteStart, vignetteEnd, colorScaleLow, colorScaleRange, saturation;
 		int isLinear = 0;
 		while(*pstr != '\0' && !isdigit(*pstr)) ++pstr;
@@ -205,7 +207,7 @@ tableParserHelper(vec, pstr + n, i - n); \
 				{
 					++i;
 					int n = i;
-					for(char c = toupper(pstr[i]); 
+					for(char c = toupper(pstr[i]);
 						c != '\0' && c != 'R' && c != 'G' && c != 'B' && c != '@'; c = toupper(pstr[i])) ++i;
 						tableParserHelper(vecR, pstr + n, i - n);
 				}
@@ -248,7 +250,7 @@ tableParserHelper(vec, pstr + n, i - n); \
 		float vignetteStart, vignetteEnd, colorScaleLow, colorScaleRange, saturation;
 		int isLinear = 0;
 		while(*pstr != '\0' && !isdigit(*pstr)) ++pstr;
-		if(sscanf(pstr, "%f%*c%f%*c%f%*c%f%*c%f%*c%d", 
+		if(sscanf(pstr, "%f%*c%f%*c%f%*c%f%*c%f%*c%d",
 			&vignetteStart, &vignetteEnd, &colorScaleLow, &colorScaleRange, &saturation, &isLinear) < 5)
 		{
 			return nullptr;
@@ -266,6 +268,16 @@ tableParserHelper(vec, pstr + n, i - n); \
 		return proc;
 	}
 
+	CGEImageFilterInterface* CGEDataParsingEngine::faceDetectParser(const char* pstr, CGEMutipleEffectFilter* fatherFilter)
+	{
+		CGEFaceDetectFilter* proc = new CGEFaceDetectFilter;
+		proc->init();
+
+		if(fatherFilter != nullptr)
+            fatherFilter->addFilter(proc);
+		return proc;
+	}
+
 #define ADJUSTHELP_COMMON_FUNC(str, procName, setFunc) \
 do{\
 	float intensity;\
diff --git a/library/src/main/jni/cge/filters/cgeFaceDetectFilter.cpp b/library/src/main/jni/cge/filters/cgeFaceDetectFilter.cpp
new file mode 100644
index 00000000..14618490
--- /dev/null
+++ b/library/src/main/jni/cge/filters/cgeFaceDetectFilter.cpp
@@ -0,0 +1,63 @@
+//
+// Created by Xue Weining on 2017/6/27.
+//
+#include "cgeFaceDetectFilter.h"
+static CGEConstString s_fshFaceDetect = CGE_SHADER_STRING_PRECISION_H
+(
+        varying vec2 textureCoordinate;
+        uniform sampler2D inputImageTexture;
+        uniform float points[212];
+        uniform bool isFaceDetect;
+
+        void main() {
+            gl_FragColor = texture2D(inputImageTexture, textureCoordinate);
+            if (isFaceDetect) {
+                for (int i = 0; i < 106; i++) {
+                    if (pow(abs(textureCoordinate.x - points[2*i]), 2.0f) +
+                        pow(abs(textureCoordinate.y - points[2*i+1]), 2.0f) < 0.00001f) {
+                        gl_FragColor = vec4(1.0f, 1.0f, 0.0f, 1.0f);
+                    }
+                }
+            }
+        }
+);
+
+namespace CGE
+{
+    bool CGEFaceDetectFilter::init()
+    {
+        if(initShadersFromString(g_vshDefaultWithoutTexCoord, s_fshFaceDetect))
+        {
+            return true;
+        }
+        return false;
+    }
+
+    void CGEFaceDetectFilter::render2Texture(CGEImageHandlerInterface* handler, GLuint srcTexture, GLuint vertexBufferID)
+    {
+        handler->setAsTarget();
+        m_program.bind();
+
+        glEnableVertexAttribArray(0);
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, srcTexture);
+        if(m_uniformParam != nullptr)
+            m_uniformParam->assignUniforms(handler, m_program.programID());
+
+        float* keyPoints = handler->getFaceDetectKeyPoint();
+        if (keyPoints != nullptr) {
+            GLint isFaceDetectUniform = glGetUniformLocation(m_program.programID(), "isFaceDetect");
+            glUniform1i(isFaceDetectUniform, GL_TRUE);
+            GLint pointsUniform = glGetUniformLocation(m_program.programID(), "points");
+            glUniform1fv(pointsUniform, 212, keyPoints);
+        }
+        else {
+            GLint isFaceDetectUniform = glGetUniformLocation(m_program.programID(), "isFaceDetect");
+            glUniform1i(isFaceDetectUniform, GL_FALSE);
+        }
+
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+        cgeCheckGLError("glDrawArrays");
+    }
+}
diff --git a/library/src/main/jni/cge/filters/cgeMultipleEffects.cpp b/library/src/main/jni/cge/filters/cgeMultipleEffects.cpp
index 229fbc03..5b2dbbf8 100644
--- a/library/src/main/jni/cge/filters/cgeMultipleEffects.cpp
+++ b/library/src/main/jni/cge/filters/cgeMultipleEffects.cpp
@@ -238,7 +238,10 @@ namespace CGE
 
 			*pBuffer = '\0';
 
-			if(strcmp(buffer, "blend") == 0)
+			if (strcmp(buffer, "facedetect") == 0) {
+            	CGEDataParsingEngine::faceDetectParser(ptr, this);
+            }
+            else if(strcmp(buffer, "blend") == 0)
 			{
 				CGEDataParsingEngine::blendParser(ptr, this);
 			}
diff --git a/library/src/main/jni/include/cgeImageHandler.h b/library/src/main/jni/include/cgeImageHandler.h
index 53715e57..5c521326 100644
--- a/library/src/main/jni/include/cgeImageHandler.h
+++ b/library/src/main/jni/include/cgeImageHandler.h
@@ -52,7 +52,8 @@ namespace CGE
 		void getOutputFBOSize(int &w, int &h) { w = m_dstImageSize.width; h = m_dstImageSize.height; }
 
         void copyTextureData(void* data, int w, int h, GLuint texID, GLenum dataFmt, GLenum channelFmt);
-
+        virtual void setFaceDetectKeyPoint(float* keyPoints) = 0;
+        virtual float* getFaceDetectKeyPoint() = 0;
 	protected:
 		virtual bool initImageFBO(const void* data, int w, int h, GLenum channelFmt, GLenum dataFmt, int channel);
 		virtual void clearImageFBO();
@@ -133,9 +134,10 @@ namespace CGE
 		void setResultDrawer(TextureDrawer* drawer);
 
         virtual void useImageFBO();
-
+        void setFaceDetectKeyPoint(float* keyPoints);
+        float* getFaceDetectKeyPoint();
 	protected:
-
+        float* m_keyPoints = nullptr;
 		bool m_bRevertEnabled;
 		std::vector<CGEImageFilterInterfaceAbstract*> m_vecFilters;
 
diff --git a/library/src/main/jni/include/filters/cgeDataParsingEngine.h b/library/src/main/jni/include/filters/cgeDataParsingEngine.h
index 8f811329..874c9be2 100644
--- a/library/src/main/jni/include/filters/cgeDataParsingEngine.h
+++ b/library/src/main/jni/include/filters/cgeDataParsingEngine.h
@@ -33,7 +33,7 @@ namespace CGE
 		static CGEImageFilterInterface* beautifyParser(const char* pstr, CGEMutipleEffectFilter* fatherFilter = nullptr);
 		static CGEImageFilterInterface* blurParser(const char* pstr, CGEMutipleEffectFilter* fatherFilter = nullptr);
 		static CGEImageFilterInterface* dynamicParser(const char* pstr, CGEMutipleEffectFilter* fatherFilter = nullptr);
-
+		static CGEImageFilterInterface* faceDetectParser(const char* pstr, CGEMutipleEffectFilter* fatherFilter = nullptr);
 	};
 
 }
diff --git a/library/src/main/jni/include/filters/cgeFaceDetectFilter.h b/library/src/main/jni/include/filters/cgeFaceDetectFilter.h
new file mode 100644
index 00000000..ddd57382
--- /dev/null
+++ b/library/src/main/jni/include/filters/cgeFaceDetectFilter.h
@@ -0,0 +1,25 @@
+//
+// Created by Xue Weining on 2017/6/27.
+//
+
+#ifndef ANDROID_GPUIMAGE_PLUS_CGEFACEDETECTFILTER_H_H
+#define ANDROID_GPUIMAGE_PLUS_CGEFACEDETECTFILTER_H_H
+
+#include "cgeGLFunctions.h"
+namespace CGE
+{
+    class CGEFaceDetectFilter : public CGEImageFilterInterface {
+    public:
+        bool init();
+        void render2Texture(CGEImageHandlerInterface* handler, GLuint srcTexture, GLuint vertexBufferID);
+    protected:
+        ProgramObject m_programDrawPoint;
+    private:
+        GLfloat* m_keyfacePoint;
+        GLfloat* m_keyfaceColor;
+        GLint aPosition;
+        GLint aColor;
+    };
+}
+
+#endif //ANDROID_GPUIMAGE_PLUS_CGEFACEDETECTFILTER_H_H
diff --git a/library/src/main/jni/interface/cgeFrameRendererWrapper.cpp b/library/src/main/jni/interface/cgeFrameRendererWrapper.cpp
index af68557f..599be5fd 100755
--- a/library/src/main/jni/interface/cgeFrameRendererWrapper.cpp
+++ b/library/src/main/jni/interface/cgeFrameRendererWrapper.cpp
@@ -120,7 +120,7 @@ JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetRend
  * Method:    nativeSetFilterWidthConfig
  * Signature: (Ljava/nio/ByteBuffer;Ljava/lang/String;)V
  */
-JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetFilterWidthConfig
+JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetFilterWithConfig
   (JNIEnv *env, jobject obj, jlong addr, jstring config)
 {
 	static CGETexLoadArg texLoadArg;
@@ -254,7 +254,20 @@ JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetFilt
 	renderer->setFilter((CGEImageFilterInterfaceAbstract*)filter);
 }
 
+JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetFaceDetectPoints
+		(JNIEnv *env, jobject, jlong addr, jfloatArray keyPoints)
+{
+	CGEFrameRenderer* renderer = (CGEFrameRenderer*)addr;
+	float* nativeKeyPoints = env->GetFloatArrayElements(keyPoints, JNI_FALSE);
+	renderer->getImageHandler()->setFaceDetectKeyPoint(nativeKeyPoints);
+}
 
+JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeClearFaceDetectPoints
+		(JNIEnv *env, jobject, jlong addr)
+{
+	CGEFrameRenderer* renderer = (CGEFrameRenderer*)addr;
+	renderer->getImageHandler()->setFaceDetectKeyPoint(nullptr);
+}
 }
 
 
diff --git a/library/src/main/jni/interface/cgeFrameRendererWrapper.h b/library/src/main/jni/interface/cgeFrameRendererWrapper.h
index 147d934e..7279febc 100755
--- a/library/src/main/jni/interface/cgeFrameRendererWrapper.h
+++ b/library/src/main/jni/interface/cgeFrameRendererWrapper.h
@@ -83,7 +83,7 @@ JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetRend
  * Method:    nativeSetFilterWidthConfig
  * Signature: (Ljava/nio/ByteBuffer;Ljava/lang/String;)V
  */
-JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetFilterWidthConfig
+JNIEXPORT void JNICALL Java_org_wysaid_nativePort_CGEFrameRenderer_nativeSetFilterWithConfig
   (JNIEnv *, jobject, jlong, jstring);
 
 /*
diff --git a/library/src/main/libs/armeabi-v7a/libCGE.so b/library/src/main/libs/armeabi-v7a/libCGE.so
index cdbecaf3..fa04af8f 100755
Binary files a/library/src/main/libs/armeabi-v7a/libCGE.so and b/library/src/main/libs/armeabi-v7a/libCGE.so differ
diff --git a/library/src/main/libs/armeabi-v7a/libCGEExt.so b/library/src/main/libs/armeabi-v7a/libCGEExt.so
index ed4d632e..054a5800 100755
Binary files a/library/src/main/libs/armeabi-v7a/libCGEExt.so and b/library/src/main/libs/armeabi-v7a/libCGEExt.so differ
diff --git a/library/src/main/libs/armeabi-v7a/libFaceTracker.so b/library/src/main/libs/armeabi-v7a/libFaceTracker.so
index 9c8de788..9efd0a2a 100755
Binary files a/library/src/main/libs/armeabi-v7a/libFaceTracker.so and b/library/src/main/libs/armeabi-v7a/libFaceTracker.so differ
diff --git a/settings.gradle b/settings.gradle
index 5bc0df71..92f35b2c 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1 +1 @@
-include ':library', ':cgeDemo'
+include ':library', ':cgeDemo', 'stmobile'
diff --git a/stmobile/.gitignore b/stmobile/.gitignore
new file mode 100644
index 00000000..796b96d1
--- /dev/null
+++ b/stmobile/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/stmobile/build.gradle b/stmobile/build.gradle
new file mode 100644
index 00000000..87142028
--- /dev/null
+++ b/stmobile/build.gradle
@@ -0,0 +1,36 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 25
+    buildToolsVersion "25.0.2"
+
+    defaultConfig {
+        minSdkVersion 14
+        targetSdkVersion 25
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+
+        ndk {
+            abiFilters 'armeabi-v7a'
+        }
+    }
+
+    lintOptions {
+        abortOnError false
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+}
+
+dependencies {
+    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
+        exclude group: 'com.android.support', module: 'support-annotations'
+    })
+    testCompile 'junit:junit:4.12'
+    compile files('libs/jna-min.jar')
+}
diff --git a/stmobile/libs/jna-min.jar b/stmobile/libs/jna-min.jar
new file mode 100644
index 00000000..de659a75
Binary files /dev/null and b/stmobile/libs/jna-min.jar differ
diff --git a/stmobile/proguard-rules.pro b/stmobile/proguard-rules.pro
new file mode 100644
index 00000000..a3f0d013
--- /dev/null
+++ b/stmobile/proguard-rules.pro
@@ -0,0 +1,25 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in E:\AndroidStudioSDK\sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# 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 *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/stmobile/src/main/AndroidManifest.xml b/stmobile/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..4e90c951
--- /dev/null
+++ b/stmobile/src/main/AndroidManifest.xml
@@ -0,0 +1,14 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+
+    package="com.sensetime.stmobileapi">
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+
+    <application android:allowBackup="true" android:label="@string/app_name"
+        android:supportsRtl="true">
+
+    </application>
+
+</manifest>
diff --git a/stmobile/src/main/assets/track_face_action1.0.0.model b/stmobile/src/main/assets/track_face_action1.0.0.model
new file mode 100644
index 00000000..348ec61e
Binary files /dev/null and b/stmobile/src/main/assets/track_face_action1.0.0.model differ
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STImageFormat.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STImageFormat.java
new file mode 100644
index 00000000..d140bed5
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STImageFormat.java
@@ -0,0 +1,9 @@
+package com.sensetime.stmobileapi;
+
+public class STImageFormat {
+	public static final int ST_PIX_FMT_GRAY8 = 0;
+	public static final int ST_PIX_FMT_YUV420P = 1;
+	public static final int ST_PIX_FMT_NV12 = 2;
+	public static final int ST_PIX_FMT_NV21 = 3;
+	public static final int ST_PIX_FMT_BGRA8888 = 4;
+}
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STMobile106.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobile106.java
new file mode 100644
index 00000000..46e820a6
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobile106.java
@@ -0,0 +1,66 @@
+package com.sensetime.stmobileapi;
+
+import com.sensetime.stmobileapi.STMobileApiBridge.st_mobile_106_t;
+
+import android.graphics.PointF;
+import android.graphics.Rect;
+
+/**
+ * STMobile API: StMobile
+ * Created by Guangli W on 9/7/15.
+ */
+public class STMobile106 extends st_mobile_106_t{
+
+    public STMobile106() {
+    }
+
+    /**
+     * Get face Rect 
+     * @return Rect
+     */
+    public Rect getRect() {
+    	Rect r = new Rect();
+		r.bottom = rect.bottom;
+		r.top    = rect.top;
+		r.left   = rect.left;
+		r.right  = rect.right;
+    	return r;
+    }
+
+    /**
+     * Get face Points Array 
+     * @return Points Array, please check the length of array
+     */
+    public PointF[] getPointsArray() {
+    	PointF[] ans = new PointF[106];
+		for (int i = 0; i < 106; i++) {
+			ans[i] = new PointF();
+			ans[i].x = points_array[2 * i];
+			ans[i].y = points_array[2 * i + 1];
+		}
+    	return ans;
+    }
+    
+    public STMobile106(st_mobile_106_t origin) {
+		rect.bottom = origin.rect.bottom;
+		rect.top    = origin.rect.top;
+		rect.left   = origin.rect.left;
+		rect.right  = origin.rect.right;
+
+		score = origin.score;
+		yaw = origin.yaw;
+		pitch = origin.pitch;
+		roll = origin.roll;
+		eye_dist = origin.eye_dist;
+		ID = origin.ID;
+
+		for (int i = 0; i < points_array.length; i++) {
+			points_array[i] = origin.points_array[i];
+		}
+    }
+    
+    @Override
+    public String toString() {
+		return "STMobile(" + getRect() + ", " + score + ")";
+    }
+}
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileApiBridge.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileApiBridge.java
new file mode 100644
index 00000000..6611c385
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileApiBridge.java
@@ -0,0 +1,346 @@
+package com.sensetime.stmobileapi;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.sun.jna.Library;
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+import com.sun.jna.Structure;
+import com.sun.jna.ptr.FloatByReference;
+import com.sun.jna.ptr.IntByReference;
+import com.sun.jna.ptr.PointerByReference;
+
+public interface STMobileApiBridge extends Library {
+    class st_rect_t extends Structure {
+    	
+        public static class ByValue extends st_rect_t implements Structure.ByValue {
+        }
+
+        public int left;
+        public int top;
+        public int right;
+        public int bottom;
+
+        @Override
+        protected List getFieldOrder() {
+            return Arrays.asList(new String[]{"left", "top", "right", "bottom"});
+        }
+
+        @Override
+        public st_rect_t clone() {
+        	st_rect_t copy = new st_rect_t();
+            copy.left = this.left;
+            copy.top = this.top;
+            copy.right = this.right;
+            copy.bottom = this.bottom;
+            return copy;
+        }
+
+        /**
+         * The jna.Structure class is passed on by reference by default,
+         * however, in some cases, we need it by value.
+         */
+        public st_rect_t.ByValue copyToValue() {
+        	st_rect_t.ByValue retObj = new st_rect_t.ByValue();
+            retObj.left = this.left;
+            retObj.top = this.top;
+            retObj.right = this.right;
+            retObj.bottom = this.bottom;
+            return retObj;
+        }
+    }
+    
+    class st_mobile_106_t extends Structure {
+    	public st_rect_t rect;
+    	public float score;
+    	public float[] points_array = new float[212];
+    	public float yaw;
+    	public float pitch;
+    	public float roll;
+    	public int eye_dist;
+    	public int ID;
+
+        public st_mobile_106_t() {
+            super();
+        }
+
+        public st_mobile_106_t(Pointer p) {
+            super(p);
+        }
+
+        @Override
+        protected List getFieldOrder() {
+            return Arrays.asList(new String[]{"rect", "score", "points_array", 
+            		"yaw", "pitch", "roll", "eye_dist", "ID"});
+        }
+
+        @Override
+        public st_mobile_106_t clone() {
+        	st_mobile_106_t copy = new st_mobile_106_t();
+            copy.rect = this.rect.clone();
+            copy.score = this.score;
+            copy.points_array = this.points_array;
+            copy.yaw = this.yaw;
+            copy.pitch = this.pitch;
+            copy.roll = this.roll;
+            copy.eye_dist = this.eye_dist;
+            copy.ID = this.ID;
+            return copy;
+        }
+
+        public static st_mobile_106_t[] arrayCopy(st_mobile_106_t[] origin) {
+        	st_mobile_106_t[] copy = new st_mobile_106_t[origin.length];
+            for (int i = 0; i < origin.length; ++i) {
+                copy[i] = origin[i].clone();
+            }
+            return copy;
+        }
+    }
+
+    /**
+     * face信息及face上的相关动作
+
+     typedef struct st_mobile_face_action_t {
+         struct st_mobile_106_t face;          /// 人脸信息，包含矩形、106点、pose信息等//
+         unsigned int face_action;             /// 脸部动作
+     } st_mobile_face_action_t;
+
+     * */
+
+    class st_mobile_face_action_t extends Structure {
+        public st_mobile_106_t face;
+        public int face_action;
+
+        public st_mobile_face_action_t() {
+            super();
+        }
+
+        public st_mobile_face_action_t(Pointer p) {
+            super(p);
+        }
+
+        @Override
+        protected List getFieldOrder() {
+            return Arrays.asList(new String[] {"face", "face_action"});
+        }
+
+        @Override
+        protected Object clone() throws CloneNotSupportedException {
+            st_mobile_face_action_t copy = new st_mobile_face_action_t();
+            copy.face = this.face;
+            copy.face_action = this.face_action;
+
+            return copy;
+        }
+
+        public static st_mobile_face_action_t[] arrayCopy(st_mobile_face_action_t[] origin) {
+            st_mobile_face_action_t[] copy = new st_mobile_face_action_t[origin.length];
+            for(int i=0; i<origin.length; i++) {
+                try {
+                    copy[i] = (st_mobile_face_action_t) origin[i].clone();
+                } catch (CloneNotSupportedException e) {
+                    e.printStackTrace();
+                }
+            }
+            return copy;
+        }
+    }
+
+    enum ResultCode {
+        ST_OK(0),
+        ST_E_INVALIDARG(-1),
+        ST_E_HANDLE(-2),
+        ST_E_OUTOFMEMORY(-3),
+        ST_E_FAIL(-4),
+        ST_E_DELNOTFOUND(-5),
+    	ST_E_INVALID_PIXEL_FORMAT(-6),	///< 不支持的图像格式
+    	ST_E_FILE_NOT_FOUND(-10),   ///< 模型文件不存在
+    	ST_E_INVALID_FILE_FORMAT(-11),	///< 模型格式不正确，导致加载失败
+    	ST_E_INVALID_APPID(-12),		///< 包名错误
+    	ST_E_INVALID_AUTH(-13),		///< 加密狗功能不支持
+    	ST_E_AUTH_EXPIRE(-14),		///< SDK过期
+    	ST_E_FILE_EXPIRE(-15),		///< 模型文件过期
+    	ST_E_DONGLE_EXPIRE(-16),	///< 加密狗过期
+    	ST_E_ONLINE_AUTH_FAIL(-17),		///< 在线验证失败
+    	ST_E_ONLINE_AUTH_TIMEOUT(-18);
+
+        private final int resultCode;
+
+        ResultCode(int resultCode) {
+            this.resultCode = resultCode;
+        }
+
+        public int getResultCode() {
+            return resultCode;
+        }
+    }
+
+    /**
+     * The instance of stmobile DLL
+     */
+    STMobileApiBridge FACESDK_INSTANCE = (STMobileApiBridge) Native.loadLibrary("st_mobile", STMobileApiBridge.class);
+
+    //cv_mobile_face_106
+  /// @brief 创建实时人脸106关键点跟踪句柄
+  /// @param[in] model_path 模型文件的绝对路径或相对路径，若不指定模型可为NULL; 模型中包含detect+align+pose模型
+  /// @param[in] config 配置选项 默认使用双线程跟踪，可选择使用单线程，实时视频预览建议使用双线程，图片或视频后处理建议使用单线程
+  /// @parma[out] handle 人脸跟踪句柄，失败返回NULL
+  /// @return 成功返回CV_OK, 失败返回其他错误信息
+    int st_mobile_tracker_106_create(String model_path, int config, PointerByReference handle);
+
+  /// @brief 设置检测到的最大人脸数目N，持续track已检测到的N个人脸直到人脸数小于N再继续做detect.
+  /// @param[in] handle 已初始化的关键点跟踪句柄
+  /// @param[in] max_facecount 设置为1即是单脸跟踪，有效范围为[1, 32]
+  /// @return 成功返回CV_OK, 错误则返回错误码
+    int st_mobile_tracker_106_set_facelimit(Pointer handle,int max_facecount);
+
+  /// @brief 重置实时人脸106关键点跟踪
+  /// @param [in] handle 已初始化的实时目标人脸106关键点跟踪句柄
+  /// @return 成功返回CV_OK, 错误则返回错误码
+    int st_mobile_tracker_106_reset(Pointer handle);
+
+  /// @brief 设置tracker每多少帧进行一次detect.
+  /// @param[in] handle 已初始化的关键点跟踪句柄
+  /// @param[in] val  有效范围[1, -)
+  /// @return 成功返回CV_OK, 错误则返回错误码
+    int st_mobile_tracker_106_set_detect_interval(Pointer handle,int val);
+
+  /// @brief 对连续视频帧进行实时快速人脸106关键点跟踪
+  /// @param handle 已初始化的实时人脸跟踪句柄
+  /// @param image 用于检测的图像数据
+  /// @param pixel_format 用于检测的图像数据的像素格式,都支持，不推荐BGRA和BGR，会慢
+  /// @param image_width 用于检测的图像的宽度(以像素为单位)
+  /// @param image_height 用于检测的图像的高度(以像素为单位)
+  /// @param orientation 视频中人脸的方向
+  /// @param p_faces_array 检测到的人脸信息数组，api负责分配内存，需要调用st_mobile_release_tracker_result函数释放
+  /// @param p_faces_count 检测到的人脸数量
+  /// @return 成功返回CV_OK，否则返回错误类型
+    int st_mobile_tracker_106_track(
+    	Pointer handle,
+    	byte[] image,
+    	int pixel_format,
+    	int image_width,
+    	int image_height,
+    	int image_stride,
+    	int orientation,
+    	PointerByReference p_faces_array,
+    	IntByReference p_faces_count
+    );
+
+    int st_mobile_tracker_106_track(
+        	Pointer handle,
+        	int[] image,
+        	int pixel_format,
+        	int image_width,
+        	int image_height,
+        	int image_stride,
+        	int orientation,
+        	PointerByReference p_faces_array,
+        	IntByReference p_faces_count
+        );
+
+    /// @brief 对连续视频帧进行实时快速人脸106关键点跟踪，并检测脸部动作
+    /// @param handle 已初始化的实时人脸跟踪句柄
+    /// @param image 用于检测的图像数据
+    /// @param pixel_format 用于检测的图像数据的像素格式,都支持，不推荐BGRA和BGR，会慢
+    /// @param image_width 用于检测的图像的宽度(以像素为单位)
+    /// @param image_height 用于检测的图像的高度(以像素为单位)
+    /// @param[in] image_stride 用于检测的图像的跨度(以像素为单位)，即每行的字节数；目前仅支持字节对齐的padding，不支持roi
+    /// @param orientation 视频中人脸的方向
+    /// @param p_face_action_array 检测到的人脸106点信息和脸部动作的数组，api负责管理内存，会覆盖上一次调用获取到的数据
+    /// @param p_faces_count 检测到的人脸数量
+    /// @return 成功返回ST_OK，失败返回其他错误码,错误码定义在st_common.h 中，如ST_E_FAIL等
+    int st_mobile_tracker_106_track_face_action(
+            Pointer handle,
+            byte[] image,
+            int pixel_format,
+            int image_width,
+            int image_height,
+            int image_stride,
+            int orientation,
+            PointerByReference p_face_action_array,
+            IntByReference p_faces_count
+    );
+
+  /// @brief 释放实时人脸106关键点跟踪返回结果时分配的空间
+  /// @param faces_array 跟踪到到的人脸信息数组
+  /// @param faces_count 跟踪到的人脸数量
+    void st_mobile_tracker_106_release_result(Pointer faces_array, int faces_count);
+
+  /// @brief 销毁已初始化的track106句柄
+  /// @param handle 已初始化的句柄
+    void st_mobile_tracker_106_destroy(Pointer handle);
+
+   //========face detection
+  /// @brief 创建人脸检测句柄
+  int st_mobile_face_detection_create(String model_path, int config, PointerByReference handle);
+
+  int st_mobile_face_detection_detect(
+  	Pointer handle,
+  	byte[] image,
+  	int pixel_format,
+  	int image_width,
+  	int image_height,
+  	int image_stride,
+  	int orientation,
+  	PointerByReference p_faces_array,
+  	IntByReference p_faces_count
+  );
+
+  int st_mobile_face_detection_detect(
+		  	Pointer handle,
+		  	int[] image,
+		  	int pixel_format,
+		  	int image_width,
+		  	int image_height,
+		  	int image_stride,
+		  	int orientation,
+		  	PointerByReference p_faces_array,
+		  	IntByReference p_faces_count
+		  );
+
+/// @brief 释放人脸检测结果
+  void st_mobile_face_detection_release_result(Pointer faces_array,int faces_count);
+
+/// @brief 销毁已初始化的人脸检测句柄
+/// @param[in] handle 已初始化的句柄
+  void st_mobile_face_detection_destroy(Pointer handle);
+
+
+/// @brief 创建人脸属性检测句柄
+/// @param[in] model_path 模型文件的绝对路径或相对路径
+/// @param[out] 人脸属性检测句柄
+/// @return 成功返回ST_OK, 错误则返回错误码，错误码定义在st_common.h 中，如ST_E_FAIL等
+  int st_mobile_face_attribute_create(
+      String model_path,
+      PointerByReference handle
+  );
+
+/// @brief 销毁已初始化的人脸属性检测句柄
+/// @param[in] attribute_handle 已初始化的人脸属性检测句柄
+  void st_mobile_face_attribute_destroy(Pointer handle);
+
+/// @brief 人脸属性检测
+/// @param[in] handle 已初始化的人脸属性检测句柄
+/// @param[in] image 用于检测的图像数据,推荐灰度格式
+/// @param[in] piexl_format 用于检测的图像数据的像素格式, 支持所有彩色图像格式，推荐ST_PIX_FMT_BGR888，不建议使用ST_PIX_FMT_GRAY8结果不准确
+/// @param[in] image_width 用于检测的图像的宽度(以像素为单位)
+/// @param[in] image_height 用于检测的图像的高度(以像素为单位)
+/// @param[in] image_stride 用于检测的图像中每一行的跨度(以像素为单位)
+/// @param[in] p_face 输入待处理的人脸信息，需要包括关键点信息
+/// @param[out] p_attributes 检测到的人脸属性结果(由用户分配和释放，长度需为对应属性ST_ATTRIBUTE_LENGTH的定义)
+/// @return 成功返回ST_OK, 错误则返回错误码，错误码定义在st_common.h 中，如ST_E_FAIL等
+   int st_mobile_face_attribute_detect(
+         Pointer handle,
+         byte[] image,
+         int pixel_format,
+         int image_width,
+         int image_height,
+         int image_stride,
+         PointerByReference p_face,                 //检查这里是否和st_mobile_face_action_t **p_face_action_array用法类似
+         IntByReference p_attributes
+   );
+
+
+}
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileFaceAction.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileFaceAction.java
new file mode 100644
index 00000000..58816264
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileFaceAction.java
@@ -0,0 +1,50 @@
+package com.sensetime.stmobileapi;
+
+import com.sensetime.stmobileapi.STMobileApiBridge.st_mobile_face_action_t;
+
+/**
+ * Created by zhym on 2016/8/23.
+ */
+
+public class STMobileFaceAction extends st_mobile_face_action_t {
+    public STMobileFaceAction() {
+    }
+
+    public STMobileFaceAction(st_mobile_face_action_t origin) {
+        face.rect = origin.face.rect;
+        face.score = origin.face.score;
+        face.yaw = origin.face.yaw;
+        face.pitch = origin.face.pitch;
+        face.roll = origin.face.roll;
+        face.eye_dist = origin.face.eye_dist;
+        face.ID = origin.face.ID;
+
+        for(int i=0; i<face.points_array.length; i++) {
+            face.points_array[i] = origin.face.points_array[i];
+        }
+
+        face_action = origin.face_action;
+    }
+
+    /**
+     * Get face action
+     * @return STMobile106
+     * */
+    public STMobile106 getFace() {
+        STMobile106 s = new STMobile106();
+        s.rect = face.rect;
+        s.score = face.score;
+        s.points_array = face.points_array;
+        s.yaw = face.yaw;
+        s.pitch = face.pitch;
+        s.roll = face.roll;
+        s.eye_dist = face.eye_dist;
+        s.ID = face.ID;
+        return s;
+    }
+
+    @Override
+    public String toString() {
+        return "STMobileFaceAction("+getFace()+", "+face_action+")";
+    }
+}
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileFaceDetection.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileFaceDetection.java
new file mode 100644
index 00000000..f26b437d
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileFaceDetection.java
@@ -0,0 +1,226 @@
+package com.sensetime.stmobileapi;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import com.sensetime.stmobileapi.STMobileApiBridge.ResultCode;
+import com.sensetime.stmobileapi.STMobileApiBridge.st_mobile_106_t;
+import com.sun.jna.Pointer;
+import com.sun.jna.ptr.IntByReference;
+import com.sun.jna.ptr.PointerByReference;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.util.Log;
+
+public class STMobileFaceDetection {
+	private Pointer detectHandle;
+	private Context mContext;
+	private static boolean DEBUG = true;// false;
+	private String TAG = "FaceDetection";
+	private static final String DETECTION_MODEL_NAME = "track_compose.model";
+	public static int ST_MOBILE_DETECT_DEFAULT_CONFIG = 0x00000000;  ///< 默认选项
+	public static int ST_MOBILE_DETECT_FAST = 0x00000001;  ///< resize图像为长边320的图像之后再检测，结果处理为原图像对应结果
+	public static int ST_MOBILE_DETECT_BALANCED = 0x00000002;  ///< resize图像为长边640的图像之后再检测，结果处理为原图像对应结果
+	public static int ST_MOBILE_DETECT_ACCURATE = 0x00000004;
+	
+    PointerByReference ptrToArray = new PointerByReference();
+    IntByReference ptrToSize = new IntByReference();
+
+    public STMobileFaceDetection(Context context, int config) {
+        PointerByReference handlerPointer = new PointerByReference();
+		mContext = context;
+		synchronized(this.getClass())
+		{
+		   copyModelIfNeed(DETECTION_MODEL_NAME);
+		}
+		String modulePath = getModelPath(DETECTION_MODEL_NAME);
+    	int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_face_detection_create(modulePath, config, handlerPointer);
+    	if(rst != ResultCode.ST_OK.getResultCode())
+    	{
+    		return;
+    	}
+    	detectHandle = handlerPointer.getValue();
+    }
+    
+	private void copyModelIfNeed(String modelName) {
+		String path = getModelPath(modelName);
+		if (path != null) {
+			File modelFile = new File(path);
+			if (!modelFile.exists()) {
+				//如果模型文件不存在或者当前模型文件的版本跟sdcard中的版本不一样
+				try {
+					if (modelFile.exists())
+						modelFile.delete();
+					modelFile.createNewFile();
+					InputStream in = mContext.getApplicationContext().getAssets().open(modelName);
+					if(in == null)
+					{
+						Log.e(TAG, "the src module is not existed");
+					}
+					OutputStream out = new FileOutputStream(modelFile);
+					byte[] buffer = new byte[4096];
+					int n;
+					while ((n = in.read(buffer)) > 0) {
+						out.write(buffer, 0, n);
+					}
+					in.close();
+					out.close();
+				} catch (IOException e) {
+					modelFile.delete();
+				}
+			}
+		}
+	}
+	
+	protected String getModelPath(String modelName) {
+		String path = null;
+		File dataDir = mContext.getApplicationContext().getExternalFilesDir(null);
+		if (dataDir != null) {
+			path = dataDir.getAbsolutePath() + File.separator + modelName;
+		}
+		return path;
+	}
+	
+	public void destory()
+	{
+    	long start_destroy = System.currentTimeMillis();
+    	if(detectHandle != null) {
+    		STMobileApiBridge.FACESDK_INSTANCE.st_mobile_face_detection_destroy(detectHandle);
+    		detectHandle = null;
+    	}
+        long end_destroy = System.currentTimeMillis();
+        Log.i(TAG, "destroy cost "+(end_destroy - start_destroy)+" ms");
+	}
+	
+    /**
+     * Given the Image by Bitmap to detect face
+     * @param image Input image by Bitmap
+     * @param orientation Image orientation
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] detect(Bitmap image, int orientation) {
+    	if(DEBUG) 
+    		Log.d(TAG, "detect bitmap");
+    	
+        int[] colorImage = STUtils.getBGRAImageByte(image);
+        return detect(colorImage, STImageFormat.ST_PIX_FMT_BGRA8888,image.getWidth(), image.getHeight(), image.getWidth(), orientation);
+    }
+    
+    /**
+     * Given the Image by Byte Array to detect face
+     * @param colorImage Input image by int
+     * @param cvImageFormat Image format
+     * @param imageWidth Image width
+     * @param imageHeight Image height
+     * @param imageStride Image stride
+     * @param orientation Image orientation
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] detect(int[] colorImage,int cvImageFormat, int imageWidth, int imageHeight, int imageStride, int orientation) {
+    	if(DEBUG)
+    		Log.d(TAG, "detect int array");
+    	
+    	if(detectHandle == null){
+    		return null;
+    	}
+        long startTime = System.currentTimeMillis();
+
+        int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_face_detection_detect(detectHandle, colorImage, cvImageFormat,imageWidth,
+                imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+        long endTime = System.currentTimeMillis();
+        
+        if(DEBUG)Log.d(TAG, "detect time: "+(endTime-startTime)+"ms");
+        
+        if (rst != ResultCode.ST_OK.getResultCode()) {
+            throw new RuntimeException("Calling st_mobile_face_detection_detect() method failed! ResultCode=" + rst);
+        }
+
+        if (ptrToSize.getValue() == 0) {
+        	if(DEBUG)Log.d(TAG, "ptrToSize.getValue() == 0");
+            return new STMobile106[0];
+        }
+
+        st_mobile_106_t arrayRef = new st_mobile_106_t(ptrToArray.getValue());
+        arrayRef.read();
+        st_mobile_106_t[] array = st_mobile_106_t.arrayCopy((st_mobile_106_t[]) arrayRef.toArray(ptrToSize.getValue()));
+        STMobileApiBridge.FACESDK_INSTANCE.st_mobile_face_detection_release_result(ptrToArray.getValue(), ptrToSize.getValue());
+        
+        STMobile106[] ret = new STMobile106[array.length]; 
+        for (int i = 0; i < array.length; i++) {
+        	ret[i] = new STMobile106(array[i]);
+        }
+        
+        if(DEBUG)Log.d(TAG, "track : "+ ret);
+        
+        return ret;
+    }
+    
+    /**
+     * Given the Image by Byte to detect face
+     * @param image Input image by byte
+     * @param orientation Image orientation
+     * @param width Image width
+     * @param height Image height
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] detect(byte[] image, int orientation,int width,int height) {
+    	if(DEBUG){
+    		Log.d(TAG, "detect byte array");
+    	}
+    	
+        return detect(image, STImageFormat.ST_PIX_FMT_NV21,width, height, width, orientation);
+    }
+
+    /**
+     * Given the Image by Byte Array to detect face
+     * @param colorImage Input image by byte
+     * @param cvImageFormat Image format
+     * @param imageWidth Image width
+     * @param imageHeight Image height
+     * @param imageStride Image stride
+     * @param orientation Image orientation
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] detect(byte[] colorImage,int cvImageFormat, int imageWidth, int imageHeight, int imageStride, int orientation) {
+    	if(DEBUG){
+    		Log.d(TAG, "detect 111");
+    	}
+    	
+    	if(detectHandle == null){
+    		return null;
+    	}
+        long startTime = System.currentTimeMillis();
+
+        int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_face_detection_detect(detectHandle, colorImage, cvImageFormat,imageWidth,
+                imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+        long endTime = System.currentTimeMillis();
+        
+        if(DEBUG)Log.d(TAG, "detect time: "+(endTime-startTime)+"ms");
+        
+        if (rst != ResultCode.ST_OK.getResultCode()) {
+            throw new RuntimeException("Calling st_mobile_face_detection_detect() method failed! ResultCode=" + rst);
+        }
+
+        if (ptrToSize.getValue() == 0) {
+            return new STMobile106[0];
+        }
+
+        st_mobile_106_t arrayRef = new st_mobile_106_t(ptrToArray.getValue());
+        arrayRef.read();
+        st_mobile_106_t[] array = st_mobile_106_t.arrayCopy((st_mobile_106_t[]) arrayRef.toArray(ptrToSize.getValue()));
+        STMobileApiBridge.FACESDK_INSTANCE.st_mobile_face_detection_release_result(ptrToArray.getValue(), ptrToSize.getValue());
+        
+        STMobile106[] ret = new STMobile106[array.length]; 
+        for (int i = 0; i < array.length; i++) {
+        	ret[i] = new STMobile106(array[i]);
+        }
+        
+        if(DEBUG)Log.d(TAG, "track : "+ ret);
+        
+        return ret;
+    }
+}
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileMultiTrack106.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileMultiTrack106.java
new file mode 100644
index 00000000..3c81b20d
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STMobileMultiTrack106.java
@@ -0,0 +1,321 @@
+package com.sensetime.stmobileapi;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import com.sensetime.stmobileapi.STMobileApiBridge.ResultCode;
+import com.sensetime.stmobileapi.STMobileApiBridge.st_mobile_106_t;
+import com.sensetime.stmobileapi.STMobileApiBridge.st_mobile_face_action_t;
+import com.sun.jna.Pointer;
+import com.sun.jna.ptr.IntByReference;
+import com.sun.jna.ptr.PointerByReference;
+
+public class STMobileMultiTrack106 {
+	private Pointer trackHandle;
+    public static final int FACE_KEY_POINTS_COUNT = 106;
+    static boolean DEBUG = true;// false;
+    
+    public static int ST_MOBILE_TRACKING_DEFAULT_CONFIG = 0x00000000;
+    public static int ST_MOBILE_TRACKING_SINGLE_THREAD = 0x00000001;
+    
+	private Context mContext;
+	private static final String BEAUTIFY_MODEL_NAME = "track_face_action1.0.0.model";
+      
+    PointerByReference ptrToArray = new PointerByReference();
+	PointerByReference faceAction_ptrToArray = new PointerByReference();
+
+    IntByReference ptrToSize = new IntByReference();		//face count int pointer
+
+    /**
+     * 
+     * Note
+        track only one face： 
+        frist:trackHandle = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_create(modulePath, handlerPointer);
+        second: setMaxDetectableFaces(1)参数设为1
+     *  track多张人脸：	
+     *  trackHandle = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_create(modulePath, handlerPointer);
+        second:setMaxDetectableFaces(num)参数设为-1
+     */
+     
+    public STMobileMultiTrack106(Context context, int config) {
+        PointerByReference handlerPointer = new PointerByReference();
+		mContext = context;
+		synchronized(this.getClass())
+		{
+		   copyModelIfNeed(BEAUTIFY_MODEL_NAME);
+		}
+		String modulePath = getModelPath(BEAUTIFY_MODEL_NAME);
+    	int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_create(modulePath, config, handlerPointer);
+    	if(rst != ResultCode.ST_OK.getResultCode())
+    	{
+    		return;
+    	}
+    	trackHandle = handlerPointer.getValue();
+    }
+    
+	private void copyModelIfNeed(String modelName) {
+		String path = getModelPath(modelName);
+		if (path != null) {
+			File modelFile = new File(path);
+			if (!modelFile.exists()) {
+				//如果模型文件不存在或者当前模型文件的版本跟sdcard中的版本不一样
+				try {
+					if (modelFile.exists())
+						modelFile.delete();
+					modelFile.createNewFile();
+					InputStream in = mContext.getApplicationContext().getAssets().open(modelName);
+					if(in == null)
+					{
+						Log.e("MultiTrack106", "the src module is not existed");
+					}
+					OutputStream out = new FileOutputStream(modelFile);
+					byte[] buffer = new byte[4096];
+					int n;
+					while ((n = in.read(buffer)) > 0) {
+						out.write(buffer, 0, n);
+					}
+					in.close();
+					out.close();
+				} catch (IOException e) {
+					modelFile.delete();
+				}
+			}
+		}
+	}
+	
+	protected String getModelPath(String modelName) {
+		String path = null;
+		File dataDir = mContext.getApplicationContext().getExternalFilesDir(null);
+		if (dataDir != null) {
+			path = dataDir.getAbsolutePath() + File.separator + modelName;
+		}
+		return path;
+	}
+    
+    public int setMaxDetectableFaces(int max)
+    {
+    	int rst = -1;
+    	if(trackHandle != null){
+    	rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_set_facelimit(trackHandle,max);
+    	}
+        return rst;
+    }
+    
+	public void destory()
+	{
+    	long start_destroy = System.currentTimeMillis();
+    	if(trackHandle != null) {
+    		STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_destroy(trackHandle);
+    		trackHandle = null;
+    	}
+        long end_destroy = System.currentTimeMillis();
+        Log.i("track106", "destroy cost "+(end_destroy - start_destroy)+" ms");
+	}
+    /**
+     * Given the Image by Bitmap to track face
+     * @param image Input image by Bitmap
+     * @param orientation Image orientation
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] track(Bitmap image, int orientation) {
+    	if(DEBUG)System.out.println("SampleLiveness-------->CvFaceMultiTrack--------->track1");
+    	
+        int[] colorImage = STUtils.getBGRAImageByte(image);
+        return track(colorImage, STImageFormat.ST_PIX_FMT_BGRA8888,image.getWidth(), image.getHeight(), image.getWidth(), orientation);
+    }
+
+    /**
+     * Given the Image by Byte Array to track face
+     * @param colorImage Input image by int
+     * @param cvImageFormat Image format
+     * @param imageWidth Image width
+     * @param imageHeight Image height
+     * @param imageStride Image stride
+     * @param orientation Image orientation
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] track(int[] colorImage,int cvImageFormat, int imageWidth, int imageHeight, int imageStride, int orientation) {
+    	if(DEBUG)System.out.println("SampleLiveness-------->CvFaceMultiTrack--------->track2");
+    	
+    	if(trackHandle == null){
+    		return null;
+    	}
+        long startTime = System.currentTimeMillis();
+        /*
+        int rst = STMobileApiBridge.FACESDK_INSTANCE.cv_face_track_106(trackHandle, colorImage, cvImageFormat,imageWidth,
+                imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+        */
+        int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_track(trackHandle, colorImage, cvImageFormat,imageWidth,
+                imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+        long endTime = System.currentTimeMillis();
+        
+        if(DEBUG)Log.d("Test", "multi track time: "+(endTime-startTime)+"ms");
+        
+        if (rst != ResultCode.ST_OK.getResultCode()) {
+            throw new RuntimeException("Calling cv_face_multi_track() method failed! ResultCode=" + rst);
+        }
+
+        if (ptrToSize.getValue() == 0) {
+        	if(DEBUG)Log.d("Test", "ptrToSize.getValue() == 0");
+            return new STMobile106[0];
+        }
+
+        st_mobile_106_t arrayRef = new st_mobile_106_t(ptrToArray.getValue());
+        arrayRef.read();
+        st_mobile_106_t[] array = st_mobile_106_t.arrayCopy((st_mobile_106_t[]) arrayRef.toArray(ptrToSize.getValue()));
+        STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_release_result(ptrToArray.getValue(), ptrToSize.getValue());
+        
+        STMobile106[] ret = new STMobile106[array.length]; 
+        for (int i = 0; i < array.length; i++) {
+        	ret[i] = new STMobile106(array[i]);
+        }
+        
+        if(DEBUG)Log.d("Test", "track : "+ ret);
+        
+        return ret;
+    }
+    
+    /**
+     * Given the Image by Byte to track face
+     * @param image Input image by byte
+     * @param orientation Image orientation
+     * @param width Image width
+     * @param height Image height
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] track(byte[] image, int orientation,int width,int height) {
+    	if(DEBUG){
+    		System.out.println("SampleLiveness-------->CvFaceMultiTrack--------->track3");
+    	}
+    	
+        return track(image, STImageFormat.ST_PIX_FMT_NV21,width, height, width, orientation);
+    }
+
+    /**
+     * Given the Image by Byte Array to track face
+     * @param colorImage Input image by byte
+     * @param cvImageFormat Image format
+     * @param imageWidth Image width
+     * @param imageHeight Image height
+     * @param imageStride Image stride
+     * @param orientation Image orientation
+     * @return CvFace array, each one in array is Detected by SDK native API
+     */
+    public STMobile106[] track(byte[] colorImage,int cvImageFormat, int imageWidth, int imageHeight, int imageStride, int orientation) {
+		Log.d("ST_mobile", "track: "+imageWidth+" "+imageHeight+" "+imageStride+" "+orientation);
+		if(DEBUG){
+    		System.out.println("SampleLiveness-------->CvFaceMultiTrack--------->track4");
+    	}
+    	
+    	if(trackHandle == null){
+    		return null;
+    	}
+        long startTime = System.currentTimeMillis();
+        /*
+           int rst = STMobileApiBridge.FACESDK_INSTANCE.cv_face_track_106(trackHandle, colorImage, cvImageFormat,imageWidth,
+                imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+         */
+
+        int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_track(trackHandle, colorImage, cvImageFormat,imageWidth,
+                imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+//		int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_track_face_action(trackHandle, colorImage, cvImageFormat, imageWidth,
+//				imageHeight, imageStride, orientation, ptrToArray, ptrToSize);
+
+        long endTime = System.currentTimeMillis();
+        
+        if(DEBUG)Log.d("Test", "multi track time: "+(endTime-startTime)+"ms");
+        
+        if (rst != ResultCode.ST_OK.getResultCode()) {
+            throw new RuntimeException("Calling cv_face_multi_track() method failed! ResultCode=" + rst);
+        }
+
+        if (ptrToSize.getValue() == 0) {
+            return new STMobile106[0];
+        }
+
+        st_mobile_106_t arrayRef = new st_mobile_106_t(ptrToArray.getValue());
+        arrayRef.read();
+        st_mobile_106_t[] array = st_mobile_106_t.arrayCopy((st_mobile_106_t[]) arrayRef.toArray(ptrToSize.getValue()));
+        //STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_release_result(ptrToArray.getValue(), ptrToSize.getValue());
+        
+        STMobile106[] ret = new STMobile106[array.length]; 
+        for (int i = 0; i < array.length; i++) {
+        	ret[i] = new STMobile106(array[i]);
+        }
+        
+        if(DEBUG)Log.d("Test", "track : "+ ret);
+        
+        return ret;
+    }
+
+	/**
+	 * Given the Image by Byte to trace face action
+	 * @param image Input image by byte
+	 * @param orientation Image orientation
+	 * @param width Image width
+	 * @param height Image height
+	 * @return CvFace action array, each one in array is Detected by SDK native API
+	 * */
+	public STMobileFaceAction[] trackFaceAction(byte[] image, int orientation, int width, int height) {
+		Log.d("ST_mobile", "track: "+width+" "+height+" "+orientation);
+		if(DEBUG) {
+			System.out.println("SampleTrackFaceAction-------->CvFaceMultiTrack--------->trackFaceAction1");
+		}
+		return trackFaceAction(image, STImageFormat.ST_PIX_FMT_NV21, width, height, width, orientation);
+	}
+
+	/**
+	 *  Given the Image by Byte Array to track face action
+	 *  @param colorImage Input image by byte
+	 *  @param cvImageFormat Image format
+	 *  @param imageWidth Image width
+	 *  @param imageHeight Image height
+	 *  @param imageStride Image stride
+	 *  @param orientation Image orientation
+	 *  @return CvFace action array, each one in array is Detected by SDK native API
+	 * */
+	public STMobileFaceAction[] trackFaceAction(byte[] colorImage, int cvImageFormat, int imageWidth, int imageHeight, int imageStride, int orientation) {
+		if(DEBUG) {
+			System.out.println("SampleTrackFaceAction-------->CvFaceMultiTrack--------->trackFaceAction2");
+		}
+
+		if(trackHandle == null) {
+			return null;
+		}
+
+		long startTime = System.currentTimeMillis();
+		int rst = STMobileApiBridge.FACESDK_INSTANCE.st_mobile_tracker_106_track_face_action(trackHandle, colorImage, cvImageFormat, imageWidth,
+				imageHeight, imageStride, orientation, faceAction_ptrToArray, ptrToSize);
+		long endTime = System.currentTimeMillis();
+		if(DEBUG)Log.d("trackFaceAction", "multi track face action time: "+(endTime-startTime)+"ms");
+
+		if(rst != ResultCode.ST_OK.getResultCode()) {
+			throw new RuntimeException("Calling cv_face_action_multi_track() method failed! ResultCode=" + rst);
+		}
+
+		if(ptrToSize.getValue() == 0) {
+			return new STMobileFaceAction[0];
+		}
+
+		st_mobile_face_action_t arrayRef = new st_mobile_face_action_t(faceAction_ptrToArray.getValue());
+		arrayRef.read();
+		st_mobile_face_action_t[] array = st_mobile_face_action_t.arrayCopy((st_mobile_face_action_t[]) arrayRef.toArray(ptrToSize.getValue()));
+
+		STMobileFaceAction[] ret = new STMobileFaceAction[array.length];
+		for(int i=0; i<array.length; i++) {
+			ret[i] = new STMobileFaceAction(array[i]);
+		}
+
+		if(DEBUG)Log.d("STMobileMultiTrack106", "face action track ret = "+ ret);
+
+		return ret;
+	}
+
+}
diff --git a/stmobile/src/main/java/com/sensetime/stmobileapi/STUtils.java b/stmobile/src/main/java/com/sensetime/stmobileapi/STUtils.java
new file mode 100644
index 00000000..02e3cc39
--- /dev/null
+++ b/stmobile/src/main/java/com/sensetime/stmobileapi/STUtils.java
@@ -0,0 +1,286 @@
+package com.sensetime.stmobileapi;
+
+import java.io.ByteArrayOutputStream;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.Config;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ImageFormat;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Paint.Style;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.YuvImage;
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.renderscript.ScriptIntrinsicYuvToRGB;
+import android.renderscript.Type;
+import android.util.TimingLogger;
+
+/**
+ * CvFaceSDK: Utils
+ * Created by Guangli W on 9/7/15.
+ */
+public class STUtils {
+    /**
+     * Get the pixels by byte[] of Bitmap
+     * @param image
+	 * @return pixels by byte[]
+     */
+    public static int[] getBGRAImageByte(Bitmap image) {
+        int width = image.getWidth();
+        int height = image.getHeight();
+
+		if(image.getConfig().equals(Config.ARGB_8888)) {
+	        int[] imgData = new int[width * height];
+	        image.getPixels(imgData, 0, width, 0, 0, width, height);
+	        return imgData;
+	       
+//	        byte[] imgPixels = new byte[width * height];
+//	        for (int i = 0; i < imgData.length; ++i) {
+//	        	int p = 0;
+//	        	//p += ((imgData[i] >> 24) & 0xFF);
+//	        	p += ((imgData[i] >> 16) & 0xFF);
+//	        	p += ((imgData[i] >> 8) & 0xFF);
+//	        	p += ((imgData[i] >> 0) & 0xFF);
+//	            imgPixels[i] = (byte) (p/3);
+//	        }
+		} else {
+			// TODO
+		}
+
+        return null;
+    }
+    
+    
+    static RenderScript mRS = null;
+    
+    static ScriptIntrinsicYuvToRGB mYuvToRgb = null;
+    
+    static Allocation ain = null;
+    
+    static Allocation aOut = null;
+    
+    static Bitmap bitmap = null;
+    
+    static final String TIMING_LOG_TAG = "CvUtils timing";
+    
+	@SuppressLint("NewApi")
+	public static Bitmap NV21ToRGBABitmap(byte []nv21, int width, int height, Context context) {
+		
+		TimingLogger timings = new TimingLogger(TIMING_LOG_TAG, "NV21ToRGBABitmap");
+		
+		Rect rect = new Rect(0, 0, width, height);
+		
+		try {
+			Class.forName("android.renderscript.Element$DataKind").getField("PIXEL_YUV");
+			Class.forName("android.renderscript.ScriptIntrinsicYuvToRGB");
+	    	byte[] imageData = nv21;
+	    	if (mRS == null) {
+	    		mRS = RenderScript.create(context);
+	    		mYuvToRgb = ScriptIntrinsicYuvToRGB.create(mRS, Element.U8_4(mRS));
+	    		Type.Builder tb = new Type.Builder(mRS, Element.createPixel(mRS, Element.DataType.UNSIGNED_8, Element.DataKind.PIXEL_YUV));
+	    		tb.setX(width);
+	    		tb.setY(height);
+	    		tb.setMipmaps(false);
+	    		tb.setYuvFormat(ImageFormat.NV21);
+	    		ain = Allocation.createTyped(mRS, tb.create(), Allocation.USAGE_SCRIPT);
+	    		timings.addSplit("Prepare for ain");
+	    		Type.Builder tb2 = new Type.Builder(mRS, Element.RGBA_8888(mRS));
+	    		tb2.setX(width);
+	    		tb2.setY(height);
+	    		tb2.setMipmaps(false);
+	    		aOut = Allocation.createTyped(mRS, tb2.create(), Allocation.USAGE_SCRIPT & Allocation.USAGE_SHARED);
+	    		timings.addSplit("Prepare for aOut");
+	    		bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+	    		timings.addSplit("Create Bitmap");
+			}
+	    	ain.copyFrom(imageData);
+			timings.addSplit("ain copyFrom");
+			mYuvToRgb.setInput(ain);
+			timings.addSplit("setInput ain");
+			mYuvToRgb.forEach(aOut);
+			timings.addSplit("NV21 to ARGB forEach");
+			aOut.copyTo(bitmap);
+			timings.addSplit("Allocation to Bitmap");
+		} catch (Exception e) {
+			YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21, width, height, null);
+			timings.addSplit("NV21 bytes to YuvImage");
+			
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+	        yuvImage.compressToJpeg(rect, 90, baos);
+	        byte[] cur = baos.toByteArray();
+	        timings.addSplit("YuvImage crop and compress to Jpeg Bytes");
+	        
+	        bitmap = BitmapFactory.decodeByteArray(cur, 0, cur.length);
+	        timings.addSplit("Jpeg Bytes to Bitmap");
+		}
+		
+    	timings.dumpToLog();
+    	return bitmap;
+	}
+    
+	/**
+	 * 将Android的特殊格式转化成ARGB彩图
+	 * 
+	 * @param NV21
+	 * 输入的图片数据，Android读图特殊格式
+	 * 
+	 * @param width
+	 * 输入图的宽度
+	 * 
+	 * @param height
+	 * 输入图的高度
+	 * 
+	 * @return
+	 * ARGB彩图
+	 */
+	static public Bitmap NV21ToRGBABitmap(byte []nv21, int width, int height) {
+		YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21, width, height, null);
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        yuvImage.compressToJpeg(new Rect(0, 0, width, height), 100, baos);
+        byte[] cur = baos.toByteArray();
+        return BitmapFactory.decodeByteArray(cur, 0, cur.length);
+	}
+
+    /**
+     * Draw the face rect in the Image
+     * @param canvas
+     * @param face
+     * @param width
+     * @param height
+     * @param frontCamera
+     */
+	static public void drawFaceRect(Canvas canvas, Rect rect, int width, int height, boolean frontCamera) {
+
+		if(canvas == null) return;
+
+		Paint paint = new Paint(); 
+		paint.setColor(Color.rgb(57, 138, 243));
+		int strokeWidth = Math.max(width / 240, 2);
+		paint.setStrokeWidth(strokeWidth);
+
+		if(frontCamera) {
+			int left = rect.left;
+			rect.left = width - rect.right;
+			rect.right = width - left;
+		}
+
+		paint.setStyle(Style.STROKE);
+		canvas.drawRect(rect, paint);
+	}
+
+    /**
+     * Draw points in the Image
+     * @param canvas
+     * @param points array
+     * @param width
+     * @param height
+     * @param frontCamera
+     */
+	static public void drawPoints(Canvas canvas, PointF[] points, int width, int height, boolean frontCamera) {
+
+		if(canvas == null) return;
+
+		Paint paint = new Paint();
+		paint.setColor(Color.rgb(57, 138, 243));
+		int strokeWidth = Math.max(width / 240, 2);
+		paint.setStrokeWidth(strokeWidth);
+		paint.setStyle(Style.STROKE);
+
+		for (PointF point : points) {
+			PointF p = point;
+			if(frontCamera) {
+				p.x = width - p.x;
+			}
+			canvas.drawPoint(p.x, p.y, paint);
+		}
+	}
+
+    /**
+     * rotate the coordinate in the image
+     * @param rect
+     * @param width, origin width in the image
+     * @param height, origin height in the image
+	 * @return rotated rect
+     */
+	static public Rect RotateDeg90(Rect rect, int width, int height, boolean frontCamera) {
+		int left = rect.left;
+		rect.left	= height- rect.bottom;
+		rect.bottom= rect.right;
+		rect.right	= height- rect.top;
+		rect.top	= left;
+		if (frontCamera) {
+			left = rect.left;
+			rect.left = height - rect.right;
+			rect.right = height - left;
+		}
+		return rect;
+	}
+	
+	static public Rect RotateDeg270(Rect rect, int width, int height, boolean frontCamera) {
+		int left = rect.left;
+		rect.left = rect.top;
+		rect.top = width - rect.right;
+		rect.right = rect.bottom;
+		rect.bottom = width - left;
+		if (frontCamera) {
+			left = rect.left;
+			rect.left = height - rect.right;
+			rect.right = height - left;
+		}
+		return rect;
+	}
+
+    /**
+     * rotate the coordinate in the image
+     * @param point
+     * @param width, origin width in the image
+     * @param height, origin height in the image
+	 * @return rotated PointF
+     */
+	static public PointF RotateDeg90(PointF point, int width, int height, boolean frontCamera) {
+		float x = point.x;
+		point.x = height - point.y;
+		point.y = x;
+		if(frontCamera) {
+			point.x = height - point.x;
+		}
+		return point;
+	}
+	
+	static public PointF RotateDeg270(PointF point, int width, int height, boolean frontCamera) {
+		float x = point.x;
+		point.x = point.y;
+		point.y = width - x;
+		if(frontCamera) {
+			point.x = height - point.x;
+		}
+		return point;
+	}
+	
+	public static Bitmap getRotateBitmap(Bitmap bitmap, int rotation){
+		if(null == bitmap || bitmap.isRecycled()){
+			return null;
+		}
+		
+		Matrix matrix = new Matrix();
+		matrix.postRotate(rotation);
+		Bitmap cropBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),bitmap.getHeight(), matrix, false);
+		return cropBitmap;
+	}
+	
+	public static void recycleBitmap(Bitmap bitmap){
+		if(bitmap == null || bitmap.isRecycled()){
+			return;
+		}
+		bitmap.recycle();
+		bitmap = null;
+	}
+}
diff --git a/stmobile/src/main/jniLibs/armeabi-v7a/libjnidispatch.so b/stmobile/src/main/jniLibs/armeabi-v7a/libjnidispatch.so
new file mode 100644
index 00000000..a4b57253
Binary files /dev/null and b/stmobile/src/main/jniLibs/armeabi-v7a/libjnidispatch.so differ
diff --git a/stmobile/src/main/jniLibs/armeabi-v7a/libst_mobile.so b/stmobile/src/main/jniLibs/armeabi-v7a/libst_mobile.so
new file mode 100644
index 00000000..de1c6beb
Binary files /dev/null and b/stmobile/src/main/jniLibs/armeabi-v7a/libst_mobile.so differ
diff --git a/stmobile/src/main/res/values/strings.xml b/stmobile/src/main/res/values/strings.xml
new file mode 100644
index 00000000..799cf3c2
--- /dev/null
+++ b/stmobile/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">STMobile</string>
+</resources>