Updated fbjni since its outdated

android/CMakeLists.txt

@@ -32,13 +32,13 @@ target_include_directories(${PACKAGE_NAME}  PUBLIC "./")
 set(libjnihack_DIR ${CMAKE_SOURCE_DIR}/../libs/jni-hack/)
 set(libfbjni_DIR ${CMAKE_SOURCE_DIR}/../libs/fbjni/src/main/cpp/include/)
 set(libsonar_DIR ${CMAKE_SOURCE_DIR}/../xplat/)
-set(third_party_ndk build/third-party-ndk)
+set(third_party_ndk ${PROJECT_SOURCE_DIR}/build/third-party-ndk)
 set(libfolly_DIR ${third_party_ndk}/folly/)
 set(glog_DIR ${third_party_ndk}/glog)
 set(BOOST_DIR ${third_party_ndk}/boost/boost_1_63_0/)
-set(LIBEVENT_DIR ${third_party_ndk}/LibEvent/libevent-1.0.0/include/)
+set(LIBEVENT_DIR ${third_party_ndk}/LibEvent/libevent-release-2.1.9/)
-
 
+message(STATUS "AAAANDROID LIBEVENT_DIR => "  ${LIBEVENT_DIR})
 set(build_DIR ${CMAKE_SOURCE_DIR}/build)
 
 set(fbjni_build_DIR ${build_DIR}/fbjni/${ANDROID_ABI})
@@ -60,7 +60,9 @@ target_include_directories(${PACKAGE_NAME} PRIVATE
     ${glog_DIR}/glog-0.3.5/src/
     ${BOOST_DIR}
     ${BOOST_DIR}/../
-    ${LIBEVENT_DIR}
+    ${LIBEVENT_DIR}/
+    ${LIBEVENT_DIR}/include/
+    ${LIBEVENT_DIR}/include/event2
     )
 
 target_link_libraries(${PACKAGE_NAME} fb sonarcpp)

libs/fbjni/src/main/cpp/include/fb/fbjni/Hybrid.h

@@ -5,68 +5,98 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#pragma once
 
-#include <memory>
+ #pragma once
-#include <type_traits>
 
-#include <fb/assert.h>
+ #include <memory>
-#include <fb/visibility.h>
+ #include <type_traits>
 
-#include "CoreClasses.h"
+ #include "CoreClasses.h"
 
