layout/relative/DeletionHandler.java

/*
 * 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;
    }
}