| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.android.ide.eclipse.adt.internal.editors.layout.gre; |
| |
| import static com.android.SdkConstants.ANDROID_WIDGET_PREFIX; |
| import static com.android.SdkConstants.VIEW_MERGE; |
| import static com.android.SdkConstants.VIEW_TAG; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.api.DropFeedback; |
| import com.android.ide.common.api.IDragElement; |
| import com.android.ide.common.api.IGraphics; |
| import com.android.ide.common.api.INode; |
| import com.android.ide.common.api.IViewRule; |
| import com.android.ide.common.api.InsertType; |
| import com.android.ide.common.api.Point; |
| import com.android.ide.common.api.Rect; |
| import com.android.ide.common.api.RuleAction; |
| import com.android.ide.common.api.SegmentType; |
| import com.android.ide.common.layout.ViewRule; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GCWrapper; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SimpleElement; |
| import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.sdklib.IAndroidTarget; |
| |
| import org.eclipse.core.resources.IProject; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * The rule engine manages the layout rules and interacts with them. |
| * There's one {@link RulesEngine} instance per layout editor. |
| * Each instance has 2 sets of rules: the static ADT rules (shared across all instances) |
| * and the project specific rules (local to the current instance / layout editor). |
| */ |
| public class RulesEngine { |
| private final IProject mProject; |
| private final Map<Object, IViewRule> mRulesCache = new HashMap<Object, IViewRule>(); |
| |
| /** |
| * The type of any upcoming node manipulations performed by the {@link IViewRule}s. |
| * When actions are performed in the tool (like a paste action, or a drag from palette, |
| * or a drag move within the canvas, etc), these are different types of inserts, |
| * and we don't want to have the rules track them closely (and pass them back to us |
| * in the {@link INode#insertChildAt} methods etc), so instead we track the state |
| * here on behalf of the currently executing rule. |
| */ |
| private InsertType mInsertType = InsertType.CREATE; |
| |
| /** |
| * Per-project loader for custom view rules |
| */ |
| private RuleLoader mRuleLoader; |
| private ClassLoader mUserClassLoader; |
| |
| /** |
| * The editor which owns this {@link RulesEngine} |
| */ |
| private final GraphicalEditorPart mEditor; |
| |
| /** |
| * Creates a new {@link RulesEngine} associated with the selected project. |
| * <p/> |
| * The rules engine will look in the project for a tools jar to load custom view rules. |
| * |
| * @param editor the editor which owns this {@link RulesEngine} |
| * @param project A non-null open project. |
| */ |
| public RulesEngine(GraphicalEditorPart editor, IProject project) { |
| mProject = project; |
| mEditor = editor; |
| |
| mRuleLoader = RuleLoader.get(project); |
| } |
| |
| /** |
| * Returns the {@link IProject} on which the {@link RulesEngine} was created. |
| */ |
| public IProject getProject() { |
| return mProject; |
| } |
| |
| /** |
| * Returns the {@link GraphicalEditorPart} for which the {@link RulesEngine} was |
| * created. |
| * |
| * @return the associated editor |
| */ |
| public GraphicalEditorPart getEditor() { |
| return mEditor; |
| } |
| |
| /** |
| * Called by the owner of the {@link RulesEngine} when it is going to be disposed. |
| * This frees some resources, such as the project's folder monitor. |
| */ |
| public void dispose() { |
| clearCache(); |
| } |
| |
| /** |
| * Invokes {@link IViewRule#getDisplayName()} on the rule matching the specified element. |
| * |
| * @param element The view element to target. Can be null. |
| * @return Null if the rule failed, there's no rule or the rule does not want to override |
| * the display name. Otherwise, a string as returned by the rule. |
| */ |
| public String callGetDisplayName(UiViewElementNode element) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(element); |
| |
| if (rule != null) { |
| try { |
| return rule.getDisplayName(); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.getDisplayName() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Invokes {@link IViewRule#addContextMenuActions(List, INode)} on the rule matching the specified element. |
| * |
| * @param selectedNode The node selected. Never null. |
| * @return Null if the rule failed, there's no rule or the rule does not provide |
| * any custom menu actions. Otherwise, a list of {@link RuleAction}. |
| */ |
| @Nullable |
| public List<RuleAction> callGetContextMenu(NodeProxy selectedNode) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(selectedNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| mInsertType = InsertType.CREATE; |
| List<RuleAction> actions = new ArrayList<RuleAction>(); |
| rule.addContextMenuActions(actions, selectedNode); |
| Collections.sort(actions); |
| |
| return actions; |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.getContextMenu() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Calls the selected node to return its default action |
| * |
| * @param selectedNode the node to apply the action to |
| * @return the default action id |
| */ |
| public String callGetDefaultActionId(@NonNull NodeProxy selectedNode) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(selectedNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| mInsertType = InsertType.CREATE; |
| return rule.getDefaultActionId(selectedNode); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.getDefaultAction() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Invokes {@link IViewRule#addLayoutActions(List, INode, List)} on the rule |
| * matching the specified element. |
| * |
| * @param actions The list of actions to add layout actions into |
| * @param parentNode The layout node |
| * @param children The selected children of the node, if any (used to |
| * initialize values of child layout controls, if applicable) |
| * @return Null if the rule failed, there's no rule or the rule does not |
| * provide any custom menu actions. Otherwise, a list of |
| * {@link RuleAction}. |
| */ |
| public List<RuleAction> callAddLayoutActions(List<RuleAction> actions, |
| NodeProxy parentNode, List<NodeProxy> children ) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(parentNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| mInsertType = InsertType.CREATE; |
| rule.addLayoutActions(actions, parentNode, children); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.getContextMenu() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Invokes {@link IViewRule#getSelectionHint(INode, INode)} |
| * on the rule matching the specified element. |
| * |
| * @param parentNode The parent of the node selected. Never null. |
| * @param childNode The child node that was selected. Never null. |
| * @return a list of strings to be displayed, or null or empty to display nothing |
| */ |
| public List<String> callGetSelectionHint(NodeProxy parentNode, NodeProxy childNode) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(parentNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| return rule.getSelectionHint(parentNode, childNode); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.getSelectionHint() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| public void callPaintSelectionFeedback(GCWrapper gcWrapper, NodeProxy parentNode, |
| List<? extends INode> childNodes, Object view) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(parentNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| rule.paintSelectionFeedback(gcWrapper, parentNode, childNodes, view); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.callPaintSelectionFeedback() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| |
| /** |
| * Called when the d'n'd starts dragging over the target node. |
| * If interested, returns a DropFeedback passed to onDrop/Move/Leave/Paint. |
| * If not interested in drop, return false. |
| * Followed by a paint. |
| */ |
| public DropFeedback callOnDropEnter(NodeProxy targetNode, |
| Object targetView, IDragElement[] elements) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(targetNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| return rule.onDropEnter(targetNode, targetView, elements); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onDropEnter() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Called after onDropEnter. |
| * Returns a DropFeedback passed to onDrop/Move/Leave/Paint (typically same |
| * as input one). |
| */ |
| public DropFeedback callOnDropMove(NodeProxy targetNode, |
| IDragElement[] elements, |
| DropFeedback feedback, |
| Point where) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(targetNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| return rule.onDropMove(targetNode, elements, feedback, where); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onDropMove() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Called when drop leaves the target without actually dropping |
| */ |
| public void callOnDropLeave(NodeProxy targetNode, |
| IDragElement[] elements, |
| DropFeedback feedback) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(targetNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| rule.onDropLeave(targetNode, elements, feedback); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onDropLeave() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| |
| /** |
| * Called when drop is released over the target to perform the actual drop. |
| */ |
| public void callOnDropped(NodeProxy targetNode, |
| IDragElement[] elements, |
| DropFeedback feedback, |
| Point where, |
| InsertType insertType) { |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(targetNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| mInsertType = insertType; |
| rule.onDropped(targetNode, elements, feedback, where); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onDropped() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| |
| /** |
| * Called when a paint has been requested via DropFeedback. |
| */ |
| public void callDropFeedbackPaint(IGraphics gc, |
| NodeProxy targetNode, |
| DropFeedback feedback) { |
| if (gc != null && feedback != null && feedback.painter != null) { |
| try { |
| feedback.painter.paint(gc, targetNode, feedback); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "DropFeedback.painter failed: %s", |
| e.toString()); |
| } |
| } |
| } |
| |
| /** |
| * Called when pasting elements in an existing document on the selected target. |
| * |
| * @param targetNode The first node selected. |
| * @param targetView The view object for the target node, or null if not known |
| * @param pastedElements The elements being pasted. |
| * @return the parent node the paste was applied into |
| */ |
| public NodeProxy callOnPaste(NodeProxy targetNode, Object targetView, |
| SimpleElement[] pastedElements) { |
| |
| // Find a target which accepts children. If you for example select a button |
| // and attempt to paste, this will reselect the parent of the button as the paste |
| // target. (This is a loop rather than just checking the direct parent since |
| // we will soon ask each child whether they are *willing* to accept the new child. |
| // A ScrollView for example, which only accepts one child, might also say no |
| // and delegate to its parent in turn. |
| INode parent = targetNode; |
| while (parent instanceof NodeProxy) { |
| NodeProxy np = (NodeProxy) parent; |
| if (np.getNode() != null && np.getNode().getDescriptor() != null) { |
| ElementDescriptor descriptor = np.getNode().getDescriptor(); |
| if (descriptor.hasChildren()) { |
| targetNode = np; |
| break; |
| } |
| } |
| parent = parent.getParent(); |
| } |
| |
| // try to find a rule for this element's FQCN |
| IViewRule rule = loadRule(targetNode.getNode()); |
| |
| if (rule != null) { |
| try { |
| mInsertType = InsertType.PASTE; |
| rule.onPaste(targetNode, targetView, pastedElements); |
| |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onPaste() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return targetNode; |
| } |
| |
| // ---- Resize operations ---- |
| |
| public DropFeedback callOnResizeBegin(NodeProxy child, NodeProxy parent, Rect newBounds, |
| SegmentType horizontalEdge, SegmentType verticalEdge, Object childView, |
| Object parentView) { |
| IViewRule rule = loadRule(parent.getNode()); |
| |
| if (rule != null) { |
| try { |
| return rule.onResizeBegin(child, parent, horizontalEdge, verticalEdge, |
| childView, parentView); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onResizeBegin() failed: %s", rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| |
| return null; |
| } |
| |
| public void callOnResizeUpdate(DropFeedback feedback, NodeProxy child, NodeProxy parent, |
| Rect newBounds, int modifierMask) { |
| IViewRule rule = loadRule(parent.getNode()); |
| |
| if (rule != null) { |
| try { |
| rule.onResizeUpdate(feedback, child, parent, newBounds, modifierMask); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onResizeUpdate() failed: %s", rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| |
| public void callOnResizeEnd(DropFeedback feedback, NodeProxy child, NodeProxy parent, |
| Rect newBounds) { |
| IViewRule rule = loadRule(parent.getNode()); |
| |
| if (rule != null) { |
| try { |
| rule.onResizeEnd(feedback, child, parent, newBounds); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onResizeEnd() failed: %s", rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| |
| // ---- Creation customizations ---- |
| |
| /** |
| * Invokes the create hooks ({@link IViewRule#onCreate}, |
| * {@link IViewRule#onChildInserted} when a new child has been created/pasted/moved, and |
| * is inserted into a given parent. The parent may be null (for example when rendering |
| * top level items for preview). |
| * |
| * @param editor the XML editor to apply edits to the model for (performed by view |
| * rules) |
| * @param parentNode the parent XML node, or null if unknown |
| * @param childNode the XML node of the new node, never null |
| * @param overrideInsertType If not null, specifies an explicit insert type to use for |
| * edits made during the customization |
| */ |
| public void callCreateHooks( |
| AndroidXmlEditor editor, |
| NodeProxy parentNode, NodeProxy childNode, |
| InsertType overrideInsertType) { |
| IViewRule parentRule = null; |
| |
| if (parentNode != null) { |
| UiViewElementNode parentUiNode = parentNode.getNode(); |
| parentRule = loadRule(parentUiNode); |
| } |
| |
| if (overrideInsertType != null) { |
| mInsertType = overrideInsertType; |
| } |
| |
| UiViewElementNode newUiNode = childNode.getNode(); |
| IViewRule childRule = loadRule(newUiNode); |
| if (childRule != null || parentRule != null) { |
| callCreateHooks(editor, mInsertType, parentRule, parentNode, |
| childRule, childNode); |
| } |
| } |
| |
| private static void callCreateHooks( |
| final AndroidXmlEditor editor, final InsertType insertType, |
| final IViewRule parentRule, final INode parentNode, |
| final IViewRule childRule, final INode newNode) { |
| // Notify the parent about the new child in case it wants to customize it |
| // (For example, a ScrollView parent can go and set all its children's layout params to |
| // fill the parent.) |
| if (!editor.isEditXmlModelPending()) { |
| editor.wrapEditXmlModel(new Runnable() { |
| @Override |
| public void run() { |
| callCreateHooks(editor, insertType, |
| parentRule, parentNode, childRule, newNode); |
| } |
| }); |
| return; |
| } |
| |
| if (parentRule != null) { |
| parentRule.onChildInserted(newNode, parentNode, insertType); |
| } |
| |
| // Look up corresponding IViewRule, and notify the rule about |
| // this create action in case it wants to customize the new object. |
| // (For example, a rule for TabHosts can go and create a default child tab |
| // when you create it.) |
| if (childRule != null) { |
| childRule.onCreate(newNode, parentNode, insertType); |
| } |
| |
| if (parentNode != null) { |
| ((NodeProxy) parentNode).applyPendingChanges(); |
| } |
| } |
| |
| /** |
| * Set the type of insert currently in progress |
| * |
| * @param insertType the insert type to use for the next operation |
| */ |
| public void setInsertType(InsertType insertType) { |
| mInsertType = insertType; |
| } |
| |
| /** |
| * Return the type of insert currently in progress |
| * |
| * @return the type of insert currently in progress |
| */ |
| public InsertType getInsertType() { |
| return mInsertType; |
| } |
| |
| // ---- Deletion ---- |
| |
| public void callOnRemovingChildren(NodeProxy parentNode, |
| List<INode> children) { |
| if (parentNode != null) { |
| UiViewElementNode parentUiNode = parentNode.getNode(); |
| IViewRule parentRule = loadRule(parentUiNode); |
| if (parentRule != null) { |
| try { |
| parentRule.onRemovingChildren(children, parentNode, |
| mInsertType == InsertType.MOVE_WITHIN); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onDispose() failed: %s", |
| parentRule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| } |
| |
| // ---- private --- |
| |
| /** |
| * Returns the descriptor for the base View class. |
| * This could be null if the SDK or the given platform target hasn't loaded yet. |
| */ |
| private ViewElementDescriptor getBaseViewDescriptor() { |
| Sdk currentSdk = Sdk.getCurrent(); |
| if (currentSdk != null) { |
| IAndroidTarget target = currentSdk.getTarget(mProject); |
| if (target != null) { |
| AndroidTargetData data = currentSdk.getTargetData(target); |
| return data.getLayoutDescriptors().getBaseViewDescriptor(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Clear the Rules cache. Calls onDispose() on each rule. |
| */ |
| private void clearCache() { |
| // The cache can contain multiple times the same rule instance for different |
| // keys (e.g. the UiViewElementNode key vs. the FQCN string key.) So transfer |
| // all values to a unique set. |
| HashSet<IViewRule> rules = new HashSet<IViewRule>(mRulesCache.values()); |
| |
| mRulesCache.clear(); |
| |
| for (IViewRule rule : rules) { |
| if (rule != null) { |
| try { |
| rule.onDispose(); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onDispose() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Checks whether the project class loader has changed, and if so |
| * unregisters any view rules that use classes from the old class loader. It |
| * then returns the class loader to be used. |
| */ |
| private ClassLoader updateClassLoader() { |
| ClassLoader classLoader = mRuleLoader.getClassLoader(); |
| if (mUserClassLoader != null && classLoader != mUserClassLoader) { |
| // We have to unload all the IViewRules from the old class |
| List<Object> dispose = new ArrayList<Object>(); |
| for (Map.Entry<Object, IViewRule> entry : mRulesCache.entrySet()) { |
| IViewRule rule = entry.getValue(); |
| if (rule.getClass().getClassLoader() == mUserClassLoader) { |
| dispose.add(entry.getKey()); |
| } |
| } |
| for (Object object : dispose) { |
| mRulesCache.remove(object); |
| } |
| } |
| |
| mUserClassLoader = classLoader; |
| return mUserClassLoader; |
| } |
| |
| /** |
| * Load a rule using its descriptor. This will try to first load the rule using its |
| * actual FQCN and if that fails will find the first parent that works in the view |
| * hierarchy. |
| */ |
| private IViewRule loadRule(UiViewElementNode element) { |
| if (element == null) { |
| return null; |
| } |
| |
| String targetFqcn = null; |
| ViewElementDescriptor targetDesc = null; |
| |
| ElementDescriptor d = element.getDescriptor(); |
| if (d instanceof ViewElementDescriptor) { |
| targetDesc = (ViewElementDescriptor) d; |
| } |
| if (d == null || !(d instanceof ViewElementDescriptor)) { |
| // This should not happen. All views should have some kind of *view* element |
| // descriptor. Maybe the project is not complete and doesn't build or something. |
| // In this case, we'll use the descriptor of the base android View class. |
| targetDesc = getBaseViewDescriptor(); |
| } |
| |
| // Check whether any of the custom view .jar files have changed and if so |
| // unregister previously cached view rules to force a new view rule to be loaded. |
| updateClassLoader(); |
| |
| // Return the rule if we find it in the cache, even if it was stored as null |
| // (which means we didn't find it earlier, so don't look for it again) |
| IViewRule rule = mRulesCache.get(targetDesc); |
| if (rule != null || mRulesCache.containsKey(targetDesc)) { |
| return rule; |
| } |
| |
| // Get the descriptor and loop through the super class hierarchy |
| for (ViewElementDescriptor desc = targetDesc; |
| desc != null; |
| desc = desc.getSuperClassDesc()) { |
| |
| // Get the FQCN of this View |
| String fqcn = desc.getFullClassName(); |
| if (fqcn == null) { |
| // Shouldn't be happening. |
| return null; |
| } |
| |
| // The first time we keep the FQCN around as it's the target class we were |
| // initially trying to load. After, as we move through the hierarchy, the |
| // target FQCN remains constant. |
| if (targetFqcn == null) { |
| targetFqcn = fqcn; |
| } |
| |
| if (fqcn.indexOf('.') == -1) { |
| // Deal with unknown descriptors; these lack the full qualified path and |
| // elements in the layout without a package are taken to be in the |
| // android.widget package. |
| fqcn = ANDROID_WIDGET_PREFIX + fqcn; |
| } |
| |
| // Try to find a rule matching the "real" FQCN. If we find it, we're done. |
| // If not, the for loop will move to the parent descriptor. |
| rule = loadRule(fqcn, targetFqcn); |
| if (rule != null) { |
| // We found one. |
| // As a side effect, loadRule() also cached the rule using the target FQCN. |
| return rule; |
| } |
| } |
| |
| // Memorize in the cache that we couldn't find a rule for this descriptor |
| mRulesCache.put(targetDesc, null); |
| return null; |
| } |
| |
| /** |
| * Try to load a rule given a specific FQCN. This looks for an exact match in either |
| * the ADT scripts or the project scripts and does not look at parent hierarchy. |
| * <p/> |
| * Once a rule is found (or not), it is stored in a cache using its target FQCN |
| * so we don't try to reload it. |
| * <p/> |
| * The real FQCN is the actual rule class we're loading, e.g. "android.view.View" |
| * where target FQCN is the class we were initially looking for, which might be the same as |
| * the real FQCN or might be a derived class, e.g. "android.widget.TextView". |
| * |
| * @param realFqcn The FQCN of the rule class actually being loaded. |
| * @param targetFqcn The FQCN of the class actually processed, which might be different from |
| * the FQCN of the rule being loaded. |
| */ |
| IViewRule loadRule(String realFqcn, String targetFqcn) { |
| if (realFqcn == null || targetFqcn == null) { |
| return null; |
| } |
| |
| // Return the rule if we find it in the cache, even if it was stored as null |
| // (which means we didn't find it earlier, so don't look for it again) |
| IViewRule rule = mRulesCache.get(realFqcn); |
| if (rule != null || mRulesCache.containsKey(realFqcn)) { |
| return rule; |
| } |
| |
| // Look for class via reflection |
| try { |
| // For now, we package view rules for the builtin Android views and |
| // widgets with the tool in a special package, so look there rather |
| // than in the same package as the widgets. |
| String ruleClassName; |
| ClassLoader classLoader; |
| if (realFqcn.startsWith("android.") || //$NON-NLS-1$ |
| realFqcn.equals(VIEW_MERGE) || |
| realFqcn.endsWith(".GridLayout") || //$NON-NLS-1$ // Temporary special case |
| // FIXME: Remove this special case as soon as we pull |
| // the MapViewRule out of this code base and bundle it |
| // with the add ons |
| realFqcn.startsWith("com.google.android.maps.")) { //$NON-NLS-1$ |
| // This doesn't handle a case where there are name conflicts |
| // (e.g. where there are multiple different views with the same |
| // class name and only differing in package names, but that's a |
| // really bad practice in the first place, and if that situation |
| // should come up in the API we can enhance this algorithm. |
| String packageName = ViewRule.class.getName(); |
| packageName = packageName.substring(0, packageName.lastIndexOf('.')); |
| classLoader = RulesEngine.class.getClassLoader(); |
| int dotIndex = realFqcn.lastIndexOf('.'); |
| String baseName = realFqcn.substring(dotIndex+1); |
| // Capitalize rule class name to match naming conventions, if necessary (<merge>) |
| if (Character.isLowerCase(baseName.charAt(0))) { |
| if (baseName.equals(VIEW_TAG)) { |
| // Hack: ViewRule is generic for the "View" class, so we can't use it |
| // for the special XML "view" tag (lowercase); instead, the rule is |
| // named "ViewTagRule" instead. |
| baseName = "ViewTag"; //$NON-NLS-1$ |
| } |
| baseName = Character.toUpperCase(baseName.charAt(0)) + baseName.substring(1); |
| } |
| ruleClassName = packageName + "." + //$NON-NLS-1$ |
| baseName + "Rule"; //$NON-NLS-1$ |
| } else { |
| // Initialize the user-classpath for 3rd party IViewRules, if necessary |
| classLoader = updateClassLoader(); |
| if (classLoader == null) { |
| // The mUserClassLoader can be null; this is the typical scenario, |
| // when the user is only using builtin layout rules. |
| // This means however we can't resolve this fqcn since it's not |
| // in the name space of the builtin rules. |
| mRulesCache.put(realFqcn, null); |
| return null; |
| } |
| |
| // For other (3rd party) widgets, look in the same package (though most |
| // likely not in the same jar!) |
| ruleClassName = realFqcn + "Rule"; //$NON-NLS-1$ |
| } |
| |
| Class<?> clz = Class.forName(ruleClassName, true, classLoader); |
| rule = (IViewRule) clz.newInstance(); |
| return initializeRule(rule, targetFqcn); |
| } catch (ClassNotFoundException ex) { |
| // Not an unexpected error - this means that there isn't a helper for this |
| // class. |
| } catch (InstantiationException e) { |
| // This is NOT an expected error: fail. |
| AdtPlugin.log(e, "load rule error (%s): %s", realFqcn, e.toString()); |
| } catch (IllegalAccessException e) { |
| // This is NOT an expected error: fail. |
| AdtPlugin.log(e, "load rule error (%s): %s", realFqcn, e.toString()); |
| } |
| |
| // Memorize in the cache that we couldn't find a rule for this real FQCN |
| mRulesCache.put(realFqcn, null); |
| return null; |
| } |
| |
| /** |
| * Initialize a rule we just loaded. The rule has a chance to examine the target FQCN |
| * and bail out. |
| * <p/> |
| * Contract: the rule is not in the {@link #mRulesCache} yet and this method will |
| * cache it using the target FQCN if the rule is accepted. |
| * <p/> |
| * The real FQCN is the actual rule class we're loading, e.g. "android.view.View" |
| * where target FQCN is the class we were initially looking for, which might be the same as |
| * the real FQCN or might be a derived class, e.g. "android.widget.TextView". |
| * |
| * @param rule A rule freshly loaded. |
| * @param targetFqcn The FQCN of the class actually processed, which might be different from |
| * the FQCN of the rule being loaded. |
| * @return The rule if accepted, or null if the rule can't handle that FQCN. |
| */ |
| private IViewRule initializeRule(IViewRule rule, String targetFqcn) { |
| |
| try { |
| if (rule.onInitialize(targetFqcn, new ClientRulesEngine(this, targetFqcn))) { |
| // Add it to the cache and return it |
| mRulesCache.put(targetFqcn, rule); |
| return rule; |
| } else { |
| rule.onDispose(); |
| } |
| } catch (Exception e) { |
| AdtPlugin.log(e, "%s.onInit() failed: %s", |
| rule.getClass().getSimpleName(), |
| e.toString()); |
| } |
| |
| return null; |
| } |
| } |