-namespace facebook {
+ namespace facebook {
-namespace jni {
+ namespace jni {
 
-namespace detail {
+ namespace detail {
 
-class BaseHybridClass {
+ class BaseHybridClass {
-public:
+ public:
    virtual ~BaseHybridClass() {}
-};
+ };
 
-struct FBEXPORT HybridData : public JavaClass<HybridData> {
+ struct HybridData : public JavaClass<HybridData> {
    constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";
-  void setNativePointer(std::unique_ptr<BaseHybridClass> new_value);
-  BaseHybridClass* getNativePointer();
    static local_ref<HybridData> create();
-};
+ };
 
-template <typename Base, typename Enabled = void>
+ class HybridDestructor : public JavaClass<HybridDestructor> {
-struct HybridTraits {
+   public:
+     static auto constexpr kJavaDescriptor = "Lcom/facebook/jni/HybridData$Destructor;";
+
+   detail::BaseHybridClass* getNativePointer();
+
+   void setNativePointer(std::unique_ptr<detail::BaseHybridClass> new_value);
+ };
+
+ template<typename T>
+ detail::BaseHybridClass* getNativePointer(T t) {
+   return getHolder(t)->getNativePointer();
+ }
+
+ template<typename T>
+ void setNativePointer(T t, std::unique_ptr<detail::BaseHybridClass> new_value) {
+   getHolder(t)->setNativePointer(std::move(new_value));
+ }
+
+ template<typename T>
+ local_ref<HybridDestructor> getHolder(T t) {
+   static auto holderField = t->getClass()->template getField<HybridDestructor::javaobject>("mDestructor");
+   return t->getFieldValue(holderField);
+ }
+
+ // JavaClass for HybridClassBase
+ struct HybridClassBase : public JavaClass<HybridClassBase> {
+   constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridClassBase;";
+
+   static bool isHybridClassBase(alias_ref<jclass> jclass) {
+     return HybridClassBase::javaClassStatic()->isAssignableFrom(jclass);
+   }
+ };
+
+ template <typename Base, typename Enabled = void>
+ struct HybridTraits {
    // This static assert should actually always fail if we don't use one of the
    // specializations below.
    static_assert(
        std::is_base_of<JObject, Base>::value ||
        std::is_base_of<BaseHybridClass, Base>::value,
        "The base of a HybridClass must be either another HybridClass or derived from JObject.");
-};
+ };
 
-template <>
+ template <>
-struct HybridTraits<BaseHybridClass> {
+ struct HybridTraits<BaseHybridClass> {
   using CxxBase = BaseHybridClass;
   using JavaBase = JObject;
-};
+ };
 
-template <typename Base>
+ template <typename Base>
-struct HybridTraits<
+ struct HybridTraits<
      Base,
      typename std::enable_if<std::is_base_of<BaseHybridClass, Base>::value>::type> {
   using CxxBase = Base;
   using JavaBase = typename Base::JavaPart;
-};
+ };
 
-template <typename Base>
+ template <typename Base>
-struct HybridTraits<
+ struct HybridTraits<
      Base,
      typename std::enable_if<std::is_base_of<JObject, Base>::value>::type> {
   using CxxBase = BaseHybridClass;
   using JavaBase = Base;
-};
+ };
 
-// convert to HybridClass* from jhybridobject
+ // convert to HybridClass* from jhybridobject
-template <typename T>
+ template <typename T>
-struct FBEXPORT Convert<
+ struct Convert<
    T, typename std::enable_if<
      std::is_base_of<BaseHybridClass, typename std::remove_pointer<T>::type>::value>::type> {
    typedef typename std::remove_pointer<T>::type::jhybridobject jniType;
@@ -77,22 +107,22 @@ struct FBEXPORT Convert<
      return wrap_alias(t)->cthis();
    }
    // There is no automatic return conversion for objects.
-};
+ };
 
-template<typename T>
+ template<typename T>
-struct RefReprType<T, typename std::enable_if<std::is_base_of<BaseHybridClass, T>::value, void>::type> {
+ struct RefReprType<T, typename std::enable_if<std::is_base_of<BaseHybridClass, T>::value, void>::type> {
    static_assert(std::is_same<T, void>::value,
        "HybridFoo (where HybridFoo derives from HybridClass<HybridFoo>) is not supported in this context. "
        "For an xxx_ref<HybridFoo>, you may want: xxx_ref<HybridFoo::javaobject> or HybridFoo*.");
    using Repr = T;
-};
+ };
 
 
-}
+ }
 
-template <typename T, typename Base = detail::BaseHybridClass>
+ template <typename T, typename Base = detail::BaseHybridClass>
-class FBEXPORT HybridClass : public detail::HybridTraits<Base>::CxxBase {
+ class HybridClass : public detail::HybridTraits<Base>::CxxBase {
-public:
+ public:
    struct JavaPart : JavaClass<JavaPart, typename detail::HybridTraits<Base>::JavaBase> {
      // At this point, T is incomplete, and so we cannot access
      // T::kJavaDescriptor directly. jtype_traits support this escape hatch for
@@ -108,6 +138,7 @@ public:
      T* cthis();
 
      friend class HybridClass;
+     friend T;
    };
 
    using jhybridobject = typename JavaPart::javaobject;
@@ -123,7 +154,7 @@ public:
      return findClassLocal(className.c_str());
    }
 
-protected:
+ protected:
    typedef HybridClass HybridBase;
 
    // This ensures that a C++ hybrid part cannot be created on its own
@@ -137,7 +168,7 @@ protected:
 
    static local_ref<detail::HybridData> makeHybridData(std::unique_ptr<T> cxxPart) {
      auto hybridData = detail::HybridData::create();
-    hybridData->setNativePointer(std::move(cxxPart));
+     setNativePointer(hybridData, std::move(cxxPart));
      return hybridData;
    }
 
@@ -146,7 +177,12 @@ protected:
      return makeHybridData(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
    }
 
-public:
+   template <typename... Args>
+   static void setCxxInstance(alias_ref<jhybridobject> o, Args&&... args) {
+     setNativePointer(o, std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
+   }
+
+ public:
    // Factory method for creating a hybrid object where the arguments
    // are used to initialize the C++ part directly without passing them
    // through java.  This method requires the Java part to have a ctor
@@ -159,8 +195,20 @@ public:
    // C++ object fails, or any JNI methods throw.
    template <typename... Args>
    static local_ref<JavaPart> newObjectCxxArgs(Args&&... args) {
-    auto hybridData = makeCxxInstance(std::forward<Args>(args)...);
+     static bool isHybrid = detail::HybridClassBase::isHybridClassBase(javaClassStatic());
-    return JavaPart::newInstance(hybridData);
+     auto cxxPart = std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+
+     local_ref<JavaPart> result;
+     if (isHybrid) {
+       result = JavaPart::newInstance();
+       setNativePointer(result, std::move(cxxPart));
+     }
+     else {
+       auto hybridData = makeHybridData(std::move(cxxPart));
+       result = JavaPart::newInstance(hybridData);
+     }
+
+     return result;
    }
 
   // TODO? Create reusable interface for Allocatable classes and use it to
@@ -189,43 +237,49 @@ public:
    // mapException returns, then the std::exception will be translated
    // to Java.
    static void mapException(const std::exception& ex) {}
-};
+ };
 
