diff --git a/CMakeLists.txt b/CMakeLists.txt
index 269fd40a0a..1aac333aba 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,8 +48,8 @@ endif()
 
 if(ANDROID)
   # To reduce the volume of the library
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g0 -Ofast -ffunction-sections -fdata-sections")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g0 -Ofast -ffunction-sections -fdata-sections")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g0 -Ofast -ffast-math -ffunction-sections -fdata-sections")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g0 -Ofast -ffast-math -ffunction-sections -fdata-sections")
 endif()
 
 ############################# Basic Options for FastDeploy ################################
@@ -74,10 +74,14 @@ option(WITH_KUNLUNXIN "Whether to compile for KunlunXin XPU deploy." OFF)
 option(WITH_TESTING "Whether to compile with unittest." OFF)
 
 ############################# Options for Android cross compiling #########################
-option(WITH_OPENCV_STATIC "Use OpenCV static lib for Android." OFF)
-option(WITH_LITE_STATIC "Use Paddle Lite static lib for Android." OFF)
-option(WITH_OPENMP "Use OpenMP support for Android." OFF)
-
+if(ANDROID)
+  option(WITH_OPENCV_STATIC "Whether to use OpenCV static lib for Android." OFF)
+  option(WITH_LITE_STATIC "Whether to use OpenCV Paddle Lite static lib for Android." OFF)
+  option(WITH_FLYCV_STATIC "Whether to use OpenCV FlyCV static lib for Android." OFF)
+  option(WITH_OPENMP "Whether to use OpenCV OpenMP support for Android." OFF)
+  option(WITH_JAVA "Whether to build jni lib for Android." OFF)
+  option(WITH_STATIC_LIB "Whether to build FastDeploy static lib." OFF)
+endif()
 # Whether to build fastdeploy with vision/text/... examples, only for testings.
 option(BUILD_EXAMPLES "Whether to build fastdeploy with vision examples" OFF)
 
@@ -198,6 +202,9 @@ endif()
 
 if(ENABLE_LITE_BACKEND)
   add_definitions(-DENABLE_LITE_BACKEND)
+  if(WITH_LITE_STATIC)
+    add_definitions(-DWITH_LITE_STATIC)
+  endif()
   include(${PROJECT_SOURCE_DIR}/cmake/paddlelite.cmake)
   list(APPEND ALL_DEPLOY_SRCS ${DEPLOY_LITE_SRCS})
   list(APPEND DEPEND_LIBS external_paddle_lite)
@@ -372,7 +379,7 @@ if(ENABLE_VISION)
   if(ENABLE_FLYCV)
     add_definitions(-DENABLE_FLYCV)
     include(${PROJECT_SOURCE_DIR}/cmake/flycv.cmake)
-    list(APPEND DEPEND_LIBS external_flycv)
+    list(APPEND DEPEND_LIBS ${FLYCV_LIBRARIES})
   endif()
 
   if(ENABLE_CVCUDA)
@@ -402,7 +409,6 @@ if(ENABLE_PADDLE2ONNX)
   list(APPEND DEPEND_LIBS external_paddle2onnx)
 endif(ENABLE_PADDLE2ONNX)
 
-
 configure_file(${PROJECT_SOURCE_DIR}/FastDeploy.cmake.in ${PROJECT_SOURCE_DIR}/FastDeploy.cmake @ONLY)
 configure_file(${PROJECT_SOURCE_DIR}/python/fastdeploy/c_lib_wrap.py.in ${PROJECT_SOURCE_DIR}/python/fastdeploy/c_lib_wrap.py)
 configure_file(${PROJECT_SOURCE_DIR}/python/scripts/process_libraries.py.in ${PROJECT_SOURCE_DIR}/python/scripts/process_libraries.py)
@@ -454,16 +460,40 @@ endif()
 if(ANDROID)
   find_library(log-lib log)
   list(APPEND DEPEND_LIBS ${log-lib})
+  if(WITH_LITE_STATIC)
+    # need omp for static Paddle Lite lib
+    set(WITH_OPENMP ON CACHE BOOL "Force WITH_OPENMP=ON while WITH_LITE_STATIC=ON" FORCE) 
+    message(STATUS "Force WITH_OPENMP=${WITH_OPENMP} while WITH_LITE_STATIC=ON")
+  endif()
   if(WITH_OPENMP)
-    find_package(OpenMP)
-    if(OpenMP_CXX_FOUND)
-      list(APPEND DEPEND_LIBS OpenMP::OpenMP_CXX)
-    endif()
+    include(${PROJECT_SOURCE_DIR}/cmake/openmp.cmake)
   endif()
 endif()
 
 target_link_libraries(${LIBRARY_NAME} ${DEPEND_LIBS})
 
+################################ JNI & STATIC LIB: FastDeploy Android JNI & STATIC Lib ###############################
+if(ANDROID AND WITH_JAVA)
+  include(${PROJECT_SOURCE_DIR}/cmake/fastdeploy_jni.cmake)
+endif()
+
+if(ANDROID AND WITH_STATIC_LIB)
+  # Here, we use a dummy target (fastdelpoy_dummy) 
+  # to form a build dependency tree for fastdeploy_static lib.
+  add_library(fastdelpoy_dummy STATIC ${ALL_DEPLOY_SRCS})
+  # Still add ${DEPEND_LIBS} for cmake to form link_libraries 
+  # property tree for a static library. 
+  target_link_libraries(fastdelpoy_dummy ${DEPEND_LIBS})
+  # Build fastdelpoy_dummy when the third-party 
+  # libraries (opencv, paddle lite, flycv) are ready.
+  add_dependencies(fastdelpoy_dummy ${LIBRARY_NAME})
+  # Add WITH_STATIC_LIB compile definitions, see lite_backend.cc.
+  target_compile_definitions(fastdelpoy_dummy PRIVATE WITH_STATIC_LIB)
+  target_compile_definitions(fastdelpoy_dummy PRIVATE WITH_STATIC_LIB_AT_COMPILING)
+  bundle_static_library(fastdelpoy_dummy fastdeploy_static bundle_fastdeploy)
+endif()
+
+##################################### Examples ####################################
 if(WIN32)
   if(ENABLE_VISION)
     if("${CMAKE_GENERATOR}" STREQUAL "Ninja")
@@ -507,10 +537,34 @@ if(WIN32)
     RUNTIME DESTINATION lib
   )
 elseif(ANDROID)
