| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package com.taobao.weex.ui.component.binding; |
| |
| import android.os.Looper; |
| import android.support.v4.util.ArrayMap; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.alibaba.fastjson.JSONArray; |
| import com.alibaba.fastjson.JSONObject; |
| import com.taobao.weex.WXEnvironment; |
| import com.taobao.weex.annotation.Component; |
| import com.taobao.weex.common.Constants; |
| import com.taobao.weex.dom.WXAttr; |
| import com.taobao.weex.dom.WXDomObject; |
| import com.taobao.weex.dom.WXEvent; |
| import com.taobao.weex.dom.binding.ELUtils; |
| import com.taobao.weex.dom.binding.WXStatement; |
| import com.taobao.weex.dom.flex.CSSLayoutContext; |
| import com.taobao.weex.el.parse.ArrayStack; |
| import com.taobao.weex.el.parse.Operators; |
| import com.taobao.weex.el.parse.Token; |
| import com.taobao.weex.ui.component.WXComponent; |
| import com.taobao.weex.ui.component.WXComponentFactory; |
| import com.taobao.weex.ui.component.WXImage; |
| import com.taobao.weex.ui.component.WXVContainer; |
| import com.taobao.weex.ui.component.list.WXCell; |
| import com.taobao.weex.ui.component.list.template.WXRecyclerTemplateList; |
| import com.taobao.weex.utils.WXLogUtils; |
| import com.taobao.weex.utils.WXUtils; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Created by jianbai.gbj on 2017/8/17. |
| * simple statement execute, render component for template list |
| */ |
| public class Statements { |
| /** |
| * recursive copy component, none parent connect |
| * */ |
| public static WXComponent copyComponentTree(WXComponent component){ |
| long start = System.currentTimeMillis(); |
| WXComponent copy = copyComponentTree(component, component.getParent()); |
| if(WXEnvironment.isApkDebugable()){ |
| WXLogUtils.d(WXRecyclerTemplateList.TAG, Thread.currentThread() + component.getRef() + "copyComponentTree " + "used " + (System.currentTimeMillis() - start)); |
| } |
| return copy; |
| } |
| |
| /** |
| * recursive copy component, |
| * */ |
| private static final WXComponent copyComponentTree(WXComponent source, WXVContainer parent){ |
| WXDomObject node = (WXDomObject) source.getDomObject(); |
| WXComponent component = WXComponentFactory.newInstance(source.getInstance(), node, parent); |
| if(source instanceof WXVContainer){ |
| WXVContainer container = (WXVContainer) source; |
| WXVContainer childParent = (WXVContainer) component; |
| WXDomObject childParentNode = (WXDomObject) childParent.getDomObject(); |
| int count = container.getChildCount(); |
| for (int i = 0; i < count; ++i) { |
| WXComponent child = container.getChild(i); |
| if (child != null) { |
| WXComponent targetChild = copyComponentTree(child, childParent); |
| childParent.addChild(targetChild); |
| childParentNode.add((WXDomObject) targetChild.getDomObject(), -1); |
| } |
| } |
| } |
| return component; |
| } |
| |
| /** |
| * @param component component with v-for statement, v-if statement and bind attrs |
| * @param stack execute context |
| * render component in context, the function do the following work. |
| * execute component's v-for statement, v-if statement in context, |
| * and rebuild component's tree with the statement, v-for reuse component execute by pre render. |
| * if executed, component will be removed, don't remove, just mark it waste; |
| * may be next render it can be used. |
| * after statement has executed, render component's binding attrs in context and bind it to component. |
| * */ |
| public static final List<WXComponent> doRender(WXComponent component, ArrayStack stack){ |
| List<WXComponent> updates = new ArrayList<>(4); |
| try{ |
| doRenderComponent(component, stack, updates); |
| }catch (Exception e){ |
| WXLogUtils.e("WeexStatementRender", e); |
| } |
| return updates; |
| } |
| |
| public static final void doInitCompontent(List<WXComponent> updates) { |
| if(updates == null || updates.size() == 0){ |
| return; |
| } |
| for(WXComponent renderNode : updates){ |
| if(renderNode.getParent() == null){ |
| throw new IllegalArgumentException("render node parent cann't find"); |
| } |
| WXVContainer parent = renderNode.getParent(); |
| int renderIndex = parent.indexOf(renderNode); |
| if(renderIndex < 0){ |
| throw new IllegalArgumentException("render node cann't find"); |
| } |
| parent.createChildViewAt(renderIndex); |
| renderNode.applyLayoutAndEvent(renderNode); |
| renderNode.bindData(renderNode); |
| } |
| } |
| |
| /** |
| * @param component component with v-for statement, v-if statement and bind attrs |
| * @param context execute context |
| * render component in context, the function do the following work. |
| * execute component's v-for statement, v-if statement in context, |
| * and rebuild component's tree with the statement, v-for reuse component execute by pre render. |
| * if executed, component will be removed, don't remove, just mark it waste; |
| * may be next render it can be used. |
| * after statement has executed, render component's binding attrs in context and bind it to component. |
| * */ |
| private static final int doRenderComponent(WXComponent component, ArrayStack context, |
| List<WXComponent> updates){ |
| WXVContainer parent = component.getParent(); |
| WXDomObject domObject = (WXDomObject) component.getDomObject(); |
| WXAttr attrs = domObject.getAttrs(); |
| WXStatement statement = attrs.getStatement(); |
| if(statement != null){ |
| WXDomObject parentDomObject = (WXDomObject) parent.getDomObject(); |
| Token vif = null; |
| JSONObject vfor = null; |
| if(statement.get(WXStatement.WX_IF) instanceof Token){ |
| vif = (Token) statement.get(WXStatement.WX_IF); |
| } |
| if(statement.get(WXStatement.WX_FOR) instanceof JSONObject){ |
| vfor = (JSONObject) statement.get(WXStatement.WX_FOR); |
| } |
| // execute v-for content |
| if(vfor != null){ |
| int renderIndex = parent.indexOf(component); |
| if(vfor.get(WXStatement.WX_FOR_LIST) instanceof Token){ |
| Token listBlock = (Token) vfor.get(WXStatement.WX_FOR_LIST); |
| String indexKey = vfor.getString(WXStatement.WX_FOR_INDEX); |
| String itemKey = vfor.getString(WXStatement.WX_FOR_ITEM); |
| Object data = null; |
| if(listBlock != null) { |
| data = listBlock.execute(context); |
| } |
| if((data instanceof List || data instanceof Map)){ |
| |
| Collection collection = null; |
| Map map = null; |
| if(data instanceof List){ |
| collection = (List)data; |
| }else{ |
| map = (Map)data; |
| collection = map.keySet(); |
| } |
| Map<String, Object> loop = new HashMap<>(); |
| int index = 0; |
| for(Object item : collection){ |
| Object key = null; |
| Object value = item; |
| if(map == null){ |
| key = index; |
| value = item; |
| }else{ |
| key = item; |
| value = map.get(item); |
| } |
| if(indexKey != null){ |
| loop.put(indexKey, key); |
| } |
| |
| if(itemKey != null){ |
| loop.put(itemKey, value); |
| }else{ |
| context.push(value); |
| } |
| if(loop.size() > 0){ |
| context.push(loop); |
| } |
| |
| |
| if(vif != null){ |
| if(!Operators.isTrue(vif.execute(context))){ |
| continue; |
| } |
| } |
| //find resuable renderNode |
| WXComponent renderNode = null; |
| if(renderIndex < parent.getChildCount()){ |
| renderNode = parent.getChild(renderIndex); |
| //check is same statment, if true, it is usabled. |
| if(!isCreateFromNodeStatement(renderNode, component)){ |
| renderNode = null; |
| } |
| if(renderNode != null){ |
| if(renderNode.isWaste()){ |
| renderNode.setWaste(false); |
| } |
| } |
| } |
| //none resuable render node, create node, add to parent, but clear node's statement |
| if(renderNode == null){ |
| long start = System.currentTimeMillis(); |
| renderNode = copyComponentTree(component, parent); |
| WXDomObject renderNodeDomObject = (WXDomObject) renderNode.getDomObject(); |
| renderNodeDomObject.getAttrs().setStatement(null); // clear node's statement |
| parentDomObject.add(renderNodeDomObject, renderIndex); |
| parent.addChild(renderNode, renderIndex); |
| updates.add(renderNode); |
| if(WXEnvironment.isApkDebugable()){ |
| WXLogUtils.d(WXRecyclerTemplateList.TAG, Thread.currentThread().getName() + renderNode.getRef() + renderNode.getDomObject().getType() + "statements copy component tree used " + (System.currentTimeMillis() - start)); |
| } |
| } |
| doBindingAttrsEventAndRenderChildNode(renderNode, domObject, context, updates); |
| renderIndex++; |
| if(loop.size() > 0){ |
| context.push(loop); |
| } |
| if(itemKey == null) { |
| context.pop(); |
| } |
| } |
| } |
| }else{ |
| WXLogUtils.e(WXRecyclerTemplateList.TAG, vfor.toJSONString() + " not call vfor block, for pre compile"); |
| } |
| //after v-for execute, remove component created pre v-for. |
| for(;renderIndex<parent.getChildCount(); renderIndex++){ |
| WXComponent wasteNode = parent.getChild(renderIndex); |
| if(!isCreateFromNodeStatement(wasteNode, component)){ |
| break; |
| } |
| wasteNode.setWaste(true); |
| } |
| return renderIndex - parent.indexOf(component); |
| } |
| |
| //execute v-if context |
| if(vif != null){ |
| if(!Operators.isTrue(vif.execute(context))){ |
| component.setWaste(true); |
| if(Thread.currentThread() == Looper.getMainLooper().getThread()) { |
| return 1; |
| } |
| }else{ |
| component.setWaste(false); |
| } |
| } |
| } |
| doBindingAttrsEventAndRenderChildNode(component, domObject, context, updates); |
| return 1; |
| } |
| |
| /** |
| * bind attrs and doRender component child |
| * */ |
| private static void doBindingAttrsEventAndRenderChildNode(WXComponent component, WXDomObject domObject, ArrayStack context, |
| List<WXComponent> updates){ |
| WXAttr attr = component.getDomObject().getAttrs(); |
| /** |
| * sub component supported, sub component new stack |
| * */ |
| if(attr.get(ELUtils.IS_COMPONENT_ROOT) != null |
| && WXUtils.getBoolean(attr.get(ELUtils.IS_COMPONENT_ROOT), false)){ |
| if(attr.get(ELUtils.COMPONENT_PROPS) != null |
| && attr.get(ELUtils.COMPONENT_PROPS) instanceof JSONObject){ |
| Map<String, Object> props = renderProps((JSONObject) attr.get(ELUtils.COMPONENT_PROPS), context); |
| context = new ArrayStack(); |
| context.push(props); |
| } |
| } |
| doRenderBindingAttrsAndEvent(component, domObject, context); |
| if(component instanceof WXVContainer){ |
| if(!domObject.isShow()){ |
| if(!(component instanceof WXCell)){ |
| if(Thread.currentThread() == Looper.getMainLooper().getThread()){ |
| return; |
| } |
| } |
| } |
| WXVContainer container = (WXVContainer) component; |
| for(int k=0; k<container.getChildCount();){ |
| WXComponent next = container.getChild(k); |
| k += doRenderComponent(next, context, updates); |
| } |
| } |
| } |
| |
| |
| /** |
| * check whether render node is create from component node statement. |
| * */ |
| private static boolean isCreateFromNodeStatement(WXComponent renderNode, WXComponent component){ |
| return (renderNode.getRef() != null && renderNode.getRef().equals(component.getRef())); |
| } |
| |
| |
| /** |
| * render dynamic binding attrs and bind them to component node. |
| * */ |
| private static void doRenderBindingAttrsAndEvent(WXComponent component, WXDomObject domObject, ArrayStack context){ |
| component.setWaste(false); |
| WXAttr attr = domObject.getAttrs(); |
| if(attr != null |
| && attr.getBindingAttrs() != null |
| && attr.getBindingAttrs().size() > 0){ |
| ArrayMap<String, Object> bindAttrs = domObject.getAttrs().getBindingAttrs(); |
| Map<String, Object> dynamic = renderBindingAttrs(bindAttrs, context); |
| Set<Map.Entry<String, Object>> entries = dynamic.entrySet(); |
| /** |
| * diff attrs, see attrs has update, remove none update attrs |
| * */ |
| Iterator<Map.Entry<String, Object>> iterator = entries.iterator(); |
| while (iterator.hasNext()){ |
| Map.Entry<String, Object> entry = iterator.next(); |
| String key = entry.getKey(); |
| if(entry.getValue() == null){ |
| if(attr.get(key) == null){ |
| iterator.remove(); |
| continue; |
| } |
| } |
| if(entry.getValue().equals(attr.get(key))){ |
| iterator.remove(); |
| } |
| } |
| |
| if(dynamic.size() > 0) { |
| if(dynamic.size() == 1 |
| && dynamic.get(Constants.Name.SRC) != null |
| && component instanceof WXImage){ |
| //for image avoid dirty layout, only update src attrs |
| domObject.getAttrs().put(Constants.Name.SRC, dynamic.get(Constants.Name.SRC)); |
| }else { |
| domObject.updateAttr(dynamic); //dirty layout |
| } |
| if(Thread.currentThread() == Looper.getMainLooper().getThread()) { |
| component.updateProperties(dynamic); |
| } |
| dynamic.clear(); |
| } |
| } |
| WXEvent event = domObject.getEvents(); |
| if(event == null || event.getEventBindingArgs() == null){ |
| return; |
| } |
| Set<Map.Entry<String, Object>> eventBindArgsEntrySet = event.getEventBindingArgs().entrySet(); |
| for(Map.Entry<String, Object> eventBindArgsEntry : eventBindArgsEntrySet){ |
| List<Object> values = getBindingEventArgs(context, eventBindArgsEntry.getValue()); |
| if(values != null){ |
| event.putEventBindingArgsValue(eventBindArgsEntry.getKey(), values); |
| } |
| } |
| } |
| |
| |
| /** |
| * @param bindAttrs none null, |
| * @param context context |
| * return binding attrs rended value in context |
| * */ |
| private static final ThreadLocal<Map<String, Object>> dynamicLocal = new ThreadLocal<>(); |
| public static Map<String, Object> renderBindingAttrs(ArrayMap bindAttrs, ArrayStack context){ |
| Set<Map.Entry<String, Object>> entrySet = bindAttrs.entrySet(); |
| Map<String, Object> dynamic = dynamicLocal.get(); |
| if(dynamic == null) { |
| dynamic = new HashMap<>(); |
| dynamicLocal.set(dynamic); |
| } |
| if(dynamic.size() > 0){ |
| dynamic.clear(); |
| } |
| for(Map.Entry<String, Object> entry : entrySet){ |
| Object value = entry.getValue(); |
| String key = entry.getKey(); |
| if(value instanceof JSONObject |
| && (((JSONObject) value).get(ELUtils.BINDING) instanceof Token)){ |
| JSONObject binding = (JSONObject) value; |
| Token block = (Token) (binding.get(ELUtils.BINDING)); |
| Object blockValue = block.execute(context); |
| dynamic.put(key, blockValue); |
| }else if(value instanceof JSONArray){ |
| JSONArray array = (JSONArray) value; |
| StringBuilder builder = new StringBuilder(); |
| for(int i=0; i<array.size(); i++){ |
| Object element = array.get(i); |
| if(element instanceof CharSequence){ |
| builder.append(element); |
| continue; |
| } |
| if(element instanceof JSONObject |
| && (((JSONObject) element).get(ELUtils.BINDING) instanceof Token)){ |
| JSONObject binding = (JSONObject) element; |
| Token block = (Token) (binding.get(ELUtils.BINDING)); |
| Object blockValue = block.execute(context); |
| if(blockValue == null){ |
| blockValue = ""; |
| } |
| builder.append(blockValue); |
| } |
| } |
| String builderString = builder.toString(); |
| if(builderString.length() > 256){ |
| if(WXEnvironment.isApkDebugable()){ |
| WXLogUtils.w(WXRecyclerTemplateList.TAG, " warn too big string " + builderString); |
| } |
| } |
| dynamic.put(key, builderString); |
| } |
| } |
| return dynamic; |
| } |
| |
| |
| public static Map<String, Object> renderProps(JSONObject props, ArrayStack context){ |
| Set<Map.Entry<String, Object>> entrySet = props.entrySet(); |
| Map<String, Object> renderProps = new ArrayMap<>(4); |
| for(Map.Entry<String, Object> entry : entrySet){ |
| Object value = entry.getValue(); |
| String key = entry.getKey(); |
| if(value instanceof JSONObject |
| && (((JSONObject) value).get(ELUtils.BINDING) instanceof Token)){ |
| JSONObject binding = (JSONObject) value; |
| Token block = (Token) (binding.get(ELUtils.BINDING)); |
| Object blockValue = block.execute(context); |
| renderProps.put(key, blockValue); |
| }else{ |
| renderProps.put(key, value); |
| } |
| } |
| return renderProps; |
| } |
| |
| public static List<Object> getBindingEventArgs(ArrayStack context, Object bindings){ |
| List<Object> params = new ArrayList<>(4); |
| if(bindings instanceof JSONArray){ |
| JSONArray array = (JSONArray) bindings; |
| for(int i=0; i<array.size(); i++){ |
| Object value = array.get(i); |
| if(value instanceof JSONObject |
| && (((JSONObject) value).get(ELUtils.BINDING) instanceof Token)){ |
| Token block = (Token)(((JSONObject) value).get(ELUtils.BINDING)); |
| Object blockValue = block.execute(context); |
| params.add(blockValue); |
| }else{ |
| params.add(value); |
| } |
| } |
| }else if(bindings instanceof JSONObject){ |
| JSONObject binding = (JSONObject) bindings; |
| if(binding.get(ELUtils.BINDING) instanceof Token){ |
| Token block = (Token) binding.get(ELUtils.BINDING); |
| Object blockValue = block.execute(context); |
| params.add(blockValue); |
| }else{ |
| params.add(bindings.toString()); |
| } |
| }else{ |
| params.add(bindings.toString()); |
| } |
| return params; |
| } |
| } |