-template <typename T, typename B>
+ template <typename T, typename B>
-inline T* HybridClass<T, B>::JavaPart::cthis() {
+ inline T* HybridClass<T, B>::JavaPart::cthis() {
+   detail::BaseHybridClass* result = 0;
+   static bool isHybrid = detail::HybridClassBase::isHybridClassBase(this->getClass());
+   if (isHybrid) {
+     result = getNativePointer(this);
+   } else {
      static auto field =
        HybridClass<T, B>::JavaPart::javaClassStatic()->template getField<detail::HybridData::javaobject>("mHybridData");
      auto hybridData = this->getFieldValue(field);
      if (!hybridData) {
        throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
      }
+
+     result = getNativePointer(hybridData);
+   }
+
    // I'd like to use dynamic_cast here, but -fno-rtti is the default.
-  T* value = static_cast<T*>(hybridData->getNativePointer());
+   return static_cast<T*>(result);
-  // This would require some serious programmer error.
+ };
-  FBASSERTMSGF(value != 0, "Incorrect C++ type in hybrid field");
-  return value;
-};
 
-template <typename T, typename B>
+ template <typename T, typename B>
-/* static */ inline std::string HybridClass<T, B>::JavaPart::get_instantiated_java_descriptor() {
+ /* static */ inline std::string HybridClass<T, B>::JavaPart::get_instantiated_java_descriptor() {
    return T::kJavaDescriptor;
-}
+ }
 
-template <typename T, typename B>
+ template <typename T, typename B>
-/* static */ inline std::string HybridClass<T, B>::JavaPart::get_instantiated_base_name() {
+ /* static */ inline std::string HybridClass<T, B>::JavaPart::get_instantiated_base_name() {
    auto name = get_instantiated_java_descriptor();
    return name.substr(1, name.size() - 2);
-}
+ }
 
-// Given a *_ref object which refers to a hybrid class, this will reach inside
+ // Given a *_ref object which refers to a hybrid class, this will reach inside
-// of it, find the mHybridData, extract the C++ instance pointer, cast it to
+ // of it, find the mHybridData, extract the C++ instance pointer, cast it to
-// the appropriate type, and return it.
+ // the appropriate type, and return it.
-template <typename T>
+ template <typename T>
-inline auto cthis(T jthis) -> decltype(jthis->cthis()) {
+ inline auto cthis(T jthis) -> decltype(jthis->cthis()) {
    return jthis->cthis();
-}
+ }
 
-void HybridDataOnLoad();
+ void HybridDataOnLoad();
 
-}
+ }
-}
+ }

libs/fbjni/src/main/cpp/jni/Hybrid.cpp

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "fb/fbjni.h"
+ #include "fb/fbjni.h"
 
 
 namespace facebook {