-  install(
-    TARGETS ${LIBRARY_NAME}
-    LIBRARY DESTINATION lib/${ANDROID_ABI}
-  )
+  if(WITH_STATIC_LIB) 
+    install(
+      FILES 
+      ${CMAKE_CURRENT_BINARY_DIR}/libfastdeploy_static.a
+      DESTINATION lib/${ANDROID_ABI}
+    )
+  else()
+    install(
+      TARGETS ${LIBRARY_NAME}
+      LIBRARY DESTINATION lib/${ANDROID_ABI}
+    )
+  endif()
+  # Install omp into fastdeploy lib dir if WITH_OPENMP=ON 
+  # and WITH_LITE_STATIC=OFF.
+  if(WITH_OPENMP AND (NOT WITH_LITE_STATIC) AND OpenMP_CXX_FOUND AND ENABLE_OPENMP_SHARED)
+    install(
+      FILES 
+      ${OpenMP_CXX_LIBRARIES}
+      DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/${ANDROID_ABI}
+    )
+  endif()
+  # install Android JNI lib
+  if(WITH_JAVA)
+    install(
+      TARGETS fastdeploy_jni
+      LIBRARY DESTINATION jni/${ANDROID_ABI}
+    )
+  endif()
 else()
   install(
     TARGETS ${LIBRARY_NAME}
@@ -524,10 +578,70 @@ install(
   PATTERN "*.h"
   PATTERN "${PROJECT_SOURCE_DIR}/${CSRCS_DIR_NAME}/fastdeploy/runtime/backends/*/*.h"
 )
-install(
-  DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install
-  DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs
-)
+
+if(NOT ANDROID)
+  install(
+    DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install
+    DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs
+  )
+else()
+  # opencv/flycv always needs to be provided to users because our api
+  # explicitly depends on opencv's and flycv's api in headers.
+  # The headers and libs of opencv must be install.
+  if(ENABLE_VISION)
+    if(WITH_OPENCV_STATIC AND WITH_STATIC_LIB)
+      # Only need to install headers while building 
+      # FastDeploy static lib. (TODO:qiuyanjun)
+      install(
+        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/opencv/sdk/native/jni/include
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install/opencv/sdk/native/jni
+      )
+    else()
+      install(
+        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/opencv
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
+      )
+    endif()
+  endif()
+  # only need flycv's headers (may also install libs? TODO:qiuyanjun)
+  if(ENABLE_FLYCV)
+    if(WITH_FLYCV_STATIC)
+      install(
+        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/flycv/include
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install/flycv
+      )
+    else()
+      install(
+        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/flycv
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
+      )
+    endif()
+  endif()
+  # fast_tokenizer's static lib is not avaliable now! 
+  # may support some days later(TODO:qiuyanjun)
+  if(ENABLE_TEXT)
+    install(
+      DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/fast_tokenizer
+      DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
+    )
+  endif()  
+  # some libs may not to install while in static mode
+  if(ENABLE_LITE_BACKEND)
+    if(WITH_LITE_STATIC)
+      if(WITH_STATIC_LIB)
+        install(
+          DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/paddlelite/include
+          DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install/paddlelite
+        )
+      endif()
+    else()
+      install(
+        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/paddlelite
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
+      )
+    endif()
+  endif()
+endif()
 
 if(WIN32 AND BUILD_EXAMPLES)
   get_windows_path(_tmp_install_dir ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install)
@@ -550,13 +664,16 @@ install(
   ${PROJECT_SOURCE_DIR}/FastDeploy.cmake
   ${PROJECT_SOURCE_DIR}/cmake/FastDeployConfig.cmake
   ${PROJECT_SOURCE_DIR}/cmake/utils.cmake
+  ${PROJECT_SOURCE_DIR}/cmake/openmp.cmake
   DESTINATION ${CMAKE_INSTALL_PREFIX}
 )
 
-install(
-  DIRECTORY ${PROJECT_SOURCE_DIR}/examples
-  DESTINATION ${CMAKE_INSTALL_PREFIX}
-)
+if(NOT ANDROID)
+  install(
+    DIRECTORY ${PROJECT_SOURCE_DIR}/examples
+    DESTINATION ${CMAKE_INSTALL_PREFIX}
+  )
+endif()
 
 install(
   FILES ${PROJECT_SOURCE_DIR}/cmake/gflags.cmake
diff --git a/FastDeploy.cmake.in b/FastDeploy.cmake.in
old mode 100755
new mode 100644
index fd0370653e..f8285e36a6
--- a/FastDeploy.cmake.in
+++ b/FastDeploy.cmake.in
@@ -21,6 +21,9 @@ set(PADDLEINFERENCE_VERSION @PADDLEINFERENCE_VERSION@)
 set(OPENVINO_VERSION @OPENVINO_VERSION@)
 set(WITH_LITE_STATIC @WITH_LITE_STATIC@)
 set(WITH_OPENCV_STATIC @WITH_OPENCV_STATIC@)
+set(WITH_FLYCV_STATIC @WITH_FLYCV_STATIC@)
+set(WITH_OPENMP @WITH_OPENMP@)
+set(WITH_JAVA @WITH_JAVA@)
 set(OPENCV_FILENAME @OPENCV_FILENAME@)
 set(OPENVINO_FILENAME @OPENVINO_FILENAME@)
 set(PADDLELITE_FILENAME @PADDLELITE_FILENAME@)
@@ -30,6 +33,10 @@ set(ORT_DIRECTORY "@ORT_DIRECTORY@")
 set(OPENVINO_DIRECTORY "@OPENVINO_DIRECTORY@")
 set(RKNN2_TARGET_SOC "@RKNN2_TARGET_SOC@")
 set(WITH_KUNLUNXIN @WITH_KUNLUNXIN@)
+# Whether to use FastDeploy static lib. The default 
+# value for this option is determined by the SDK 
+# build-time options.
+set(WITH_STATIC_LIB @WITH_STATIC_LIB@)
 
 set(FASTDEPLOY_LIBS "")
 set(FASTDEPLOY_INCS "")
@@ -45,10 +52,38 @@ if(NOT MSVC)
   add_definitions(-D_GLIBCXX_USE_CXX11_ABI=1)
 endif(NOT MSVC)
 
+# Set FastDeploy static lib definitions
+if(WITH_LITE_STATIC)
+  add_definitions(-DWITH_LITE_STATIC)
+endif()
+
+if(WITH_STATIC_LIB)
+  add_definitions(-DWITH_STATIC_LIB)
+  # add_definitions(-DWITH_STATIC_WARNING)
+endif()
+
+# Still need omp while using FastDeploy static lib. 
+# This is due to the use of openmp for Paddle Lite's 
+# static library.
+if(ANDROID AND WITH_STATIC_LIB AND WITH_LITE_STATIC)
+  include(${CMAKE_CURRENT_LIST_DIR}/openmp.cmake)
+endif()
+
 if(ANDROID)
   add_library(fastdeploy STATIC IMPORTED GLOBAL)
-  set_property(TARGET fastdeploy PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/lib${LIBRARY_NAME}.so)
+  if(WITH_STATIC_LIB)
+    set_property(TARGET fastdeploy PROPERTY IMPORTED_LOCATION 
+                 ${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/lib${LIBRARY_NAME}_static.a)
+  else()
+    set_property(TARGET fastdeploy PROPERTY IMPORTED_LOCATION 
+                 ${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/lib${LIBRARY_NAME}.so)
+  endif()
   list(APPEND FASTDEPLOY_LIBS fastdeploy)
+  if(WITH_OPENMP AND (NOT WITH_LITE_STATIC))
+    add_library(fastdeploy_omp STATIC IMPORTED GLOBAL)
+    set_property(TARGET fastdeploy_omp PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/libomp.so)
+    list(APPEND FASTDEPLOY_LIBS fastdeploy_omp)
+  endif()
 else()
   find_library(FDLIB ${LIBRARY_NAME} ${CMAKE_CURRENT_LIST_DIR}/lib NO_DEFAULT_PATH)
   list(APPEND FASTDEPLOY_LIBS ${FDLIB})
@@ -108,7 +143,11 @@ endif()
 if(ENABLE_LITE_BACKEND)
   set(LITE_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${PADDLELITE_FILENAME})
   if(ANDROID)
-    if(NOT WITH_LITE_STATIC)
+    if(WITH_LITE_STATIC)
+      if(WITH_STATIC_LIB)
+        list(APPEND FASTDEPLOY_INCS ${LITE_DIR}/include)
+      endif()
+    else()
       add_library(paddle_full_api_shared STATIC IMPORTED GLOBAL)
       set_property(TARGET paddle_full_api_shared PROPERTY IMPORTED_LOCATION ${LITE_DIR}/lib/${ANDROID_ABI}/libpaddle_full_api_shared.so)
       list(APPEND FASTDEPLOY_LIBS paddle_full_api_shared)
@@ -169,6 +208,7 @@ if(ENABLE_VISION)
   else()
     if(ANDROID)
       set(OpenCV_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${OPENCV_FILENAME}/sdk/native/jni)
+      set(OpenCV_NATIVE_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${OPENCV_FILENAME}/sdk/native)
     else()
       set(OpenCV_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${OPENCV_FILENAME})
       if(WIN32)
@@ -179,9 +219,18 @@ if(ENABLE_VISION)
   message(STATUS "The path of OpenCV is ${OpenCV_DIR}.")
   if(ANDROID)
     if(WITH_OPENCV_STATIC)
-      find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
-      list(APPEND FASTDEPLOY_INCS ${OpenCV_INCLUDE_DIRS})
-      list(APPEND FASTDEPLOY_LIBS ${OpenCV_LIBS})
+      if(WITH_STATIC_LIB)
+        # Only need the headers of opencv while using FastDeploy static lib.
+        list(APPEND FASTDEPLOY_INCS ${OpenCV_DIR}/include)
+      else()
+        find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
+        list(APPEND FASTDEPLOY_INCS ${OpenCV_INCLUDE_DIRS})
+        # For now, we still need to link OpenCV static libs.
+        # Users may use some of opencv's apis, but they may 
+        # not have been compiled into fastdeploy.
+        # list(APPEND FASTDEPLOY_LIBS ${OpenCV_LIBS})
+        list(APPEND FASTDEPLOY_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
+      endif()
     else()
       set(OpenCV_INCLUDE_DIRS ${OpenCV_DIR}/include)
       get_filename_component(OpenCV_NATIVE_DIR ${OpenCV_DIR} DIRECTORY)
@@ -211,21 +260,38 @@ if(ENABLE_VISION)
     include_directories(${CMAKE_CURRENT_LIST_DIR}/third_libs/install/flycv/include)
     set(FLYCV_LIB_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/flycv/lib)
     if(ANDROID)
-      add_library(flycv_shared STATIC IMPORTED GLOBAL)
-      set_property(TARGET flycv_shared PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libflycv_shared.so)
-      list(APPEND FASTDEPLOY_LIBS flycv_shared)
+      if(NOT WITH_FLYCV_STATIC)
+        add_library(flycv_shared STATIC IMPORTED GLOBAL)
+        set_property(TARGET flycv_shared PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libflycv_shared.so)
+        list(APPEND FASTDEPLOY_LIBS flycv_shared)
+      else()  
+        # This code may be needed later. Therefore, I choose to 
+        # comment it rather than delete it. (TODO:qiuyanjun)
+        # add_library(flycv_static STATIC IMPORTED GLOBAL)
+        # add_library(flycv_png16 STATIC IMPORTED GLOBAL)
+        # add_library(flycv_turbojpeg STATIC IMPORTED GLOBAL)
+        # add_library(flycv_z STATIC IMPORTED GLOBAL)
+        # set_property(TARGET flycv_static PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libflycv_static.a)
+        # set_property(TARGET flycv_png16 PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libpng16.a)
+        # set_property(TARGET flycv_turbojpeg PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libturbojpeg.a) 
+        # set_property(TARGET flycv_z PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libz.a)  
+        # list(APPEND FASTDEPLOY_LIBS flycv_static)
+        # list(APPEND FASTDEPLOY_LIBS flycv_png16) 
+        # list(APPEND FASTDEPLOY_LIBS flycv_turbojpeg) 
+        # list(APPEND FASTDEPLOY_LIBS flycv_z)        
+      endif()
     else()
       find_library(FLYCV_LIB flycv_shared ${FLYCV_LIB_DIR} NO_DEFAULT_PATH)
       list(APPEND FASTDEPLOY_LIBS ${FLYCV_LIB})
     endif()
   endif()
-
+  
   if(ENABLE_CVCUDA)
     find_library(CVCUDA_LIB cvcuda ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/cvcuda/lib NO_DEFAULT_PATH)
     find_library(NVCV_TYPES_LIB nvcv_types ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/cvcuda/lib NO_DEFAULT_PATH)
     list(APPEND FASTDEPLOY_LIBS ${CVCUDA_LIB} ${NVCV_TYPES_LIB})
   endif()
-
+  
 endif()
 
 if (ENABLE_TEXT)
@@ -258,13 +324,19 @@ if(WITH_KUNLUNXIN)
   list(APPEND FASTDEPLOY_LIBS -lpthread -lrt -ldl)
 endif()
 
-
 # log lib for Android
 if(ANDROID)
   find_library(log-lib log)
   list(APPEND FASTDEPLOY_LIBS ${log-lib})
 endif()
 
+# Update CXX LINKER's FLAGS, reference: https://zhuanlan.zhihu.com/p/595527528
+if(ANDROID AND (WITH_OPENCV_STATIC OR WITH_LITE_STATIC))
+  set(COMMON_LINK_FLAGS_REL "-Wl,-s,--gc-sections,-exclude-libs,ALL")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${COMMON_LINK_FLAGS_REL} -Wl,-allow-multiple-definition" CACHE INTERNAL "" FORCE)
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${COMMON_LINK_FLAGS_REL} -Wl,-allow-multiple-definition" CACHE INTERNAL "" FORCE)
+endif()
+
 remove_duplicate_libraries(FASTDEPLOY_LIBS)
 
 # Print compiler information
@@ -276,6 +348,14 @@ message(STATUS "  System                    : ${CMAKE_SYSTEM_NAME}")
 message(STATUS "  C++ compiler              : ${CMAKE_CXX_COMPILER}")
 message(STATUS "  C++ compiler version      : ${CMAKE_CXX_COMPILER_VERSION}")
 message(STATUS "  CXX flags                 : ${CMAKE_CXX_FLAGS}")
+message(STATUS "  EXE linker flags          : ${CMAKE_EXE_LINKER_FLAGS}")
+message(STATUS "  Shared linker flags       : ${CMAKE_SHARED_LINKER_FLAGS}")
+get_directory_property(tmp DIRECTORY ${PROJECT_SOURCE_DIR} COMPILE_DEFINITIONS)
+message(STATUS "  Compile definitions       : ${tmp}")
+message(STATUS "  CMAKE_PREFIX_PATH         : ${CMAKE_PREFIX_PATH}")
+message(STATUS "  CMAKE_INSTALL_PREFIX      : ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "  CMAKE_MODULE_PATH         : ${CMAKE_MODULE_PATH}")
+message(STATUS "")
 message(STATUS "  WITH_GPU                  : ${WITH_GPU}")
 message(STATUS "  ENABLE_ORT_BACKEND        : ${ENABLE_ORT_BACKEND}")
 message(STATUS "  ENABLE_RKNPU2_BACKEND     : ${ENABLE_RKNPU2_BACKEND}")
@@ -308,18 +388,23 @@ endif()
 if(ORT_DIRECTORY)
   message(STATUS "  ORT_DIRECTORY             : ${ORT_DIRECTORY}")
 endif()
-if (OPENVINO_DIRECTORY)
+if(OPENVINO_DIRECTORY)
   message(STATUS "  OPENVINO_DIRECTORY        : ${OPENVINO_DIRECTORY}")
 endif()
 if(ANDROID)
   message(STATUS "  ANDROID_ABI               : ${ANDROID_ABI}")
   message(STATUS "  ANDROID_PLATFORM          : ${ANDROID_PLATFORM}")
   message(STATUS "  ANDROID_NDK               : ${ANDROID_NDK}")
+  message(STATUS "  ANDROID_NDK_MAJOR         : ${ANDROID_NDK_MAJOR}")
+  message(STATUS "  WITH_STATIC_LIB:          : ${WITH_STATIC_LIB}")
   message(STATUS "  WITH_OPENCV_STATIC:       : ${WITH_OPENCV_STATIC}")
+  message(STATUS "  WITH_FLYCV_STATIC:        : ${WITH_FLYCV_STATIC}")
   if(ENABLE_LITE_BACKEND)
     message(STATUS "  WITH_LITE_STATIC          : ${WITH_LITE_STATIC}")
   endif()
-endif()
+  message(STATUS "  WITH_OPENMP:              : ${WITH_OPENMP}")
+  message(STATUS "  WITH_JAVA:                : ${WITH_JAVA}")
+endif() 
 message(STATUS "  DEPENDENCY_LIBS           : ${FASTDEPLOY_LIBS}")
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -330,6 +415,11 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 endif()
 
 function(install_fastdeploy_libraries DESTINATION_DIR)
+  # No dynamic libs need to install while using 
+  # FastDeploy static lib.
+  if(WITH_STATIC_LIB)
+    return()
+  endif()
   set(DYN_LIB_SUFFIX "*.so*")
   if(WIN32)
     set(DYN_LIB_SUFFIX "*.dll")
@@ -343,28 +433,48 @@ function(install_fastdeploy_libraries DESTINATION_DIR)
   else()
     message(FATAL_ERROR "Please set FastDeploy_DIR/FASTDEPLOY_INSTALL_DIR before call install_fastdeploy_libraries.")
   endif()
-  file(GLOB_RECURSE ALL_NEED_DYN_LIBS ${DYN_SEARCH_DIR}/${DYN_LIB_SUFFIX})
+  file(GLOB_RECURSE ALL_NEED_DYN_LIBS ${DYN_SEARCH_DIR}/lib/${DYN_LIB_SUFFIX})
+  file(GLOB_RECURSE ALL_DEPS_DYN_LIBS ${DYN_SEARCH_DIR}/third_libs/${DYN_LIB_SUFFIX})
+
   if(ENABLE_VISION)
-    file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_DIR}/${DYN_LIB_SUFFIX})
-    list(REMOVE_ITEM ALL_NEED_DYN_LIBS ${ALL_OPENCV_DYN_LIBS})
-    # Only Install the necessary libraries
+    # OpenCV
+    if(ANDROID)
+      file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_NATIVE_DIR}/libs/${DYN_LIB_SUFFIX})
+    else()
+      file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_DIR}/${DYN_LIB_SUFFIX})
+    endif()  
+    list(REMOVE_ITEM ALL_DEPS_DYN_LIBS ${ALL_OPENCV_DYN_LIBS})
+  
     if(NOT WITH_OPENCV_STATIC)
       if(WIN32)
         file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/x64/vc15/bin/${DYN_LIB_SUFFIX})
       elseif(ANDROID)
