GithubStar/Hippy
1
0
Fork 0
mirror of https://github.com/Tencent/Hippy.git synced 2026-10-20 07:38:33 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
Hippy/layout/android/jni/FlexNode.cpp
T
charleeshen eba94ebd3f feat(layout): format files
2021-03-12 16:00:28 +08:00

588 lines
21 KiB
C++
Executable File
Raw Permalink Blame History

/* Tencent is pleased to support the open source community by making Hippy available.
* Copyright (C) 2018 THL A29 Limited, a Tencent company. 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.
*/
#include "FlexNode.h"
#include <android/log.h>
#include <time.h>
#include <iostream>
#include <map>
#include <memory>
#include "FlexNodeJni.h"
#include "FlexNodeStyle.h"
static inline HPNodeRef _jlong2HPNodeRef(jlong addr) {
return (reinterpret_cast<FlexNode*>(addr))->mHPNode;
}
#ifdef LAYOUT_TIME_ANALYZE
static int layout_analyze_measureCount = 0;
static double layout_analyze_measureTime = 0.0f;
static int newLayoutCount = 0;
#endif
static jclass clazz;
static jfieldID widthField;
static jfieldID heightField;
static jfieldID leftField;
static jfieldID topField;
static jfieldID marginLeftField;
static jfieldID marginTopField;
static jfieldID marginRightField;
static jfieldID marginBottomField;
static jfieldID paddingLeftField;
static jfieldID paddingTopField;
static jfieldID paddingRightField;
static jfieldID paddingBottomField;
static jfieldID borderLeftField;
static jfieldID borderTopField;
static jfieldID borderRightField;
static jfieldID borderBottomField;
static jfieldID edgeSetFlagField;
static jfieldID hasNewLayoutField;
class LayoutContext {
public:
LayoutContext(jlongArray nativeNodes, jobjectArray javaNodes) {
// 1.setup the map index of HPNodes and java nodes.
jboolean isCopy = JNI_FALSE;
JNIEnv* env = GetJNIEnv();
jlong* flexNodes = env->GetLongArrayElements(nativeNodes, &isCopy);
jsize size = env->GetArrayLength(nativeNodes);
// __android_log_print(ANDROID_LOG_ERROR, "LayoutContext", "node count %d", size);
for (int i = 0; i < size; i++) {
HPNodeRef hpNode = _jlong2HPNodeRef(flexNodes[i]);
ASSERT(hpNode != nullptr);
node_ptr_index_map[hpNode] = i;
}
env->ReleaseLongArrayElements(nativeNodes, flexNodes, 0);
// 2.holds java object array
ASSERT(size == env->GetArrayLength(javaNodes));
jnode_arr = javaNodes;
}
base::android::ScopedJavaLocalRef<jobject> get(HPNodeRef node) {
JNIEnv* env = GetJNIEnv();
auto idx = node_ptr_index_map.find(node);
if (idx == node_ptr_index_map.end()) {
return base::android::ScopedJavaLocalRef<jobject>();
} else {
jobject java_object = env->GetObjectArrayElement(jnode_arr, idx->second);
return base::android::ScopedJavaLocalRef<jobject>(env, java_object);
}
}
private:
std::map<HPNodeRef, size_t> node_ptr_index_map;
jobjectArray jnode_arr;
};
static HPSize HPJNIMeasureFunc(HPNodeRef node,
float width,
MeasureMode widthMode,
float height,
MeasureMode heightMode,
void* layoutContext) {
ASSERT(layoutContext != nullptr);
base::android::ScopedJavaLocalRef<jobject> jnode =
(reinterpret_cast<LayoutContext*>(layoutContext))->get(node);
if (!jnode.is_null()) {
#ifdef LAYOUT_TIME_ANALYZE
clock_t start = clock();
#endif
const auto measureResult =
Java_FlexNode_measureFunc(GetJNIEnv(), jnode.obj(), width, widthMode, height, heightMode);
#ifdef LAYOUT_TIME_ANALYZE
clock_t end = clock();
layout_analyze_measureTime += (end - start);
layout_analyze_measureCount++;
#endif
static_assert(sizeof(measureResult) == 8,
"Expected measureResult to be 8 bytes, or two 32 bit ints");
int32_t wBits = 0xFFFFFFFF & (measureResult >> 32);
int32_t hBits = 0xFFFFFFFF & measureResult;
// __android_log_print(ANDROID_LOG_INFO, "TextNode2", "in FlexNode widthMode %d width %f,
// heightMode %d height %f, result :width %d, height %d",widthMode,width,heightMode, height,
// wBits, hBits);
return HPSize{static_cast<float>(wBits), static_cast<float>(hBits)};
} else {
return HPSize{
widthMode == 0 ? 0 : width,
heightMode == 0 ? 0 : height,
};
}
}
static jlong FlexNodeNew(JNIEnv* env, const base::android::JavaParamRef<jobject>& jcaller) {
FlexNode* flex_node = new FlexNode(env, jcaller);
return reinterpret_cast<intptr_t>(flex_node);
}
#ifdef LAYOUT_TIME_ANALYZE
static int FlexNodeCount(HPNodeRef node) {
int allCount = node->childCount();
for (unsigned int i = 0; i < node->childCount(); i++) {
allCount += FlexNodeCount(node->getChild(i));
}
return allCount;
}
#endif
static void TransferLayoutOutputsRecursive(HPNodeRef node, void* layoutContext) {
ASSERT(layoutContext != nullptr);
base::android::ScopedJavaLocalRef<jobject> jnode =
(reinterpret_cast<LayoutContext*>(layoutContext))->get(node);
if (jnode.is_null()) {
return;
}
JNIEnv* env = GetJNIEnv();
jobject java_node = jnode.obj();
if (!HPNodeHasNewLayout(node)) {
#ifdef LAYOUT_TIME_ANALYZE
// if (weakRef && ( localRef = GetJNIEnv()->NewLocalRef( weakRef) ) !=NULL ) {
// JNIEnv* env = GetJNIEnv();
static jclass clazz = env->FindClass(kFlexNodeClassPath);
static jfieldID widthField = env->GetFieldID(clazz, "mWidth", "F");
float javaWidth = env->GetFloatField(java_node, widthField);
// static jfieldID hasNewLayoutField = env->GetFieldID( clazz, "mHasNewLayout", "Z");
// hasNewLayout = env->GetBooleanField(weakRef ,hasNewLayoutField );
if (!isDefined(javaWidth)) {
__android_log_print(ANDROID_LOG_ERROR, "HippyLayoutTime",
"cache width NAN node's fetchCount %d nodetype %d", node->fetchCount,
node->style.nodeType);
}
// GetJNIEnv()->DeleteLocalRef( localRef );
// }
#endif
return;
}
#ifdef LAYOUT_TIME_ANALYZE
newLayoutCount++;
#endif
const int MARGIN = 1;
const int PADDING = 2;
const int BORDER = 4;
int hasEdgeSetFlag = env->GetIntField(java_node, edgeSetFlagField);
env->SetFloatField(java_node, widthField, HPNodeLayoutGetWidth(node));
env->SetFloatField(java_node, heightField, HPNodeLayoutGetHeight(node));
env->SetFloatField(java_node, leftField, HPNodeLayoutGetLeft(node));
env->SetFloatField(java_node, topField, HPNodeLayoutGetTop(node));
if ((hasEdgeSetFlag & MARGIN) == MARGIN) {
env->SetFloatField(java_node, marginLeftField,
HPNodeLayoutGetMargin(node, CSSDirection::CSSLeft));
env->SetFloatField(java_node, marginTopField,
HPNodeLayoutGetMargin(node, CSSDirection::CSSTop));
env->SetFloatField(java_node, marginRightField,
HPNodeLayoutGetMargin(node, CSSDirection::CSSRight));
env->SetFloatField(java_node, marginBottomField,
HPNodeLayoutGetMargin(node, CSSDirection::CSSBottom));
}
if ((hasEdgeSetFlag & PADDING) == PADDING) {
env->SetFloatField(java_node, paddingLeftField,
HPNodeLayoutGetPadding(node, CSSDirection::CSSLeft));
env->SetFloatField(java_node, paddingTopField,
HPNodeLayoutGetPadding(node, CSSDirection::CSSTop));
env->SetFloatField(java_node, paddingRightField,
HPNodeLayoutGetPadding(node, CSSDirection::CSSRight));
env->SetFloatField(java_node, paddingBottomField,
HPNodeLayoutGetPadding(node, CSSDirection::CSSBottom));
}
if ((hasEdgeSetFlag & BORDER) == BORDER) {
env->SetFloatField(java_node, borderLeftField,
HPNodeLayoutGetBorder(node, CSSDirection::CSSLeft));
env->SetFloatField(java_node, borderTopField,
HPNodeLayoutGetBorder(node, CSSDirection::CSSTop));
env->SetFloatField(java_node, borderRightField,
HPNodeLayoutGetBorder(node, CSSDirection::CSSRight));
env->SetFloatField(java_node, borderBottomField,
HPNodeLayoutGetBorder(node, CSSDirection::CSSBottom));
}
env->SetBooleanField(java_node, hasNewLayoutField, true);
HPNodesetHasNewLayout(node, false);
#ifdef LAYOUT_TIME_ANALYZE
node->fetchCount++;
#endif
for (unsigned int i = 0; i < node->childCount(); i++) {
TransferLayoutOutputsRecursive(node->getChild(i), layoutContext);
}
}
FlexNode::FlexNode(JNIEnv* env, const base::android::JavaParamRef<jobject>& jcaller) {
mHPNode = HPNodeNew();
// jobject jnode = env->NewWeakGlobalRef(jcaller.obj());
// mHPNode->setContext(jnode);
}
FlexNode::~FlexNode() {
// jobject weakRef = (jobject) mHPNode->getContext();
HPNodeFree(mHPNode);
// if (weakRef) {
// GetJNIEnv()->DeleteWeakGlobalRef(weakRef);
// }
}
void FlexNode::FlexNodeReset(JNIEnv* env, const base::android::JavaParamRef<jobject>& jcaller) {
FLEX_NODE_LOG("#not#FlexNode::Reset:");
}
void FlexNode::FlexNodeInsertChild(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
jlong childPointer,
jint index) {
FLEX_NODE_LOG("FlexNode::InsertChild:%d", index);
HPNodeInsertChild(mHPNode, _jlong2HPNodeRef(childPointer), index);
}
void FlexNode::FlexNodeRemoveChild(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
jlong childPointer) {
FLEX_NODE_LOG("FlexNode::RemoveChild");
HPNodeRemoveChild(mHPNode, _jlong2HPNodeRef(childPointer));
}
void FlexNode::FlexNodeCalculateLayout(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
jfloat width,
jfloat height,
const base::android::JavaParamRef<jlongArray>& nativeNodes,
const base::android::JavaParamRef<jobjectArray>& javaNodes,
jint direction) {
FLEX_NODE_LOG("FlexNode::CalculateLayout:%.2f,%.2f", width, height);
ASSERT(!nativeNodes.is_null());
ASSERT(!javaNodes.is_null());
LayoutContext layoutContext(nativeNodes, javaNodes);
// __android_log_print(ANDROID_LOG_INFO, "HippyLayout", "start
// HPNodeDoLayout===========================================");
#ifdef LAYOUT_TIME_ANALYZE
// clock_t start = clock();
newLayoutCount = 0;
struct timeval start, end;
gettimeofday(&start, NULL);
layout_analyze_measureCount = 0;
layout_analyze_measureTime = 0.0f;
#endif
if (direction < 0 || direction > 2) {
direction = 1; // HPDirection::LTR
}
HPNodeDoLayout(mHPNode, width, height, (HPDirection)direction,
reinterpret_cast<void*>(&layoutContext));
#ifdef LAYOUT_TIME_ANALYZE
// clock_t end = clock();
gettimeofday(&end, NULL);
__android_log_print(ANDROID_LOG_INFO, "HippyLayoutTime",
"HPNodeDoLayout %ld ms MeasureCount %d MeasureTime %lf ms",
// (end - start)/(double) CLOCKS_PER_SEC * 1000,
(1000 * (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec) / 1000),
layout_analyze_measureCount,
layout_analyze_measureTime / static_cast<double>(CLOCKS_PER_SEC) * 1000);
#endif
TransferLayoutOutputsRecursive(mHPNode, reinterpret_cast<void*>(&layoutContext));
#ifdef LAYOUT_TIME_ANALYZE
gettimeofday(&start, NULL);
__android_log_print(ANDROID_LOG_INFO, "HippyLayoutTime", "TransferLayoutOutputsRecursive %ld ms ",
(1000 * (start.tv_sec - end.tv_sec) + (start.tv_usec - end.tv_usec) / 1000));
__android_log_print(ANDROID_LOG_INFO, "HippyLayoutTime",
"FlexNodeCount %d TransferLayoutOutputsRecursive newLayoutCount %d",
FlexNodeCount(mHPNode), newLayoutCount);
#endif
// HPNodePrint(mHPNode);
// __android_log_print(ANDROID_LOG_INFO, "HippyLayout", "end
// HPNodeDoLayout===========================================");
}
void FlexNode::FlexNodeNodeMarkDirty(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj) {
FLEX_NODE_LOG("FlexNode::MarkDirty");
HPNodeMarkDirty(mHPNode);
}
bool FlexNode::FlexNodeNodeIsDirty(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj) {
FLEX_NODE_LOG("FlexNode::IsDirty");
return HPNodeIsDirty(mHPNode);
}
void FlexNode::FlexNodeNodeSetHasMeasureFunc(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
jboolean hasMeasureFunc) {
FLEX_NODE_LOG("FlexNode::SetHasMeasureFunc:%d ", hasMeasureFunc);
HPNodeSetMeasureFunc(mHPNode, hasMeasureFunc ? HPJNIMeasureFunc : NULL);
}
void FlexNode::FlexNodeNodeSetHasBaselineFunc(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
jboolean hasMeasureFunc) {
FLEX_NODE_LOG("#not#FlexNode::SetHasBaselineFunc");
}
void FlexNode::FlexNodemarkHasNewLayout(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj) {
FLEX_NODE_LOG("FlexNode::markHasNewLayout");
HPNodesetHasNewLayout(mHPNode, true);
}
bool FlexNode::FlexNodehasNewLayout(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj) {
FLEX_NODE_LOG("FlexNode::hasNewLayout");
return HPNodeHasNewLayout(mHPNode);
}
void FlexNode::FlexNodemarkLayoutSeen(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj) {
FLEX_NODE_LOG("FlexNode::markLayoutSeen");
HPNodesetHasNewLayout(mHPNode, false);
}
#define FLEX_NODE_MEM_FUN_GET_CPP(type, name) \
type FlexNode::FlexNodeGet##name(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj)
#define FLEX_NODE_MEM_FUN_SET_CPP(type, name) \
void FlexNode::FlexNodeSet##name(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj, \
type name)
void FlexNode::FlexNodeFree(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj) {
delete this;
}
void FlexNode::FlexNodeFreeRecursive(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj) {
FLEX_NODE_LOG("FlexNode::FreeRecursive");
HPNodeFreeRecursive(mHPNode);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, Width) {
FLEX_NODE_LOG("FlexNode::GetWidth");
float value = HPNodeLayoutGetWidth(mHPNode);
// __android_log_print(ANDROID_LOG_INFO, "TextNode", "width %f", value);
return value;
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, Width) {
FLEX_NODE_LOG("#not#FlexNode::SetWidth:%.2f", Width);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, Height) {
FLEX_NODE_LOG("FlexNode::GetHeight: %.2f", HPNodeLayoutGetHeight(mHPNode));
return HPNodeLayoutGetHeight(mHPNode);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, Height) {
FLEX_NODE_LOG("#not#FlexNode::SetHeight:%.2f", Height);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, Left) {
FLEX_NODE_LOG("FlexNode::GetLeft :%.2f", HPNodeLayoutGetLeft(mHPNode));
return HPNodeLayoutGetLeft(mHPNode);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, Left) {
FLEX_NODE_LOG("#not#FlexNode::SetLeft:%.2f", Left);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, Top) {
FLEX_NODE_LOG("FlexNode::GetTop:%.2f ", HPNodeLayoutGetTop(mHPNode));
return HPNodeLayoutGetTop(mHPNode);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, Top) {
FLEX_NODE_LOG("#not#FlexNode::SetTop:%.2f", Top);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, Right) {
FLEX_NODE_LOG("FlexNode::GetRight:%.2f", HPNodeLayoutGetRight(mHPNode));
return HPNodeLayoutGetRight(mHPNode);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, Right) {
FLEX_NODE_LOG("#not#FlexNode::SetRight:%.2f", Right);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, Bottom) {
FLEX_NODE_LOG("FlexNode::GetBottom:%.2f", HPNodeLayoutGetBottom(mHPNode));
return HPNodeLayoutGetBottom(mHPNode);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, Bottom) {
FLEX_NODE_LOG("#not#FlexNode::SetBottom:%.2f", Bottom);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, MarginLeft) {
FLEX_NODE_LOG("FlexNode::GetMarginLeft");
return HPNodeLayoutGetMargin(mHPNode, CSSDirection::CSSLeft);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, MarginLeft) {
FLEX_NODE_LOG("#not#FlexNode::SetMarginLeft:%.2f", MarginLeft);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, MarginTop) {
FLEX_NODE_LOG("FlexNode::GetMarginTop");
return HPNodeLayoutGetMargin(mHPNode, CSSDirection::CSSTop);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, MarginTop) {
FLEX_NODE_LOG("#not#FlexNode::SetMarginTop:%.2f", MarginTop);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, MarginRight) {
FLEX_NODE_LOG("FlexNode::GetMarginRight");
return HPNodeLayoutGetMargin(mHPNode, CSSDirection::CSSRight);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, MarginRight) {
FLEX_NODE_LOG("#not#FlexNode::SetMarginRight:%.2f", MarginRight);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, MarginBottom) {
FLEX_NODE_LOG("FlexNode::GetMarginBottom");
return HPNodeLayoutGetMargin(mHPNode, CSSDirection::CSSBottom);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, MarginBottom) {
FLEX_NODE_LOG("#not#FlexNode::SetMarginBottom:%.2f", MarginBottom);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, PaddingLeft) {
FLEX_NODE_LOG("FlexNode::GetPaddingLeft");
return HPNodeLayoutGetPadding(mHPNode, CSSDirection::CSSLeft);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, PaddingLeft) {
FLEX_NODE_LOG("#not#FlexNode::SetPaddingLeft:%.2f", PaddingLeft);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, PaddingTop) {
FLEX_NODE_LOG("FlexNode::GetPaddingTop");
return HPNodeLayoutGetPadding(mHPNode, CSSDirection::CSSTop);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, PaddingTop) {
FLEX_NODE_LOG("#not#FlexNode::SetPaddingTop:%.2f", PaddingTop);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, PaddingRight) {
FLEX_NODE_LOG("FlexNode::GetPaddingRight");
return HPNodeLayoutGetPadding(mHPNode, CSSDirection::CSSRight);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, PaddingRight) {
FLEX_NODE_LOG("#not#FlexNode::SetPaddingRight:%.2f", PaddingRight);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, PaddingBottom) {
FLEX_NODE_LOG("FlexNode::GetPaddingBottom");
return HPNodeLayoutGetPadding(mHPNode, CSSDirection::CSSBottom);
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, PaddingBottom) {
FLEX_NODE_LOG("#not#FlexNode::SetPaddingBottom:%.2f", PaddingBottom);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, BorderLeft) {
FLEX_NODE_LOG("#not#FlexNode::GetBorderLeft");
return 0;
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, BorderLeft) {
FLEX_NODE_LOG("#not#FlexNode::SetBorderLeft:%.2f", BorderLeft);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, BorderTop) {
FLEX_NODE_LOG("#not#FlexNode::GetBorderTop");
return 0;
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, BorderTop) {
FLEX_NODE_LOG("#not#FlexNode::SetBorderTop:%.2f", BorderTop);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, BorderRight) {
FLEX_NODE_LOG("#not#FlexNode::GetBorderRight");
return 0;
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, BorderRight) {
FLEX_NODE_LOG("#not#FlexNode::SetBorderRight:%.2f", BorderRight);
}
FLEX_NODE_MEM_FUN_GET_CPP(jfloat, BorderBottom) {
FLEX_NODE_LOG("#not#FlexNode::GetBorderBottom");
return 0;
}
FLEX_NODE_MEM_FUN_SET_CPP(jfloat, BorderBottom) {
FLEX_NODE_LOG("#not#FlexNode::SetBorderBottom:%.2f", BorderBottom);
}
bool RegisterFlexNode(JNIEnv* env) {
return RegisterNativesImpl(env);
}
JavaVM* g_jvm = NULL;
jint JNI_OnLoad(JavaVM* vm, void*) {
JNIEnv* env = NULL;
g_jvm = vm;
// __android_log_print(ANDROID_LOG_INFO, "FlexBox", "JNI_OnLoad start:%p" , vm);
if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_4) != JNI_OK) {
// __android_log_print(ANDROID_LOG_INFO, "FlexBox", "JNI_OnLoad ERROR");
return -1;
}
// delete vlock;
RegisterFlexNode(env);
RegisterFlexNodeStyle(env);
// DemoDocument();
// __android_log_print(ANDROID_LOG_INFO, "FlexBox", "JNI_OnLoad Sucess");
clazz = env->FindClass(kFlexNodeClassPath);
widthField = env->GetFieldID(clazz, "mWidth", "F");
heightField = env->GetFieldID(clazz, "mHeight", "F");
leftField = env->GetFieldID(clazz, "mLeft", "F");
topField = env->GetFieldID(clazz, "mTop", "F");
marginLeftField = env->GetFieldID(clazz, "mMarginLeft", "F");
marginTopField = env->GetFieldID(clazz, "mMarginTop", "F");
marginRightField = env->GetFieldID(clazz, "mMarginRight", "F");
marginBottomField = env->GetFieldID(clazz, "mMarginBottom", "F");
paddingLeftField = env->GetFieldID(clazz, "mPaddingLeft", "F");
paddingTopField = env->GetFieldID(clazz, "mPaddingTop", "F");
paddingRightField = env->GetFieldID(clazz, "mPaddingRight", "F");
paddingBottomField = env->GetFieldID(clazz, "mPaddingBottom", "F");
borderLeftField = env->GetFieldID(clazz, "mBorderLeft", "F");
borderTopField = env->GetFieldID(clazz, "mBorderTop", "F");
borderRightField = env->GetFieldID(clazz, "mBorderRight", "F");
borderBottomField = env->GetFieldID(clazz, "mBorderBottom", "F");
edgeSetFlagField = env->GetFieldID(clazz, "mEdgeSetFlag", "I");
hasNewLayoutField = env->GetFieldID(clazz, "mHasNewLayout", "Z");
return JNI_VERSION_1_4;
}
void JNI_OnUnLoad(JavaVM* vm, void*) {
// __android_log_print(ANDROID_LOG_INFO, "FlexBox", "JNI_OnUnLoad Sucess");
}
JNIEnv* GetJNIEnv() {
JNIEnv* env = NULL;
g_jvm->AttachCurrentThread(&env, NULL);
return env;
}
Reference in New Issue View Git Blame Copy Permalink