xref: /development/samples/IntentPlayground/src/com/example/android/intentplayground/IntentBuilderView.java

/*
 * Copyright (C) 2018 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 com.example.android.intentplayground;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.ColorStateList;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Displays options to build an intent with different configurations of flags
 * and target activities, and allows the user to launch an activity with the built intent.
 */
public class IntentBuilderView extends FrameLayout implements View.OnClickListener,
        CompoundButton.OnCheckedChangeListener {
    private static final String TAG = "IntentBuilderView";
    protected final int TAG_FLAG = R.id.tag_flag;
    protected final int TAG_SUGGESTED = R.id.tag_suggested;
    protected ComponentName mActivityToLaunch;
    private boolean mVerifyMode;
    private ColorStateList mSuggestTint;
    private ColorStateList mDefaultTint;
    private LinearLayout mLayout;
    private Context mContext;
    private LayoutInflater mInflater;
    private List<RadioButton> mRadioButtons;

    /**
     * Constructs a new IntentBuilderView, in the specified mode.
     *
     * @param context The context of the activity that holds this view.
     * @param mode    The mode to launch in (if null, default mode turns suggestions off). Passing
     *                {@link BaseActivity.Mode} will turn on suggestions
     *                by default.
     */
    public IntentBuilderView(@NonNull Context context, BaseActivity.Mode mode) {
        super(context);
        mContext = context;
        mInflater = LayoutInflater.from(context);
        mLayout = (LinearLayout) mInflater.inflate(R.layout.view_build_intent,
                this /* root */, false /* attachToRoot */);
        addView(mLayout, new LayoutParams(LayoutParams.MATCH_PARENT,
                LayoutParams.MATCH_PARENT));
        mActivityToLaunch = new ComponentName(context,
                TaskAffinity1Activity.class);
        mSuggestTint = context.getColorStateList(R.color.suggested_checkbox);
        mDefaultTint = context.getColorStateList(R.color.default_checkbox);
        mVerifyMode = mode != null && mode == BaseActivity.Mode.VERIFY;
        setTag(BaseActivity.BUILDER_VIEW);
        setId(R.id.build_intent_container);
        setBackground(context.getResources().getDrawable(R.drawable.card_background,
                null /*theme*/));
        setupViews();
    }

    private Class<?> getClass(String name) {
        String fullName = mContext.getPackageName().concat(".").concat(name);
        try {
            return Class.forName(fullName);
        } catch (ClassNotFoundException e) {
            if (BuildConfig.DEBUG) e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    private void setupViews() {
        PackageInfo packInfo;

        // Retrieve activities and their manifest flags
        PackageManager pm = mContext.getPackageManager();
        try {
            packInfo = pm.getPackageInfo(mContext.getPackageName(), PackageManager.GET_ACTIVITIES);
        } catch (PackageManager.NameNotFoundException e) {
            Toast.makeText(mContext,
                    "Cannot find activities, this should never happen " + e.toString(),
                    Toast.LENGTH_SHORT).show();
            throw new RuntimeException(e);
        }
        List<ActivityInfo> activities = Arrays.asList(packInfo.activities);
        Map<ActivityInfo, List<String>> activityToFlags = new HashMap<>();
        activities.forEach(activityInfo ->
                activityToFlags.put(activityInfo, FlagUtils.getActivityFlags(activityInfo)));

        // Get handles to views
        LinearLayout flagBuilderLayout = mLayout.findViewById(R.id.build_intent_flags);
        RadioGroup activityRadios = mLayout.findViewById(R.id.radioGroup_launchMode);
        // Populate views with text
        fillCheckBoxLayout(flagBuilderLayout, FlagUtils.intentFlagsByCategory(),
                R.layout.section_header, R.id.header_title, R.layout.checkbox_list_item,
                R.id.checkBox_item);

        // Add radios for activity combos
        List<RadioButton> radioButtons = new ArrayList<>();
        activityToFlags.entrySet().stream()
                .sorted(Comparator.comparing(
                        activityEntry -> nameOfActivityInfo(activityEntry.getKey())))
                .forEach(activityEntry -> {
                    ActivityInfo activityInfo = activityEntry.getKey();
                    List<String> manifestFlags = activityEntry.getValue();

                    LinearLayout actRadio = (LinearLayout) mInflater
                            .inflate(R.layout.activity_radio_list_item, null /* root */);
                    RadioButton rb = actRadio.findViewById(R.id.radio_launchMode);
                    rb.setText(activityInfo.name.substring(activityInfo.name.lastIndexOf('.') + 1));
                    rb.setTag(activityInfo);
                    ((TextView) actRadio.findViewById(R.id.activity_desc)).setText(
                            manifestFlags.stream().collect(Collectors.joining("\n")));
                    rb.setOnClickListener(this);
                    activityRadios.addView(actRadio);
                    radioButtons.add(rb);
                });
        ((CompoundButton) mLayout.findViewById(R.id.suggestion_switch))
                .setOnCheckedChangeListener(this);
        mRadioButtons = radioButtons;
    }


    private String nameOfActivityInfo(ActivityInfo activityInfo) {
        return activityInfo.name.substring(activityInfo.name.lastIndexOf('.') + 1);
    }

    /**
     * Fills the {@link ViewGroup} with a list separated by section
     *
     * @param layout            The layout to fill
     * @param categories        A map of category names to list items within that category
     * @param categoryLayoutRes the layout resource of the category header view
     * @param categoryViewId    the resource id of the category {@link TextView} within the layout
     * @param itemLayoutRes     the layout resource of the list item view
     * @param itemViewId        the resource id of the item {@link TextView} within the item layout
     */
    private void fillCheckBoxLayout(ViewGroup layout, Map<String, List<String>> categories,
            int categoryLayoutRes, int categoryViewId, int itemLayoutRes, int itemViewId) {
        layout.removeAllViews();
        for (String category : categories.keySet()) {
            View categoryLayout = mInflater.inflate(categoryLayoutRes, layout,
                    false /* attachToRoot */);
            TextView categoryView = categoryLayout.findViewById(categoryViewId);
            categoryView.setText(category);
            layout.addView(categoryLayout);
            for (String item : categories.get(category)) {
                View itemLayout = mInflater.inflate(itemLayoutRes, layout,
                        false /* attachToRoot */);
                CheckBox itemView = itemLayout.findViewById(itemViewId);
                IntentFlag flag = FlagUtils.getFlagForString(item);
                itemView.setTag(TAG_FLAG, flag);
                itemView.setText(item);
                itemView.setOnCheckedChangeListener(this);
                layout.addView(itemLayout);
            }
        }
    }

    @Override
    public void onClick(View view) {
        // Handles selection of target activity
        if (view instanceof RadioButton) {
            ActivityInfo tag = (ActivityInfo) view.getTag();
            mActivityToLaunch = new ComponentName(mContext,
                    getClass(tag.name.substring(tag.name.lastIndexOf(".") + 1)));
            mRadioButtons.stream().filter(rb -> rb != view)
                    .forEach(rb -> rb.setChecked(false));
        }
    }

    public Intent currentIntent() {
        LinearLayout flagBuilder = mLayout.findViewById(R.id.build_intent_flags);
        Intent intent = new Intent();
        // Gather flags from flag builder checkbox list
        childrenOfGroup(flagBuilder, CheckBox.class)
                .forEach(checkbox -> {
                    int flagVal = FlagUtils.flagValue(checkbox.getText().toString());
                    if (checkbox.isChecked()) {
                        intent.addFlags(flagVal);
                    } else {
                        intent.removeFlags(flagVal);
                    }
                });
        intent.setComponent(mActivityToLaunch);
        return intent;
    }


    public boolean startForResult() {
        RadioButton startNormal = mLayout.findViewById(R.id.start_normal);
        return !startNormal.isChecked();
    }

    @Override
    public void onCheckedChanged(CompoundButton compoundButton, boolean checked) {
        int buttonId = compoundButton.getId();
        if (buttonId == R.id.checkBox_item) {
            // A checkbox was checked/unchecked
            IntentFlag flag = (IntentFlag) compoundButton.getTag(TAG_FLAG);
            if (flag != null && mVerifyMode) {
                refreshConstraints();
                if (checked) {
                    suggestFlags(flag);
                    selectFlags(flag.getRequests());
                } else {
                    clearSuggestions();
                }
            }
        } else if (buttonId == R.id.suggestion_switch) {
            // Suggestions were turned on/off
            clearSuggestions();
            mVerifyMode = checked;
            if (mVerifyMode) {
                refreshConstraints();
                getCheckedFlags().forEach(this::suggestFlags);
            } else {
                enableAllFlags();
            }
        }
    }

    private void refreshConstraints() {
        enableAllFlags();
        getCheckedFlags().forEach(flag -> disableFlags(flag.getConflicts()));
    }

    private void suggestFlags(IntentFlag flag) {
        clearSuggestions();
        List<String> suggestions = flag.getComplements().stream().map(IntentFlag::getName)
                .collect(Collectors.toList());
        getAllCheckBoxes().stream()
                .filter(box -> hasSuggestion(suggestions, box))
                .forEach(box -> {
                    box.setButtonTintList(mSuggestTint);
                    box.setTag(TAG_SUGGESTED, true);
                });
    }

    private boolean hasSuggestion(List<String> suggestions, CheckBox box) {
        IntentFlag flag = (IntentFlag) box.getTag(TAG_FLAG);
        if (flag != null) {
            return suggestions.contains(flag.getName());
        } else {
            Log.w(TAG, "Unknown flag: " + box.getText());
            return false;
        }
    }

    private void clearSuggestions() {
        getAllCheckBoxes().forEach(box -> box.setButtonTintList(mDefaultTint));
    }

    /**
     * Clears all of the checkboxes in this builder.
     */
    public void clearFlags() {
        getAllCheckBoxes().forEach(box -> box.setChecked(false));
    }

    private List<CheckBox> getAllCheckBoxes() {
        View layout = mLayout;
        ViewGroup flagBuilder = (LinearLayout) layout.findViewById(R.id.build_intent_flags);
        List<CheckBox> checkBoxes = new LinkedList<>();
        for (int i = 0; i < flagBuilder.getChildCount(); i++) {
            View child = flagBuilder.getChildAt(i);
            if (child instanceof CheckBox) {
                checkBoxes.add((CheckBox) child);
            }
        }
        return checkBoxes;
    }

    /**
     * Retrieve children of a certain type from a {@link ViewGroup}.
     *
     * @param group the ViewGroup to retrieve children from.
     */
    protected static <T> List<T> childrenOfGroup(ViewGroup group, Class<T> viewType) {
        List<T> list = new LinkedList<>();
        for (int i = 0; i < group.getChildCount(); i++) {
            View v = group.getChildAt(i);
            if (viewType.isAssignableFrom(v.getClass())) list.add(viewType.cast(v));
        }
        return list;
    }

    /**
     * Selects the checkboxes for the given list of flags.
     *
     * @param flags A list of mIntent flags to select.
     */
    public void selectFlags(List<String> flags) {
        getAllCheckBoxes().forEach(box -> {
            if (flags.contains(box.getText())) {
                box.setChecked(true);
            }
        });
    }

    /**
     * Selects the checkboxes for the given list of flags.
     *
     * @param flags A list of mIntent flags to select.
     */
    public void selectFlags(Collection<IntentFlag> flags) {
        selectFlags(flags.stream().map(IntentFlag::getName).collect(Collectors.toList()));
    }

    private void enableAllFlags() {
        getAllCheckBoxes().forEach(box -> box.setEnabled(true));
    }

    private Collection<CheckBox> getChecked() {
        return getAllCheckBoxes().stream().filter(CompoundButton::isChecked)
                .collect(Collectors.toList());
    }

    private Collection<IntentFlag> getCheckedFlags() {
        return getChecked().stream().map(checkBox -> (IntentFlag) checkBox.getTag(TAG_FLAG))
                .collect(Collectors.toList());
    }

    private void disableFlags(Collection<IntentFlag> flags) {
        flags.forEach(flag -> getCheckBox(flag).setEnabled(false));
    }

    private CheckBox getCheckBox(IntentFlag flag) {
        return getAllCheckBoxes().stream().filter(box -> flag.getName().equals(box.getText()))
                .findFirst().orElse(null);
    }

    /**
     * A functional interface that represents the action to take upon the user pressing the launch
     * button within this view.
     */
    public interface OnLaunchCallback {
        void launchActivity(Intent intent, boolean forResult);
    }
}