-        file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/libs/${ANDROID_ABI}/${DYN_LIB_SUFFIX})
+        file(GLOB OPENCV_DYN_LIBS ${OpenCV_NATIVE_DIR}/libs/${ANDROID_ABI}/${DYN_LIB_SUFFIX})
       else() # linux/mac
         file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/lib/${DYN_LIB_SUFFIX})
       endif()
       file(INSTALL ${OPENCV_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
     endif()
+
+    # FlyCV
+    if(ENABLE_FLYCV)
+      file(GLOB_RECURSE ALL_FLYCV_DYN_LIBS ${FLYCV_LIB_DIR}/${DYN_LIB_SUFFIX})
+      list(REMOVE_ITEM ALL_DEPS_DYN_LIBS ${ALL_FLYCV_DYN_LIBS})
+      if(NOT WITH_FLYCV_STATIC)
+        file(INSTALL ${ALL_FLYCV_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
+      endif()
+    endif()
+
   endif()
+
   if(ENABLE_OPENVINO_BACKEND)
     # need plugins.xml for openvino backend
     set(OPENVINO_RUNTIME_BIN_DIR ${OPENVINO_DIR}/bin)
     file(GLOB OPENVINO_PLUGIN_XML ${OPENVINO_RUNTIME_BIN_DIR}/*.xml)
     file(INSTALL ${OPENVINO_PLUGIN_XML} DESTINATION ${DESTINATION_DIR})
   endif()
+
   # Install other libraries
   file(INSTALL ${ALL_NEED_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
+  file(INSTALL ${ALL_DEPS_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
 endfunction()
diff --git a/cmake/fastdeploy_jni.cmake b/cmake/fastdeploy_jni.cmake
new file mode 100644
index 0000000000..36989506dc
--- /dev/null
+++ b/cmake/fastdeploy_jni.cmake
@@ -0,0 +1,52 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+if(WITH_JAVA)
+  set(JNI_SRCS_FOUND OFF)
+  if(NOT ANDROID)
+    message(FATAL_ERROR "Only support jni lib for Android now!")
+  else()
+    set(JNI_SRCS_DIR "${PROJECT_SOURCE_DIR}/java/android/fastdeploy/src/main/cpp")
+    include_directories(${JNI_SRCS_DIR})
+    file(GLOB JNI_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/*.cc)
+    file(GLOB JNI_VISION_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/vision/*.cc)
+    file(GLOB JNI_PIPELINE_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/pipeline/*.cc)
+    file(GLOB JNI_TEXT_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/text/*.cc)
+    list(APPEND JNI_SRCS ${JNI_VISION_SRCS} ${JNI_PIPELINE_SRCS} ${JNI_TEXT_SRCS})
+    set(JNI_SRCS_FOUND ON CACHE BOOL "JNI SRCS Flags" FORCE)
+  endif()
+  if(JNI_SRCS_FOUND)
+    # Here, we use a dummy target (fastdelpoy_dummy) 
+    # to form a build dependency tree for fastdeploy_jni lib.
+    add_library(fastdelpoy_jni_dummy STATIC ${ALL_DEPLOY_SRCS})
+    # Build fastdelpoy_jni_dummy when the third-party 
+    # libraries (opencv, paddle lite, flycv) are ready.
+    add_dependencies(fastdelpoy_jni_dummy ${LIBRARY_NAME})
+    target_compile_definitions(fastdelpoy_jni_dummy PRIVATE WITH_JAVA)
+    if(TARGET fastdelpoy_jni_dummy)
+      add_library(fastdeploy_jni SHARED ${JNI_SRCS})
+      target_link_libraries(fastdeploy_jni fastdelpoy_jni_dummy ${DEPEND_LIBS} 
+                            jnigraphics GLESv2 EGL)
+      add_dependencies(fastdeploy_jni fastdelpoy_jni_dummy)  
+      # Strip debug C++ symbol table
+      set_target_properties(fastdeploy_jni PROPERTIES COMPILE_FLAGS 
+          "-fvisibility=hidden -fvisibility-inlines-hidden -fdata-sections -ffunction-sections")
+      set_target_properties(fastdeploy_jni PROPERTIES LINK_FLAGS ${COMMON_LINK_FLAGS})
+      set_target_properties(fastdeploy_jni PROPERTIES LINK_FLAGS_RELEASE ${COMMON_LINK_FLAGS_REL})
+      set_target_properties(fastdeploy_jni PROPERTIES LINK_FLAGS_MINSIZEREL ${COMMON_LINK_FLAGS_REL}) 
+    endif()
+  else()
+    message(FATAL_ERROR "Can not found Android JNI_SRCS!")  
+  endif()
+endif()
diff --git a/cmake/flycv.cmake b/cmake/flycv.cmake
index d1e63d1049..3352456357 100755
--- a/cmake/flycv.cmake
+++ b/cmake/flycv.cmake
@@ -54,9 +54,15 @@ elseif(APPLE)
       "${FLYCV_INSTALL_DIR}/lib/libflycv.dylib"
       CACHE FILEPATH "flycv compile library." FORCE)      
 elseif(ANDROID)
-  set(FLYCV_COMPILE_LIB
-  "${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libflycv_shared.so"
-  CACHE FILEPATH "flycv compile library." FORCE)   
+  if(WITH_FLYCV_STATIC)
+    set(FLYCV_COMPILE_LIB
+    "${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libflycv_static.a"
+    CACHE FILEPATH "flycv compile library." FORCE)   
+  else()
+    set(FLYCV_COMPILE_LIB
+    "${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libflycv_shared.so"
+    CACHE FILEPATH "flycv compile library." FORCE)  
+  endif()  
 else()
   set(FLYCV_COMPILE_LIB
       "${FLYCV_INSTALL_DIR}/lib/libflycv_shared.so"
@@ -134,3 +140,22 @@ add_library(external_flycv STATIC IMPORTED GLOBAL)
 set_property(TARGET external_flycv PROPERTY IMPORTED_LOCATION
                                          ${FLYCV_COMPILE_LIB})
 add_dependencies(external_flycv ${FLYCV_PROJECT})
+
+set(FLYCV_LIBRARIES external_flycv)
+if(ANDROID AND WITH_FLYCV_STATIC)
+  add_library(external_flycv_png16 STATIC IMPORTED GLOBAL)
+  add_library(external_flycv_turbojpeg STATIC IMPORTED GLOBAL)
+  add_library(external_flycv_z STATIC IMPORTED GLOBAL)
+  set_property(TARGET external_flycv_png16 PROPERTY IMPORTED_LOCATION
+              "${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libpng16.a")
+  set_property(TARGET external_flycv_turbojpeg PROPERTY IMPORTED_LOCATION
+              "${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libturbojpeg.a") 
+  set_property(TARGET external_flycv_z PROPERTY IMPORTED_LOCATION
+              "${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libz.a")  
+  add_dependencies(external_flycv_png16 ${FLYCV_PROJECT})      
+  add_dependencies(external_flycv_turbojpeg ${FLYCV_PROJECT})
+  add_dependencies(external_flycv_z ${FLYCV_PROJECT})  
+  list(APPEND FLYCV_LIBRARIES external_flycv_png16) 
+  list(APPEND FLYCV_LIBRARIES external_flycv_turbojpeg) 
+  list(APPEND FLYCV_LIBRARIES external_flycv_z)                           
+endif()
\ No newline at end of file
diff --git a/cmake/opencv.cmake b/cmake/opencv.cmake
index 5103a69d98..9968c129c8 100755
--- a/cmake/opencv.cmake
+++ b/cmake/opencv.cmake
@@ -118,7 +118,8 @@ if(OPENCV_DIRECTORY)
       set(OpenCV_DIR ${OPENCV_DIRECTORY})
       find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
       include_directories(${OpenCV_INCLUDE_DIRS})
-      list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+      # list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+      list(APPEND DEPEND_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
     else()
       set(OpenCV_INCLUDE_DIRS ${OPENCV_DIRECTORY}/include)
       get_filename_component(OpenCV_NATIVE_DIR ${OPENCV_DIRECTORY} DIRECTORY)
@@ -151,7 +152,8 @@ else()
       remove_redundant_opencv_android_abi_libraries(${OpenCV_DIR})
       find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
       include_directories(${OpenCV_INCLUDE_DIRS})
-      list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+      # list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+      list(APPEND DEPEND_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
     else()
       # Installing OpenCV shared lib to FastDeploy third_libs/install dir.
       download_and_decompress(${OPENCV_URL} ${CMAKE_CURRENT_BINARY_DIR}/${OPENCV_FILENAME}${COMPRESSED_SUFFIX} ${THIRD_PARTY_PATH}/install)
diff --git a/cmake/openmp.cmake b/cmake/openmp.cmake
new file mode 100644
index 0000000000..115a0db0e2
--- /dev/null
+++ b/cmake/openmp.cmake
@@ -0,0 +1,72 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+if(NOT WITH_OPENMP)
+ message(FATAL_ERROR "Please set WITH_OPENMP=ON before inclue openmp.cmake")
+endif()
+
+if(ANDROID)
+
+  if(NOT ANDROID_TOOLCHAIN MATCHES "clang")
+     message(FATAL_ERROR "Currently, only support clang toolchain while cross compiling FastDeploy for Android with OpenMP support, but found ${ANDROID_TOOLCHAIN}.")
+  endif()  
+
+  find_package(OpenMP REQUIRED)
+  set(ENABLE_OPENMP_SHARED ON CACHE BOOL "" FORCE)
+  if(WITH_LITE_STATIC)
+    # Can use static/shared omp lib if WITH_LITE_STATIC=ON
+    if(OPENMP_FOUND OR OpenMP_CXX_FOUND)
+      add_definitions(-DWITH_OPENMP)
+      if(${ANDROID_NDK_MAJOR})
+        if(${ANDROID_NDK_MAJOR} GREATER 20)
+          set(ENABLE_OPENMP_SHARED OFF CACHE BOOL "" FORCE)
+          message(STATUS "ANDROID_NDK_MAJOR ${ANDROID_NDK_MAJOR} GREATER 20")
+          set(OPENMP_LINK_FLAGS "-fopenmp -static-openmp")
+        else()
+          set(OPENMP_LINK_FLAGS "-fopenmp")
+        endif()  
+      endif()
+    else()
+      message(FATAL_ERROR "Could not found OpenMP!")  
+    endif()
+  else()
+    if(OPENMP_FOUND OR OpenMP_CXX_FOUND)
+      add_definitions(-DWITH_OPENMP)
+      # Can only use shared omp lib if WITH_LITE_STATIC=OFF
+      set(OPENMP_LINK_FLAGS "-fopenmp")
+    else()
+      message(FATAL_ERROR "Could not found OpenMP!")  
+    endif()  
+  endif()
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENMP_LINK_FLAGS}")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${OPENMP_LINK_FLAGS}")
+  message(STATUS "Found OpenMP ${OpenMP_VERSION} ${OpenMP_CXX_VERSION}")
+  message(STATUS "OpenMP C flags:  ${OpenMP_C_FLAGS}")
+  message(STATUS "OpenMP CXX flags:  ${OpenMP_CXX_FLAGS}")
+  message(STATUS "OpenMP EXE LINKER flags:  ${OPENMP_LINK_FLAGS}")
+  message(STATUS "OpenMP OpenMP_CXX_LIB_NAMES:  ${OpenMP_CXX_LIB_NAMES}")
+  message(STATUS "OpenMP OpenMP_CXX_LIBRARIES:  ${OpenMP_CXX_LIBRARIES}")
+  message(STATUS "ENABLE_OPENMP_SHARED: ${ENABLE_OPENMP_SHARED}")
+
+elseif(WIN32)
+  message(FATAL_ERROR "WITH_OPENMP=ON option is not support for WIN32 now!")
+elseif(APPLE)
+  message(FATAL_ERROR "WITH_OPENMP=ON option is not support for APPLE now!")
+elseif(IOS)
+  message(FATAL_ERROR "WITH_OPENMP=ON option is not support for IOS now!")  
+else()
+  message(FATAL_ERROR "WITH_OPENMP=ON option is not support for Linux now!")
+endif()
diff --git a/cmake/paddlelite.cmake b/cmake/paddlelite.cmake
index d546cbf38f..2f8f26d9bb 100755
--- a/cmake/paddlelite.cmake
+++ b/cmake/paddlelite.cmake
@@ -37,9 +37,6 @@ set(CMAKE_BUILD_RPATH "${CMAKE_BUILD_RPATH}" "${PADDLELITE_LIB_DIR}")
 set(PADDLELITE_URL_PREFIX "https://bj.bcebos.com/fastdeploy/third_libs")
 
 if(ANDROID)
-  if(WITH_LITE_STATIC)
-      message(FATAL_ERROR "Doesn't support WTIH_LITE_STATIC=ON for Paddle Lite now.")
-  endif()  
   # check ABI, toolchain
   if((NOT ANDROID_ABI MATCHES "armeabi-v7a") AND (NOT ANDROID_ABI MATCHES "arm64-v8a"))
     message(FATAL_ERROR "FastDeploy with Paddle Lite only support armeabi-v7a, arm64-v8a now.")
@@ -53,9 +50,9 @@ if(NOT PADDLELITE_URL)
   if(WIN32 OR APPLE OR IOS)
     message(FATAL_ERROR "Doesn't support windows/mac/ios platform with backend Paddle Lite now.")
   elseif(ANDROID)
-    set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-latest-dev.tgz")
+    set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-latest-dev1.tgz")
     if(ANDROID_ABI MATCHES "arm64-v8a") 
-      set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-fp16-latest-dev.tgz")
+      set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-fp16-latest-dev1.tgz")
     endif()  
   else() # Linux
     if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
@@ -70,10 +67,10 @@ if(WIN32 OR APPLE OR IOS)
   message(FATAL_ERROR "Doesn't support windows/mac/ios platform with backend Paddle Lite now.")
 elseif(ANDROID AND WITH_LITE_STATIC)
   set(PADDLELITE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_api_full_bundled.a")
-  set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_api_light_bundled.a")
+  set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_full_api_shared.so")
 else()
   set(PADDLELITE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_full_api_shared.so")
-  set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_light_api_shared.so")
+  set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_api_full_bundled.a")
 endif()
 
 include_directories(${PADDLELITE_INC_DIR})
diff --git a/cmake/summary.cmake b/cmake/summary.cmake
index adfa515e3a..faaacb4174 100755
--- a/cmake/summary.cmake
+++ b/cmake/summary.cmake
@@ -21,6 +21,8 @@ function(fastdeploy_summary)
   message(STATUS "  C++ compiler              : ${CMAKE_CXX_COMPILER}")
   message(STATUS "  C++ compiler version      : ${CMAKE_CXX_COMPILER_VERSION}")
   message(STATUS "  CXX flags                 : ${CMAKE_CXX_FLAGS}")
+  message(STATUS "  EXE linker flags          : ${CMAKE_EXE_LINKER_FLAGS}")
+  message(STATUS "  Shared linker flags       : ${CMAKE_SHARED_LINKER_FLAGS}")
   message(STATUS "  Build type                : ${CMAKE_BUILD_TYPE}")
   get_directory_property(tmp DIRECTORY ${PROJECT_SOURCE_DIR} COMPILE_DEFINITIONS)
   message(STATUS "  Compile definitions       : ${tmp}")
@@ -64,13 +66,15 @@ function(fastdeploy_summary)
     message(STATUS "  ANDROID_ABI               : ${ANDROID_ABI}")
     message(STATUS "  ANDROID_PLATFORM          : ${ANDROID_PLATFORM}")
     message(STATUS "  ANDROID_NDK               : ${ANDROID_NDK}")
-    message(STATUS "  ANDROID_NDK_VERSION       : ${CMAKE_ANDROID_NDK_VERSION}")
+    message(STATUS "  ANDROID_NDK_MAJOR         : ${ANDROID_NDK_MAJOR}")
+    message(STATUS "  WITH_STATIC_LIB:          : ${WITH_STATIC_LIB}")
     message(STATUS "  WITH_OPENCV_STATIC:       : ${WITH_OPENCV_STATIC}")
+    message(STATUS "  WITH_FLYCV_STATIC:        : ${WITH_FLYCV_STATIC}")
     if(ENABLE_LITE_BACKEND)
       message(STATUS "  WITH_LITE_STATIC          : ${WITH_LITE_STATIC}")
-      message(STATUS "  WITH_LITE_FULL_API        : ${WITH_LITE_FULL_API}")
-      message(STATUS "  WITH_LITE_FP16            : ${WITH_LITE_FP16}")
     endif()
+    message(STATUS "  WITH_OPENMP:              : ${WITH_OPENMP}")
+    message(STATUS "  WITH_JAVA:                : ${WITH_JAVA}")
   endif() 
   if (${BUILD_FASTDEPLOY_PYTHON})
     message(STATUS "  Python executable         : ${PYTHON_EXECUTABLE}")
diff --git a/cmake/utils.cmake b/cmake/utils.cmake
index dd61150a26..bb51a79ba5 100644
--- a/cmake/utils.cmake
+++ b/cmake/utils.cmake
@@ -73,3 +73,149 @@ function(get_osx_architecture)
     set(CURRENT_OSX_ARCH ${CMAKE_HOST_SYSTEM_PROCESSOR} PARENT_SCOPE)
   endif()
 endfunction()
+
+
+# A fake target to include all the libraries and tests the fastdeploy module depends.
+add_custom_target(fd_compile_deps COMMAND echo 1)
+
+# A function to grep LINK_ONLY dependencies from INTERFACE_LINK_LIBRARIES
+function(regrex_link_only_libraries OUTPUT_DEPS PUBLIC_DEPS)
+  string(JOIN "#" _public_deps ${PUBLIC_DEPS})
+  string(REPLACE "$<LINK_ONLY:" "" _public_deps ${_public_deps})
+  string(REPLACE ">" "" _public_deps ${_public_deps})
+  string(REPLACE "#" ";" _public_deps ${_public_deps})
+  set(${OUTPUT_DEPS} ${_public_deps} PARENT_SCOPE)
+endfunction()
+
+# Bundle several static libraries into one. This function is modified from Paddle Lite. 
+# reference: https://github.com/PaddlePaddle/Paddle-Lite/blob/develop/cmake/lite.cmake#L252
+function(bundle_static_library tgt_name bundled_tgt_name fake_target)
+  list(APPEND static_libs ${tgt_name})
+  add_dependencies(fd_compile_deps ${fake_target})
+  # Set redundant static libs here, protobuf is already available 
+  # in the Paddle Lite static library. So, we don't need protobuf 
+  # in opencv. And there is no need for opencv_dnn, opencv_ml, 
+  # opencv_flann and some other modules. Therefore, we chose
+  # to discard these redundant modules.
+  set(REDUNDANT_STATIC_LIBS opencv_dnn opencv_calib3d opencv_photo 
+      opencv_flann opencv_objdetect opencv_stitching opencv_gapi 
+      opencv_ml libprotobuf)
+
+  function(_recursively_collect_dependencies input_target)
+    list(FIND REDUNDANT_STATIC_LIBS ${input_target} _input_redunant_id)
+    if(${_input_redunant_id} GREATER 0)
+      return()
+    endif()
+    set(_input_link_libraries LINK_LIBRARIES)
+    # https://cmake.org/cmake/help/latest/prop_tgt/TYPE.html
+    get_target_property(_input_type ${input_target} TYPE)
+    # In OpenCVModules.cmake, they set the deps of modules
+    # (opencv_core,...) as INTERFACE_LINK_LIBRARIES. The 
+    # 'Type' of opencv static lib is set as 'STATIC_LIBRARY'.
+    if ((${_input_type} STREQUAL "INTERFACE_LIBRARY")
+         OR (${_input_type} STREQUAL "STATIC_LIBRARY"))
+      set(_input_link_libraries INTERFACE_LINK_LIBRARIES)
+    endif()
+    get_target_property(_public_dependencies ${input_target} ${_input_link_libraries})
+    regrex_link_only_libraries(public_dependencies "${_public_dependencies}")
+    
+    foreach(dependency IN LISTS public_dependencies)
+      if(TARGET ${dependency})
+        get_target_property(alias ${dependency} ALIASED_TARGET)
+        if (TARGET ${alias})
+          set(dependency ${alias})
+        endif()
+        get_target_property(_type ${dependency} TYPE)
+        list(FIND REDUNDANT_STATIC_LIBS ${dependency} _deps_redunant_id)
+        if (${_type} STREQUAL "STATIC_LIBRARY" AND 
+            (NOT (${_deps_redunant_id} GREATER 0)))
+          list(APPEND static_libs ${dependency})
+        endif()
+
+        get_property(library_already_added
+          GLOBAL PROPERTY _${tgt_name}_static_bundle_${dependency})
+        if (NOT library_already_added)
+          set_property(GLOBAL PROPERTY _${tgt_name}_static_bundle_${dependency} ON)
+          if(NOT (${_deps_redunant_id} GREATER 0))
+            _recursively_collect_dependencies(${dependency})
+          endif()
+        endif()
+      endif()
+    endforeach()
+    set(static_libs ${static_libs} PARENT_SCOPE)
+  endfunction()
+
+  _recursively_collect_dependencies(${tgt_name})
+
+  list(REMOVE_DUPLICATES static_libs)
+  list(REMOVE_ITEM static_libs ${REDUNDANT_STATIC_LIBS})
+  message(STATUS "WITH_STATIC_LIB=${WITH_STATIC_LIB}, Found all needed static libs from dependecy tree: ${static_libs}")
+  message(STATUS "Exclude some redundant static libs: ${REDUNDANT_STATIC_LIBS}")
+
+  set(bundled_tgt_full_name
+    ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${bundled_tgt_name}${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+  message(STATUS "Use bundled_tgt_full_name:  ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${bundled_tgt_name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+  if(WIN32)
+    message(FATAL_ERROR "Not support FastDeploy static lib for windows now.")
+  endif()
+
+  add_custom_target(${fake_target} ALL COMMAND ${CMAKE_COMMAND} -E echo "Building fake_target ${fake_target}")
+  add_dependencies(${fake_target} ${tgt_name})
+  # add_dependencies(${fake_target} fastdelpoy_dummy)
+
+  if(NOT IOS AND NOT APPLE)
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in
+      "CREATE ${bundled_tgt_full_name}\n" )
+
+    foreach(tgt IN LISTS static_libs)
+      file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in
+        "ADDLIB $<TARGET_FILE:${tgt}>\n")
+    endforeach()
+
+    file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in "SAVE\n")
+    file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in "END\n")
+
+    file(GENERATE
+      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar
+      INPUT ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in)
+
+    set(ar_tool ${CMAKE_AR})
+    if (CMAKE_INTERPROCEDURAL_OPTIMIZATION)
+      set(ar_tool ${CMAKE_CXX_COMPILER_AR})
+    endif()
+    message(STATUS "Found ar_tool: ${ar_tool}")
+
+    add_custom_command(
+      TARGET ${fake_target} PRE_BUILD
+      COMMAND rm -f ${bundled_tgt_full_name}
+      COMMAND ${ar_tool} -M < ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar
+      COMMENT "Bundling ${bundled_tgt_name}"
+      COMMAND ${CMAKE_STRIP} --strip-unneeded ${CMAKE_CURRENT_BINARY_DIR}/lib${bundled_tgt_name}.a
+      COMMENT "Stripped unneeded debug symbols in ${bundled_tgt_name}"
+      DEPENDS ${tgt_name}
+      VERBATIM)
+  else()
+    foreach(lib ${static_libs})
+      set(libfiles ${libfiles} $<TARGET_FILE:${lib}>)
+    endforeach()
+    add_custom_command(
+      TARGET ${fake_target} PRE_BUILD
+      COMMAND rm -f ${bundled_tgt_full_name}
+      COMMAND /usr/bin/libtool -static -o ${bundled_tgt_full_name} ${libfiles}
+      COMMENT "Bundling ${bundled_tgt_name}"
+      COMMAND ${CMAKE_STRIP} -S ${CMAKE_CURRENT_BINARY_DIR}/lib${bundled_tgt_name}.a
+      COMMENT "Stripped unneeded debug symbols in ${bundled_tgt_name}"
+      DEPENDS ${tgt_name}
+    )
+  endif()
+
+  add_library(${bundled_tgt_name} STATIC IMPORTED GLOBAL)
+  set_property(TARGET ${bundled_tgt_name} PROPERTY IMPORTED_LOCATION
+                                         ${bundled_tgt_full_name})          
+  add_dependencies(${bundled_tgt_name} ${fake_target})
+  add_dependencies(${bundled_tgt_name} ${tgt_name})
+
+endfunction()
+
diff --git a/fastdeploy/core/fd_tensor.cc b/fastdeploy/core/fd_tensor.cc
index e84535ac90..533e58fd8b 100644
--- a/fastdeploy/core/fd_tensor.cc
+++ b/fastdeploy/core/fd_tensor.cc
@@ -353,33 +353,35 @@ FDTensor::FDTensor(const char* tensor_name) { name = tensor_name; }
 FDTensor::FDTensor(const Scalar& scalar) {
   Allocate({1}, scalar.dtype());
   switch (scalar.dtype()) {
-  case FDDataType::BOOL:
-    (reinterpret_cast<bool*>(Data()))[0] = scalar.to<bool>();
-    break;
-  case FDDataType::UINT8:
-    (reinterpret_cast<uint8_t*>(Data()))[0] = scalar.to<uint8_t>();
-    break;
-  case FDDataType::INT8:
-    (reinterpret_cast<int8_t*>(Data()))[0] = scalar.to<int8_t>();
-    break;
-  case FDDataType::INT16:
-    (reinterpret_cast<int16_t*>(Data()))[0] = scalar.to<int16_t>();
-    break;
-  case FDDataType::INT32:
-    (reinterpret_cast<int*>(Data()))[0] = scalar.to<int>();
-    break;
-  case FDDataType::INT64:
-    (reinterpret_cast<int64_t*>(Data()))[0] = scalar.to<int64_t>();
-    break;
-  case FDDataType::FP16:
-    (reinterpret_cast<float16*>(Data()))[0] = scalar.to<float16>();
-    break;
-  case FDDataType::FP32:
-    (reinterpret_cast<float*>(Data()))[0] = scalar.to<float>();
-    break;
-  case FDDataType::FP64:
-    (reinterpret_cast<double*>(Data()))[0] = scalar.to<double>();
-    break;
+    case FDDataType::BOOL:
+      (reinterpret_cast<bool*>(Data()))[0] = scalar.to<bool>();
+      break;
+    case FDDataType::UINT8:
+      (reinterpret_cast<uint8_t*>(Data()))[0] = scalar.to<uint8_t>();
+      break;
+    case FDDataType::INT8:
+      (reinterpret_cast<int8_t*>(Data()))[0] = scalar.to<int8_t>();
+      break;
+    case FDDataType::INT16:
+      (reinterpret_cast<int16_t*>(Data()))[0] = scalar.to<int16_t>();
+      break;
+    case FDDataType::INT32:
+      (reinterpret_cast<int*>(Data()))[0] = scalar.to<int>();
+      break;
+    case FDDataType::INT64:
+      (reinterpret_cast<int64_t*>(Data()))[0] = scalar.to<int64_t>();
+      break;
+    case FDDataType::FP16:
+      (reinterpret_cast<float16*>(Data()))[0] = scalar.to<float16>();
+      break;
+    case FDDataType::FP32:
+      (reinterpret_cast<float*>(Data()))[0] = scalar.to<float>();
+      break;
+    case FDDataType::FP64:
+      (reinterpret_cast<double*>(Data()))[0] = scalar.to<double>();
+      break;
+    default:
+      break;  
   }
 }
 
diff --git a/fastdeploy/runtime.h b/fastdeploy/runtime.h
index f6c75fe8df..0814a03e18 100755
--- a/fastdeploy/runtime.h
+++ b/fastdeploy/runtime.h
@@ -20,4 +20,4 @@
 
 #pragma once
 #include "fastdeploy/core/config.h"
-#include "fastdeploy/runtime/runtime.h"
+#include "fastdeploy/runtime/runtime.h"
\ No newline at end of file
diff --git a/fastdeploy/runtime/backends/lite/lite_backend.cc b/fastdeploy/runtime/backends/lite/lite_backend.cc
index 4e374525bf..f20c23c57f 100644
--- a/fastdeploy/runtime/backends/lite/lite_backend.cc
+++ b/fastdeploy/runtime/backends/lite/lite_backend.cc
@@ -13,6 +13,23 @@
 // limitations under the License.
 
 #include "fastdeploy/runtime/backends/lite/lite_backend.h"
+// https://github.com/PaddlePaddle/Paddle-Lite/issues/8290
+// When compiling the FastDeploy dynamic library, namely, 
+// WITH_STATIC_LIB=OFF, and depending on the Paddle Lite 
+// static library, you need to include the fake registration
+// codes of Paddle Lite. When you compile the FastDeploy static 
+// library and depends on the Paddle Lite static library, 
+// WITH_STATIC_LIB=ON, you do not need to include the fake 
+// registration codes for Paddle Lite, but wait until you 
+// use the FastDeploy static library.
+#if (defined(WITH_LITE_STATIC) && (!defined(WITH_STATIC_LIB)))
+#warning You are compiling the FastDeploy dynamic library with \
+Paddle Lite static lib We will automatically add some registration \
+codes for ops, kernels and passes for Paddle Lite.
+#include "paddle_use_ops.h"       // NOLINT
+#include "paddle_use_kernels.h"   // NOLINT
+#include "paddle_use_passes.h"    // NOLINT
+#endif
 
 #include <cstring>
 
diff --git a/fastdeploy/runtime/backends/lite/option.h b/fastdeploy/runtime/backends/lite/option.h
index 072f237719..fc1dfa9194 100755
--- a/fastdeploy/runtime/backends/lite/option.h
+++ b/fastdeploy/runtime/backends/lite/option.h
@@ -15,11 +15,29 @@
 #pragma once
 
 #include "fastdeploy/core/fd_type.h"
+// https://github.com/PaddlePaddle/Paddle-Lite/issues/8290
+#if (defined(WITH_LITE_STATIC) && defined(WITH_STATIC_LIB))
+// Whether to output some warning messages when using the 
+// FastDepoy static library, default OFF. These messages
+// are only reserve for debugging.
+#if defined(WITH_STATIC_WARNING)
+#warning You are using the FastDeploy static library. \
+We will automatically add some registration codes for \
+ops, kernels and passes for Paddle Lite.
+#endif
+#if !defined(WITH_STATIC_LIB_AT_COMPILING)
+#include "paddle_use_ops.h"       // NOLINT
+#include "paddle_use_kernels.h"   // NOLINT
+#include "paddle_use_passes.h"    // NOLINT
+#endif
+#endif
+
 #include <iostream>
 #include <memory>
 #include <string>
 #include <vector>
-#include <map>
+#include <map>  
+
 namespace fastdeploy {
 
 /*! Paddle Lite power mode for mobile device. */
diff --git a/java/android/app/src/main/java/com/baidu/paddle/fastdeploy/app/examples/segmentation/SegmentationWelcomeActivity.java b/java/android/app/src/main/java/com/baidu/paddle/fastdeploy/app/examples/segmentation/SegmentationWelcomeActivity.java
index 16736c0c77..16ba8bf9d1 100644
--- a/java/android/app/src/main/java/com/baidu/paddle/fastdeploy/app/examples/segmentation/SegmentationWelcomeActivity.java
+++ b/java/android/app/src/main/java/com/baidu/paddle/fastdeploy/app/examples/segmentation/SegmentationWelcomeActivity.java
@@ -20,7 +20,7 @@ protected void onCreate(@Nullable Bundle savedInstanceState) {
             );
             getWindow().setStatusBarColor(Color.TRANSPARENT);
         }
-        setContentView(R.layout.super_resolution_welcome);
+        setContentView(R.layout.segmentation_welcome);
     }
 
     public void startActivity(View view) {
diff --git a/java/android/fastdeploy/build.gradle b/java/android/fastdeploy/build.gradle
index 29e6b57d9a..4c91ca13db 100644
--- a/java/android/fastdeploy/build.gradle
+++ b/java/android/fastdeploy/build.gradle
@@ -28,7 +28,7 @@ android {
     externalNativeBuild {
         cmake {
             path "src/main/cpp/CMakeLists.txt"
-            version "3.10.2"
+            version "3.22.1"
         }
     }
     sourceSets {
@@ -36,7 +36,7 @@ android {
             jniLibs.srcDirs = ['libs']
         }
     }
-    ndkVersion '20.1.5948944'
+    ndkVersion '25.1.8937393'
 }
 
 dependencies {
diff --git a/java/android/fastdeploy/src/main/cpp/CMakeLists.txt b/java/android/fastdeploy/src/main/cpp/CMakeLists.txt
index 563722b841..9d40871aa2 100644
--- a/java/android/fastdeploy/src/main/cpp/CMakeLists.txt
+++ b/java/android/fastdeploy/src/main/cpp/CMakeLists.txt
@@ -2,7 +2,7 @@
 # documentation: https://d.android.com/studio/projects/add-native-code.html
 
 # Sets the minimum version of CMake required to build the native library.
-cmake_minimum_required(VERSION 3.10.2)
+cmake_minimum_required(VERSION 3.22.1)
 
 # Declares and names the project.
 project("fastdeploy_jni")
@@ -15,12 +15,11 @@ project("fastdeploy_jni")
 set(FastDeploy_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/fastdeploy-android-latest-shared-dev")
 
 find_package(FastDeploy REQUIRED)
-
 # include_directories(.)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${FastDeploy_INCLUDE_DIRS})
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math -Ofast -Os -DNDEBUG -fomit-frame-pointer -fno-asynchronous-unwind-tables -fno-unwind-tables")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math -Ofast -DNDEBUG -fomit-frame-pointer -fno-asynchronous-unwind-tables -fno-unwind-tables")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden -fdata-sections -ffunction-sections")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,-z,nocopyreloc")
 
diff --git a/scripts/android/build_android_aar.sh b/scripts/android/build_android_aar.sh
index 8d072004e1..fcbe6bf5af 100755
--- a/scripts/android/build_android_aar.sh
+++ b/scripts/android/build_android_aar.sh
@@ -29,9 +29,12 @@ fi
 # remove old package
 echo "[INFO] --- Packing ${CXX_PACKAGE_NAME} package ..."
 if [ -d "${CXX_PACKAGE_NAME}" ]; then
-	echo "[INFO] --- Removed old package done !"
-	rm ${CXX_PACKAGE_NAME}.tgz
 	rm -rf ${CXX_PACKAGE_NAME}
+    echo "[INFO] --- Removed old ${CXX_PACKAGE_NAME} done !"
+    if [ -f "${CXX_PACKAGE_NAME}.tgz" ]; then
+        rm ${CXX_PACKAGE_NAME}.tgz
+        echo "[INFO] --- Removed old ${CXX_PACKAGE_NAME} done !"
+    fi
 fi
 
 # package latest c++ sdk
@@ -39,11 +42,28 @@ mkdir ${CXX_PACKAGE_NAME}
 echo "[INFO] --- Collecting package contents ..."
 cp -r ${ARMV7_CXX_PACKAGE_NAME}/* ${CXX_PACKAGE_NAME}/
 cp -r ${ARMV8_CXX_PACKAGE_NAME}/* ${CXX_PACKAGE_NAME}/
-rm -rf ${CXX_PACKAGE_NAME}/examples
+# Fix Paddle Lite headers to support FastDeploy static lib
+SDK_LITE_INCLUDE_DIR=${CXX_PACKAGE_NAME}/third_libs/install/paddlelite/include
+ARMV7_LITE_INCLUDE_DIR=${ARMV7_CXX_PACKAGE_NAME}/third_libs/install/paddlelite/include
+ARMV8_LITE_INCLUDE_DIR=${ARMV8_CXX_PACKAGE_NAME}/third_libs/install/paddlelite/include
+rm ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+cat ${ARMV8_LITE_INCLUDE_DIR}/paddle_use_kernels.h | head -n 3 >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+echo "#if (defined(__aarch64__) || defined(_M_ARM64))" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+cat ${ARMV8_LITE_INCLUDE_DIR}/paddle_use_kernels.h | grep -v "#" | grep "USE" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+echo "#else" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+cat ${ARMV7_LITE_INCLUDE_DIR}/paddle_use_kernels.h | grep -v "#" | grep "USE" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+echo "#endif" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
+echo "[INFO] --- Fixed Paddle Lite paddle_use_kernels.h to support FastDeploy static lib."
+if [ -d "${CXX_PACKAGE_NAME}/examples" ]; then
+    rm -rf ${CXX_PACKAGE_NAME}/examples
+fi
 echo "[INFO] --- Removed examples files ..."
 echo "[INFO] --- Removing static .a files: "
-find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a"
-rm $(find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a")
+static_files=$(find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a")
+if [ ${#static_files[@]} -gt 10 ]; then
+    echo "${#static_files[@]}: ${static_files}"
+    rm $(find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a")
+fi
 echo "[INFO] --- Taring ${CXX_PACKAGE_NAME}.tgz package ..."
 tar -zcvf ${CXX_PACKAGE_NAME}.tgz ${CXX_PACKAGE_NAME}/* >> ${BUILT_PACKAGE_DIR}/pkg.log 2>&1
 echo "[INFO] --- Package ${CXX_PACKAGE_NAME}.tgz done ! Package size info: "
diff --git a/scripts/android/build_android_cpp_with_static_deps.sh b/scripts/android/build_android_cpp_with_static_deps.sh
new file mode 100755
index 0000000000..9aec9c4e83
--- /dev/null
+++ b/scripts/android/build_android_cpp_with_static_deps.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+set -e
+set +x
+
+# -------------------------------------------------------------------------------
+#                        mutable global variables
+# -------------------------------------------------------------------------------
+TOOLCHAIN=clang # gcc/clang toolchain
+
+# -------------------------------------------------------------------------------
+#                        readonly global variables
+# -------------------------------------------------------------------------------
+readonly ROOT_PATH=$(pwd)
+readonly ANDROID_ABI=$1
+readonly ANDROID_PLATFORM="android-$2"
+readonly BUILD_ROOT=build/Android
+readonly BUILD_DIR=${BUILD_ROOT}/${ANDROID_ABI}-api-$2
+
+# -------------------------------------------------------------------------------
+#                                 tasks
+# -------------------------------------------------------------------------------
+__make_build_dir() {
+  if [ ! -d "${BUILD_DIR}" ]; then
+    echo "-- [INFO] BUILD_DIR: ${BUILD_DIR} not exists, setup manually ..."
+    if [ ! -d "${BUILD_ROOT}" ]; then
+      mkdir -p "${BUILD_ROOT}" && echo "-- [INFO] Created ${BUILD_ROOT} !"
+    fi
+    mkdir -p "${BUILD_DIR}" && echo "-- [INFO] Created ${BUILD_DIR} !"
+  else
+    echo "-- [INFO] Found BUILD_DIR: ${BUILD_DIR}"
+  fi
+}
+
+__check_cxx_envs() {
+  if [ $LDFLAGS ]; then
+    echo "-- [INFO] Found LDFLAGS: ${LDFLAGS}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset LDFLAGS
+  fi
+  if [ $CPPFLAGS ]; then
+    echo "-- [INFO] Found CPPFLAGS: ${CPPFLAGS}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset CPPFLAGS
+  fi
+  if [ $CPLUS_INCLUDE_PATH ]; then
+    echo "-- [INFO] Found CPLUS_INCLUDE_PATH: ${CPLUS_INCLUDE_PATH}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset CPLUS_INCLUDE_PATH
+  fi
+  if [ $C_INCLUDE_PATH ]; then
+    echo "-- [INFO] Found C_INCLUDE_PATH: ${C_INCLUDE_PATH}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset C_INCLUDE_PATH
+  fi
+}
+
+__set_android_ndk() {
+  if [ -z $ANDROID_NDK ]; then
+    echo "-- [INFO] ANDROID_NDK not exists, please setup manually ..."
+    exit 0
+  else
+    echo "-- [INFO] Found ANDROID_NDK: ${ANDROID_NDK}"
+  fi
+  if [ "$ANDROID_NDK" ]; then
+      NDK_VERSION=$(echo $ANDROID_NDK | egrep -o "[0-9]{2}" | head -n 1)
+      if [ "$NDK_VERSION" -gt 17 ]; then
+          TOOLCHAIN=clang
+      fi
+      echo "-- [INFO] Checked ndk version: ${NDK_VERSION}"
+      echo "-- [INFO] Selected toolchain: ${TOOLCHAIN}"
+  fi
+}
+
+__build_fastdeploy_android_shared() {
+
+  local ANDROID_STL=c++_shared  # c++_static
+  local ANDROID_TOOLCHAIN=${TOOLCHAIN}
+  local TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake
+  local FASDEPLOY_INSTALL_DIR="${ROOT_PATH}/${BUILD_DIR}/install"
+  cd "${BUILD_DIR}" && echo "-- [INFO] Working Dir: ${PWD}"
+
+  cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \
+        -DCMAKE_BUILD_TYPE=MinSizeRel \
+        -DANDROID_ABI=${ANDROID_ABI} \
+        -DANDROID_NDK=${ANDROID_NDK} \
+        -DANDROID_PLATFORM=${ANDROID_PLATFORM} \
+        -DANDROID_STL=${ANDROID_STL} \
+        -DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN} \
+        -DENABLE_ORT_BACKEND=OFF \
+        -DENABLE_LITE_BACKEND=ON \
+        -DENABLE_PADDLE2ONNX=OFF \
+        -DENABLE_FLYCV=ON \
+        -DENABLE_TEXT=OFF \
+        -DENABLE_VISION=ON \
+        -DBUILD_EXAMPLES=OFF \
+        -DWITH_OPENCV_STATIC=ON \
+        -DWITH_FLYCV_STATIC=ON \
+        -DWITH_LITE_STATIC=ON \
+        -DWITH_STATIC_LIB=ON \
+        -DWITH_OPENMP=ON \
+        -DWITH_JAVA=ON \
+        -DCMAKE_INSTALL_PREFIX=${FASDEPLOY_INSTALL_DIR} \
+        -Wno-dev ../../.. && make -j8 && make install       
+
+  echo "-- [INFO][built][${ANDROID_ABI}][${BUILD_DIR}/install]"
+}
+
+main() {
+  __make_build_dir
+  __check_cxx_envs
+  __set_android_ndk
+  __build_fastdeploy_android_shared
+  exit 0
+}
+
+main
+
+# Usage:
+# ./scripts/android/build_android_cpp_with_static_deps.sh arm64-v8a 21
+# ./scripts/android/build_android_cpp_with_static_deps.sh armeabi-v7a 21
diff --git a/scripts/android/build_android_cpp_with_static_deps_with_text_api.sh b/scripts/android/build_android_cpp_with_static_deps_with_text_api.sh
new file mode 100755
index 0000000000..551e34a4a9
--- /dev/null
+++ b/scripts/android/build_android_cpp_with_static_deps_with_text_api.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+set -e
+set +x
+
+# -------------------------------------------------------------------------------
+#                        mutable global variables
+# -------------------------------------------------------------------------------
+TOOLCHAIN=clang # gcc/clang toolchain
+
+# -------------------------------------------------------------------------------
+#                        readonly global variables
+# -------------------------------------------------------------------------------
+readonly ROOT_PATH=$(pwd)
+readonly ANDROID_ABI=$1
+readonly ANDROID_PLATFORM="android-$2"
+readonly BUILD_ROOT=build/Android
+readonly BUILD_DIR=${BUILD_ROOT}/${ANDROID_ABI}-api-$2
+
+# -------------------------------------------------------------------------------
+#                                 tasks
+# -------------------------------------------------------------------------------
+__make_build_dir() {
+  if [ ! -d "${BUILD_DIR}" ]; then
+    echo "-- [INFO] BUILD_DIR: ${BUILD_DIR} not exists, setup manually ..."
+    if [ ! -d "${BUILD_ROOT}" ]; then
+      mkdir -p "${BUILD_ROOT}" && echo "-- [INFO] Created ${BUILD_ROOT} !"
+    fi
+    mkdir -p "${BUILD_DIR}" && echo "-- [INFO] Created ${BUILD_DIR} !"
+  else
+    echo "-- [INFO] Found BUILD_DIR: ${BUILD_DIR}"
+  fi
+}
+
+__check_cxx_envs() {
+  if [ $LDFLAGS ]; then
+    echo "-- [INFO] Found LDFLAGS: ${LDFLAGS}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset LDFLAGS
+  fi
+  if [ $CPPFLAGS ]; then
+    echo "-- [INFO] Found CPPFLAGS: ${CPPFLAGS}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset CPPFLAGS
+  fi
+  if [ $CPLUS_INCLUDE_PATH ]; then
+    echo "-- [INFO] Found CPLUS_INCLUDE_PATH: ${CPLUS_INCLUDE_PATH}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset CPLUS_INCLUDE_PATH
+  fi
+  if [ $C_INCLUDE_PATH ]; then
+    echo "-- [INFO] Found C_INCLUDE_PATH: ${C_INCLUDE_PATH}, \c"
+    echo "unset it before crossing compiling ${ANDROID_ABI}"
+    unset C_INCLUDE_PATH
+  fi
+}
+
+__set_android_ndk() {
+  if [ -z $ANDROID_NDK ]; then
+    echo "-- [INFO] ANDROID_NDK not exists, please setup manually ..."
+    exit 0
+  else
+    echo "-- [INFO] Found ANDROID_NDK: ${ANDROID_NDK}"
+  fi
+  if [ "$ANDROID_NDK" ]; then
+      NDK_VERSION=$(echo $ANDROID_NDK | egrep -o "[0-9]{2}" | head -n 1)
+      if [ "$NDK_VERSION" -gt 17 ]; then
+          TOOLCHAIN=clang
+      fi
+      echo "-- [INFO] Checked ndk version: ${NDK_VERSION}"
+      echo "-- [INFO] Selected toolchain: ${TOOLCHAIN}"
+  fi
+}
+
+__build_fastdeploy_android_shared() {
+
+  local ANDROID_STL=c++_shared  # c++_static
+  local ANDROID_TOOLCHAIN=${TOOLCHAIN}
+  local TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake
+  local FASDEPLOY_INSTALL_DIR="${ROOT_PATH}/${BUILD_DIR}/install"
+  cd "${BUILD_DIR}" && echo "-- [INFO] Working Dir: ${PWD}"
+
+  cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \
+        -DCMAKE_BUILD_TYPE=MinSizeRel \
+        -DANDROID_ABI=${ANDROID_ABI} \
+        -DANDROID_NDK=${ANDROID_NDK} \
+        -DANDROID_PLATFORM=${ANDROID_PLATFORM} \
+        -DANDROID_STL=${ANDROID_STL} \
+        -DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN} \
+        -DENABLE_ORT_BACKEND=OFF \
+        -DENABLE_LITE_BACKEND=ON \
+        -DENABLE_PADDLE2ONNX=OFF \
+        -DENABLE_FLYCV=ON \
+        -DENABLE_TEXT=ON \
+        -DENABLE_VISION=ON \
+        -DBUILD_EXAMPLES=OFF \
+        -DWITH_OPENCV_STATIC=ON \
+        -DWITH_FLYCV_STATIC=ON \
+        -DWITH_LITE_STATIC=ON \
+        -DWITH_STATIC_LIB=OFF \
+        -DWITH_OPENMP=ON \
+        -DWITH_JAVA=ON \
+        -DCMAKE_INSTALL_PREFIX=${FASDEPLOY_INSTALL_DIR} \
+        -Wno-dev ../../.. && make -j8 && make install
+
+  echo "-- [INFO][built][${ANDROID_ABI}][${BUILD_DIR}/install]"
+}
+
+main() {
+  __make_build_dir
+  __check_cxx_envs
+  __set_android_ndk
+  __build_fastdeploy_android_shared
+  exit 0
+}
+
+main
+
+# Usage:
+# ./scripts/android/build_android_cpp_with_static_deps_with_text_api.sh arm64-v8a 21
+# ./scripts/android/build_android_cpp_with_static_deps_with_text_api.sh armeabi-v7a 21