android/app/slice/SliceQuery.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * 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.
 */

package android.app.slice;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Queue;
import java.util.Spliterators;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

/**
 * A bunch of utilities for searching the contents of a slice.
 * @hide
 */
public class SliceQuery {
    private static final String TAG = "SliceQuery";

    /**
     * @hide
     */
    public static SliceItem getPrimaryIcon(Slice slice) {
        for (SliceItem item : slice.getItems()) {
            if (Objects.equals(item.getFormat(), SliceItem.FORMAT_IMAGE)) {
                return item;
            }
            if (!(compareTypes(item, SliceItem.FORMAT_SLICE)
                    && item.hasHint(Slice.HINT_LIST))
                    && !item.hasHint(Slice.HINT_ACTIONS)
                    && !item.hasHint(Slice.HINT_LIST_ITEM)
                    && !compareTypes(item, SliceItem.FORMAT_ACTION)) {
                SliceItem icon = SliceQuery.find(item, SliceItem.FORMAT_IMAGE);
                if (icon != null) {
                    return icon;
                }
            }
        }
        return null;
    }

    /**
     * @hide
     */
    public static SliceItem findNotContaining(SliceItem container, List<SliceItem> list) {
        SliceItem ret = null;
        while (ret == null && list.size() != 0) {
            SliceItem remove = list.remove(0);
            if (!contains(container, remove)) {
                ret = remove;
            }
        }
        return ret;
    }

    /**
     * @hide
     */
    private static boolean contains(SliceItem container, SliceItem item) {
        if (container == null || item == null) return false;
        return stream(container).filter(s -> (s == item)).findAny().isPresent();
    }

    /**
     * @hide
     */
    public static List<SliceItem> findAll(SliceItem s, String type) {
        return findAll(s, type, (String[]) null, null);
    }

    /**
     * @hide
     */
    public static List<SliceItem> findAll(SliceItem s, String type, String hints, String nonHints) {
        return findAll(s, type, new String[]{ hints }, new String[]{ nonHints });
    }

    /**
     * @hide
     */
    public static List<SliceItem> findAll(SliceItem s, String type, String[] hints,
            String[] nonHints) {
        return stream(s).filter(item -> compareTypes(item, type)
                && (item.hasHints(hints) && !item.hasAnyHints(nonHints)))
                .collect(Collectors.toList());
    }

    /**
     * @hide
     */
    public static SliceItem find(Slice s, String type, String hints, String nonHints) {
        return find(s, type, new String[]{ hints }, new String[]{ nonHints });
    }

    /**
     * @hide
     */
    public static SliceItem find(Slice s, String type) {
        return find(s, type, (String[]) null, null);
    }

    /**
     * @hide
     */
    public static SliceItem find(SliceItem s, String type) {
        return find(s, type, (String[]) null, null);
    }

    /**
     * @hide
     */
    public static SliceItem find(SliceItem s, String type, String hints, String nonHints) {
        return find(s, type, new String[]{ hints }, new String[]{ nonHints });
    }

    /**
     * @hide
     */
    public static SliceItem find(Slice s, String type, String[] hints, String[] nonHints) {
        List<String> h = s.getHints();
        return find(new SliceItem(s, SliceItem.FORMAT_SLICE, null, h.toArray(new String[h.size()])),
                type, hints, nonHints);
    }

    /**
     * @hide
     */
    public static SliceItem find(SliceItem s, String type, String[] hints, String[] nonHints) {
        return stream(s).filter(item -> compareTypes(item, type)
                && (item.hasHints(hints) && !item.hasAnyHints(nonHints))).findFirst().orElse(null);
    }

    /**
     * @hide
     */
    public static Stream<SliceItem> stream(SliceItem slice) {
        Queue<SliceItem> items = new LinkedList();
        items.add(slice);
        Iterator<SliceItem> iterator = new Iterator<SliceItem>() {
            @Override
            public boolean hasNext() {
                return items.size() != 0;
            }

            @Override
            public SliceItem next() {
                SliceItem item = items.poll();
                if (compareTypes(item, SliceItem.FORMAT_SLICE)
                        || compareTypes(item, SliceItem.FORMAT_ACTION)) {
                    items.addAll(item.getSlice().getItems());
                }
                return item;
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    }

    /**
     * @hide
     */
    public static boolean compareTypes(SliceItem item, String desiredType) {
        final int typeLength = desiredType.length();
        if (typeLength == 3 && desiredType.equals("*/*")) {
            return true;
        }
        if (item.getSubType() == null && desiredType.indexOf('/') < 0) {
            return item.getFormat().equals(desiredType);
        }
        return (item.getFormat() + "/" + item.getSubType())
                .matches(desiredType.replaceAll("\\*", ".*"));
    }
}