Java tutorial
/* * Copyright (C) 2012 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.common.layout.relative; import static com.android.SdkConstants.ANDROID_URI; import static com.android.SdkConstants.ATTR_ID; import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN; import static com.android.SdkConstants.ATTR_LAYOUT_RESOURCE_PREFIX; import static com.android.SdkConstants.ID_PREFIX; import static com.android.SdkConstants.NEW_ID_PREFIX; import static com.android.ide.common.layout.BaseViewRule.stripIdPrefix; import static com.android.ide.common.layout.relative.ConstraintType.LAYOUT_CENTER_HORIZONTAL; import static com.android.ide.common.layout.relative.ConstraintType.LAYOUT_CENTER_VERTICAL; import com.android.SdkConstants; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.ide.common.api.INode; import com.android.ide.common.api.INode.IAttribute; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import java.util.List; import java.util.Map; import java.util.Set; /** * Handles deletions in a relative layout, transferring constraints across * deleted nodes * <p> * TODO: Consider adding the * {@link SdkConstants#ATTR_LAYOUT_ALIGN_WITH_PARENT_MISSING} attribute to a * node if it's pointing to a node which is deleted and which has no transitive * reference to another node. */ public class DeletionHandler { private final INode mLayout; private final INode[] mChildren; private final List<INode> mDeleted; private final Set<String> mDeletedIds; private final Map<String, INode> mNodeMap; private final List<INode> mMoved; /** * Creates a new {@link DeletionHandler} * * @param deleted the deleted nodes * @param moved nodes that were moved (e.g. deleted, but also inserted elsewhere) * @param layout the parent layout of the deleted nodes */ public DeletionHandler(@NonNull List<INode> deleted, @NonNull List<INode> moved, @NonNull INode layout) { mDeleted = deleted; mMoved = moved; mLayout = layout; mChildren = mLayout.getChildren(); mNodeMap = Maps.newHashMapWithExpectedSize(mChildren.length); for (INode child : mChildren) { String id = child.getStringAttr(ANDROID_URI, ATTR_ID); if (id != null) { mNodeMap.put(stripIdPrefix(id), child); } } mDeletedIds = Sets.newHashSetWithExpectedSize(mDeleted.size()); for (INode node : mDeleted) { String id = node.getStringAttr(ANDROID_URI, ATTR_ID); if (id != null) { mDeletedIds.add(stripIdPrefix(id)); } } // Any widgets that remain (e.g. typically because they were moved) should // keep their incoming dependencies for (INode node : mMoved) { String id = node.getStringAttr(ANDROID_URI, ATTR_ID); if (id != null) { mDeletedIds.remove(stripIdPrefix(id)); } } } @Nullable private static String getId(@NonNull IAttribute attribute) { if (attribute.getName().startsWith(ATTR_LAYOUT_RESOURCE_PREFIX) && ANDROID_URI.equals(attribute.getUri()) && !attribute.getName().startsWith(ATTR_LAYOUT_MARGIN)) { String id = attribute.getValue(); // It might not be an id reference, so check manually rather than just // calling stripIdPrefix(): if (id.startsWith(NEW_ID_PREFIX)) { return id.substring(NEW_ID_PREFIX.length()); } else if (id.startsWith(ID_PREFIX)) { return id.substring(ID_PREFIX.length()); } } return null; } /** * Updates the constraints in the layout to handle deletion of a set of * nodes. This ensures that any constraints pointing to one of the deleted * nodes are changed properly to point to a non-deleted node with similar * constraints. */ public void updateConstraints() { if (mChildren.length == mDeleted.size()) { // Deleting everything: Nothing to be done return; } // Now remove incoming edges to any views that were deleted. If possible, // don't just delete them but replace them with a transitive constraint, e.g. // if we have "A <= B <= C" and "B" is removed, then we end up with "A <= C", for (INode child : mChildren) { if (mDeleted.contains(child)) { continue; } for (IAttribute attribute : child.getLiveAttributes()) { String id = getId(attribute); if (id != null) { if (mDeletedIds.contains(id)) { // Unset this reference to a deleted widget. It might be // replaced if the pointed to node points to some other node // on the same side, but it may use a different constraint name, // or have none at all (e.g. parent). String name = attribute.getName(); child.setAttribute(ANDROID_URI, name, null); INode deleted = mNodeMap.get(id); if (deleted != null) { ConstraintType type = ConstraintType.fromAttribute(name); if (type != null) { transfer(deleted, child, type, 0); } } } } } } } private void transfer(INode deleted, INode target, ConstraintType targetType, int depth) { if (depth == 20) { // Prevent really deep flow or unbounded recursion in case there is a bug in // the cycle detection code return; } assert mDeleted.contains(deleted); for (IAttribute attribute : deleted.getLiveAttributes()) { String name = attribute.getName(); ConstraintType type = ConstraintType.fromAttribute(name); if (type == null) { continue; } ConstraintType transfer = getCompatibleConstraint(type, targetType); if (transfer != null) { String id = getId(attribute); if (id != null) { if (mDeletedIds.contains(id)) { INode nextDeleted = mNodeMap.get(id); if (nextDeleted != null) { // Points to another deleted node: recurse transfer(nextDeleted, target, targetType, depth + 1); } } else { // Found an undeleted node destination: point to it directly. // Note that we're using the target.setAttribute(ANDROID_URI, transfer.name, attribute.getValue()); } } else { // Pointing to parent or center etc (non-id ref): replicate this on the target target.setAttribute(ANDROID_URI, name, attribute.getValue()); } } } } /** * Determines if two constraints are in the same direction and if so returns * the constraint in the same direction. Rather than returning boolean true * or false, this returns the constraint which is sometimes modified. For * example, if you have a node which points left to a node which is centered * in parent, then the constraint is turned into center horizontal. */ @Nullable private static ConstraintType getCompatibleConstraint(@NonNull ConstraintType first, @NonNull ConstraintType second) { if (first == second) { return first; } switch (second) { case ALIGN_LEFT: case LAYOUT_RIGHT_OF: switch (first) { case LAYOUT_CENTER_HORIZONTAL: case LAYOUT_LEFT_OF: case ALIGN_LEFT: return first; case LAYOUT_CENTER_IN_PARENT: return LAYOUT_CENTER_HORIZONTAL; } return null; case ALIGN_RIGHT: case LAYOUT_LEFT_OF: switch (first) { case LAYOUT_CENTER_HORIZONTAL: case ALIGN_RIGHT: case LAYOUT_LEFT_OF: return first; case LAYOUT_CENTER_IN_PARENT: return LAYOUT_CENTER_HORIZONTAL; } return null; case ALIGN_TOP: case LAYOUT_BELOW: case ALIGN_BASELINE: switch (first) { case LAYOUT_CENTER_VERTICAL: case ALIGN_TOP: case LAYOUT_BELOW: case ALIGN_BASELINE: return first; case LAYOUT_CENTER_IN_PARENT: return LAYOUT_CENTER_VERTICAL; } return null; case ALIGN_BOTTOM: case LAYOUT_ABOVE: switch (first) { case LAYOUT_CENTER_VERTICAL: case ALIGN_BOTTOM: case LAYOUT_ABOVE: case ALIGN_BASELINE: return first; case LAYOUT_CENTER_IN_PARENT: return LAYOUT_CENTER_VERTICAL; } return null; } return null; } }