/*
 * Copyright (C) 2010 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.android.cts.verifier;

import static com.android.cts.verifier.ReportExporter.LOGS_DIRECTORY;
import static com.android.cts.verifier.TestListActivity.sCurrentDisplayMode;

import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.ContentObserver;
import android.database.Cursor;
import android.hardware.devicestate.DeviceStateManager;
import android.os.AsyncTask;
import android.os.Environment;
import android.os.Handler;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.TextView;

import com.android.compatibility.common.util.ReportLog;
import com.android.compatibility.common.util.TestScreenshotsMetadata;
import com.android.cts.verifier.TestListActivity.DisplayMode;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;

/**
 * {@link BaseAdapter} that handles loading, refreshing, and setting test results. What tests are
 * shown can be customized by overriding {@link #getRows()}. See {@link ArrayTestListAdapter} and
 * {@link ManifestTestListAdapter} for examples.
 */
public abstract class TestListAdapter extends BaseAdapter {

    /** Activities implementing {@link Intent#ACTION_MAIN} and this will appear in the list. */
    public static final String CATEGORY_MANUAL_TEST = "android.cts.intent.category.MANUAL_TEST";

    /** View type for a category of tests like "Sensors" or "Features" */
    private static final int CATEGORY_HEADER_VIEW_TYPE = 0;

    /** View type for an actual test like the Accelerometer test. */
    private static final int TEST_VIEW_TYPE = 1;

    /** Padding around the text views and icons. */
    private static final int PADDING = 10;

    private final Context mContext;

    /** Immutable data of tests like the test's title and launch intent. */
    private final List<TestListItem> mRows = new ArrayList<TestListItem>();

    /** Mutable test results that will change as each test activity finishes. */
    private final Map<String, Integer> mTestResults = new HashMap<String, Integer>();

    /** Map from test name to test details. */
    private final Map<String, String> mTestDetails = new HashMap<String, String>();

    /** Map from test name to {@link ReportLog}. */
    private final Map<String, ReportLog> mReportLogs = new HashMap<String, ReportLog>();

    /** Map from test name to {@link TestResultHistoryCollection}. */
    private final Map<String, TestResultHistoryCollection> mHistories = new HashMap<>();

    /** Map from test name to {@link TestScreenshotsMetadata}. */
    private final Map<String, TestScreenshotsMetadata> mScreenshotsMetadata = new HashMap<>();

    /** Flag to identify whether the mHistories has been loaded. */
    private final AtomicBoolean mHasLoadedResultHistory = new AtomicBoolean(false);

    private final LayoutInflater mLayoutInflater;

    /**
     * Map from display mode to the list of {@link TestListItem}. Records the TestListItem from main
     * view only, including unfolded mode and folded mode respectively.
     */
    protected Map<String, List<TestListItem>> mDisplayModesTests = new HashMap<>();

    /** A keyword to help filter out test cases by the test name. */
    protected String mTestFilter;

    /** {@link ListView} row that is either a test category header or a test. */
    public static class TestListItem {

        /** Title shown in the {@link ListView}. */
        public final String title;

        /** Test name with class and test ID to uniquely identify the test. Null for categories. */
        public String testName;

        /** Intent used to launch the activity from the list. Null for categories. */
        public final Intent intent;

        /** Features necessary to run this test. */
        public final String[] requiredFeatures;

        /** Configs necessary to run this test. */
        public final String[] requiredConfigs;

        /** Intent actions necessary to run this test. */
        public final String[] requiredActions;

        /** Features such that, if any present, the test gets excluded from being shown. */
        public final String[] excludedFeatures;

        /** User "types" that, if any present, the test gets excluded from being shown. */
        public final String[] excludedUserTypes;

        /** If any of of the features are present the test is meaningful to run. */
        public final String[] applicableFeatures;

        /** Configs display mode to run this test. */
        public final String displayMode;

        /** Configs test pass mode to record the test result. */
        public final boolean passInEitherMode;

        // TODO: refactor to use a Builder approach instead

        /**
         * Creates a new test item with given required, excluded and applicable features, the
         * context and the resource ID of the title.
         */
        public static TestListItem newTest(
                Context context,
                int titleResId,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] excludedFeatures,
                String[] applicableFeatures) {
            return newTest(
                    context.getString(titleResId),
                    testName,
                    intent,
                    requiredFeatures,
                    excludedFeatures,
                    applicableFeatures);
        }

        /**
         * Creates a new test item with given required and excluded features, the context and the
         * resource ID of the title.
         */
        public static TestListItem newTest(
                Context context,
                int titleResId,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] excludedFeatures) {
            return newTest(
                    context.getString(titleResId),
                    testName,
                    intent,
                    requiredFeatures,
                    excludedFeatures,
                    /* applicableFeatures= */ null);
        }

        /**
         * Creates a new test item with given required features, the context and the resource ID of
         * the title.
         */
        public static TestListItem newTest(
                Context context,
                int titleResId,
                String testName,
                Intent intent,
                String[] requiredFeatures) {
            return newTest(
                    context.getString(titleResId),
                    testName,
                    intent,
                    requiredFeatures,
                    /* excludedFeatures= */ null,
                    /* applicableFeatures= */ null);
        }

        /**
         * Creates a new test item with given display mode, the required, excluded, applicable
         * features and required configureations and actions.
         */
        public static TestListItem newTest(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] requiredConfigs,
                String[] requiredActions,
                String[] excludedFeatures,
                String[] applicableFeatures,
                String[] excludedUserTypes,
                String displayMode,
                boolean passInEitherMode) {
            return new TestListItem(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    requiredConfigs,
                    requiredActions,
                    excludedFeatures,
                    applicableFeatures,
                    excludedUserTypes,
                    displayMode,
                    passInEitherMode);
        }

        /**
         * Creates a new test item with given display mode, the required, excluded, applicable
         * features, required configurations and actions and test pass mode.
         */
        public static TestListItem newTest(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] requiredConfigs,
                String[] requiredActions,
                String[] excludedFeatures,
                String[] applicableFeatures,
                String[] excludedUserTypes,
                String displayMode) {
            return new TestListItem(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    requiredConfigs,
                    requiredActions,
                    excludedFeatures,
                    applicableFeatures,
                    excludedUserTypes,
                    displayMode,
                    /* passInEitherMode= */ false);
        }

        /**
         * Creates a new test item with given required, excluded, applicable features and required
         * configureations.
         */
        public static TestListItem newTest(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] requiredConfigs,
                String[] excludedFeatures,
                String[] applicableFeatures) {
            return new TestListItem(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    requiredConfigs,
                    /* requiredActions= */ null,
                    excludedFeatures,
                    applicableFeatures,
                    /* excludedUserTypes= */ null,
                    /* displayMode= */ null,
                    /* passInEitherMode= */ false);
        }

        /** Creates a new test item with given required, excluded and applicable features. */
        public static TestListItem newTest(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] excludedFeatures,
                String[] applicableFeatures) {
            return new TestListItem(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    /* requiredConfigs= */ null,
                    /* requiredActions= */ null,
                    excludedFeatures,
                    applicableFeatures,
                    /* excludedUserTypes= */ null,
                    /* displayMode= */ null,
                    /* passInEitherMode= */ false);
        }

        /** Creates a new test item with given required and excluded features. */
        public static TestListItem newTest(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] excludedFeatures) {
            return new TestListItem(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    /* requiredConfigs= */ null,
                    /* requiredActions= */ null,
                    excludedFeatures,
                    /* applicableFeatures= */ null,
                    /* excludedUserTypes= */ null,
                    /* displayMode= */ null,
                    /* passInEitherMode= */ false);
        }

        /** Creates a new test item with given required features. */
        public static TestListItem newTest(
                String title, String testName, Intent intent, String[] requiredFeatures) {
            return new TestListItem(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    /* requiredConfigs= */ null,
                    /* requiredActions= */ null,
                    /* excludedFeatures= */ null,
                    /* applicableFeatures= */ null,
                    /* excludedUserTypes= */ null,
                    /* displayMode= */ null,
                    /* passInEitherMode= */ false);
        }

        public static TestListItem newCategory(Context context, int titleResId) {
            return newCategory(context.getString(titleResId));
        }

        public static TestListItem newCategory(String title) {
            return new TestListItem(
                    title,
                    /* testName= */ null,
                    /* intent= */ null,
                    /* requiredFeatures= */ null,
                    /* requiredConfigs= */ null,
                    /* requiredActions= */ null,
                    /* excludedFeatures= */ null,
                    /* applicableFeatures= */ null,
                    /* excludedUserTypes= */ null,
                    /* displayMode= */ null,
                    /* passInEitherMode= */ false);
        }

        protected TestListItem(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] excludedFeatures,
                String[] applicableFeatures) {
            this(
                    title,
                    testName,
                    intent,
                    requiredFeatures,
                    /* requiredConfigs= */ null,
                    /* requiredActions= */ null,
                    excludedFeatures,
                    applicableFeatures,
                    /* excludedUserTypes= */ null,
                    /* displayMode= */ null,
                    /* passInEitherMode= */ false);
        }

        protected TestListItem(
                String title,
                String testName,
                Intent intent,
                String[] requiredFeatures,
                String[] requiredConfigs,
                String[] requiredActions,
                String[] excludedFeatures,
                String[] applicableFeatures,
                String[] excludedUserTypes,
                String displayMode,
                boolean passInEitherMode) {
            this.title = title;
            this.testName = setTestNameSuffix(sCurrentDisplayMode, testName);
            this.intent = intent;
            this.requiredActions = requiredActions;
            this.requiredFeatures = requiredFeatures;
            this.requiredConfigs = requiredConfigs;
            this.excludedFeatures = excludedFeatures;
            this.applicableFeatures = applicableFeatures;
            this.excludedUserTypes = excludedUserTypes;
            this.displayMode = displayMode;
            this.passInEitherMode = passInEitherMode;
        }

        boolean isTest() {
            return intent != null;
        }
    }

    public TestListAdapter(Context context) {
        this.mContext = context;
        this.mLayoutInflater =
                (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        TestResultContentObserver observer = new TestResultContentObserver();
        ContentResolver resolver = context.getContentResolver();
        resolver.registerContentObserver(
                TestResultsProvider.getResultContentUri(context), true, observer);
    }

    public void loadTestResults() {
        new RefreshTestResultsTask().execute();
    }

    public void clearTestResults() {
        new ClearTestResultsTask().execute();
    }

    public void setTestResult(TestResult testResult) {
        String name = testResult.getName();

        // Append existing history
        TestResultHistoryCollection histories = testResult.getHistoryCollection();
        histories.merge(null, mHistories.get(name));

        new SetTestResultTask(
                        name,
                        testResult.getResult(),
                        testResult.getDetails(),
                        testResult.getReportLog(),
                        histories,
                        mScreenshotsMetadata.get(name))
                .execute();
    }

    void setTestFilter(String testFilter) {
        mTestFilter = testFilter;
    }

    class RefreshTestResultsTask extends AsyncTask<Void, Void, RefreshResult> {

        @Override
        protected RefreshResult doInBackground(Void... params) {
            return getRefreshResults(getRows());
        }

        @Override
        protected void onPostExecute(RefreshResult result) {
            super.onPostExecute(result);
            mRows.clear();
            mRows.addAll(result.mItems);
            mTestResults.clear();
            mTestResults.putAll(result.mResults);
            mTestDetails.clear();
            mTestDetails.putAll(result.mDetails);
            mReportLogs.clear();
            mReportLogs.putAll(result.mReportLogs);
            mHistories.clear();
            mHistories.putAll(result.mHistories);
            mScreenshotsMetadata.clear();
            mScreenshotsMetadata.putAll(result.mScreenshotsMetadata);
            mHasLoadedResultHistory.set(true);
            notifyDataSetChanged();
        }
    }

    static class RefreshResult {
        List<TestListItem> mItems;
        Map<String, Integer> mResults;
        Map<String, String> mDetails;
        Map<String, ReportLog> mReportLogs;
        Map<String, TestResultHistoryCollection> mHistories;
        Map<String, TestScreenshotsMetadata> mScreenshotsMetadata;

        RefreshResult(
                List<TestListItem> items,
                Map<String, Integer> results,
                Map<String, String> details,
                Map<String, ReportLog> reportLogs,
                Map<String, TestResultHistoryCollection> histories,
                Map<String, TestScreenshotsMetadata> screenshotsMetadata) {
            mItems = items;
            mResults = results;
            mDetails = details;
            mReportLogs = reportLogs;
            mHistories = histories;
            mScreenshotsMetadata = screenshotsMetadata;
        }
    }

    protected abstract List<TestListItem> getRows();

    static final String[] REFRESH_PROJECTION = {
        TestResultsProvider._ID,
        TestResultsProvider.COLUMN_TEST_NAME,
        TestResultsProvider.COLUMN_TEST_RESULT,
        TestResultsProvider.COLUMN_TEST_DETAILS,
        TestResultsProvider.COLUMN_TEST_METRICS,
        TestResultsProvider.COLUMN_TEST_RESULT_HISTORY,
        TestResultsProvider.COLUMN_TEST_SCREENSHOTS_METADATA,
    };

    RefreshResult getRefreshResults(List<TestListItem> items) {
        Map<String, Integer> results = new HashMap<String, Integer>();
        Map<String, String> details = new HashMap<String, String>();
        Map<String, ReportLog> reportLogs = new HashMap<String, ReportLog>();
        Map<String, TestResultHistoryCollection> histories = new HashMap<>();
        Map<String, TestScreenshotsMetadata> screenshotsMetadata = new HashMap<>();
        ContentResolver resolver = mContext.getContentResolver();
        Cursor cursor = null;
        try {
            cursor =
                    resolver.query(
                            TestResultsProvider.getResultContentUri(mContext),
                            REFRESH_PROJECTION,
                            null,
                            null,
                            null);
            if (cursor.moveToFirst()) {
                do {
                    String testName = cursor.getString(1);
                    int testResult = cursor.getInt(2);
                    String testDetails = cursor.getString(3);
                    ReportLog reportLog = (ReportLog) deserialize(cursor.getBlob(4));
                    TestResultHistoryCollection historyCollection =
                            (TestResultHistoryCollection) deserialize(cursor.getBlob(5));
                    TestScreenshotsMetadata screenshots =
                            (TestScreenshotsMetadata) deserialize(cursor.getBlob(6));
                    results.put(testName, testResult);
                    details.put(testName, testDetails);
                    reportLogs.put(testName, reportLog);
                    histories.put(testName, historyCollection);
                    screenshotsMetadata.put(testName, screenshots);
                } while (cursor.moveToNext());
            }
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
        return new RefreshResult(
                items, results, details, reportLogs, histories, screenshotsMetadata);
    }

    class ClearTestResultsTask extends AsyncTask<Void, Void, Void> {

        private void deleteDirectory(File file) {
            for (File subfile : file.listFiles()) {
                if (subfile.isDirectory()) {
                    deleteDirectory(subfile);
                }
                subfile.delete();
            }
        }

        @Override
        protected Void doInBackground(Void... params) {
            ContentResolver resolver = mContext.getContentResolver();
            resolver.delete(TestResultsProvider.getResultContentUri(mContext), "1", null);

            // Apart from deleting metadata from content resolver database, need to delete
            // files generated in LOGS_DIRECTORY. For example screenshots.
            File resFolder =
                    new File(
                            Environment.getExternalStorageDirectory().getAbsolutePath()
                                    + File.separator
                                    + LOGS_DIRECTORY);
            deleteDirectory(resFolder);

            return null;
        }
    }

    class SetTestResultTask extends AsyncTask<Void, Void, Void> {

        private final String mTestName;
        private final int mResult;
        private final String mDetails;
        private final ReportLog mReportLog;
        private final TestResultHistoryCollection mHistoryCollection;
        private final TestScreenshotsMetadata mScreenshotsMetadata;

        SetTestResultTask(
                String testName,
                int result,
                String details,
                ReportLog reportLog,
                TestResultHistoryCollection historyCollection,
                TestScreenshotsMetadata screenshotsMetadata) {
            mTestName = testName;
            mResult = result;
            mDetails = details;
            mReportLog = reportLog;
            mHistoryCollection = historyCollection;
            mScreenshotsMetadata = screenshotsMetadata;
        }

        @Override
        protected Void doInBackground(Void... params) {
            if (mHasLoadedResultHistory.get()) {
                mHistoryCollection.merge(null, mHistories.get(mTestName));
            } else {
                // Loads history from ContentProvider directly if it has not been loaded yet.
                ContentResolver resolver = mContext.getContentResolver();

                try (Cursor cursor =
                        resolver.query(
                                TestResultsProvider.getTestNameUri(mContext, mTestName),
                                new String[] {TestResultsProvider.COLUMN_TEST_RESULT_HISTORY},
                                null,
                                null,
                                null)) {
                    if (cursor.moveToFirst()) {
                        do {
                            TestResultHistoryCollection historyCollection =
                                    (TestResultHistoryCollection) deserialize(cursor.getBlob(0));
                            mHistoryCollection.merge(null, historyCollection);
                        } while (cursor.moveToNext());
                    }
                }
            }
            TestResultsProvider.setTestResult(
                    mContext,
                    mTestName,
                    mResult,
                    mDetails,
                    mReportLog,
                    mHistoryCollection,
                    mScreenshotsMetadata);
            return null;
        }
    }

    class TestResultContentObserver extends ContentObserver {

        public TestResultContentObserver() {
            super(new Handler());
        }

        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
            loadTestResults();
        }
    }

    @Override
    public boolean areAllItemsEnabled() {
        // Section headers for test categories are not clickable.
        return false;
    }

    @Override
    public boolean isEnabled(int position) {
        if (getItem(position) == null) {
            return false;
        }
        return getItem(position).isTest();
    }

    @Override
    public int getItemViewType(int position) {
        if (getItem(position) == null) {
            return CATEGORY_HEADER_VIEW_TYPE;
        }
        return getItem(position).isTest() ? TEST_VIEW_TYPE : CATEGORY_HEADER_VIEW_TYPE;
    }

    @Override
    public int getViewTypeCount() {
        return 2;
    }

    @Override
    public int getCount() {
        return mRows.size();
    }

    @Override
    public TestListItem getItem(int position) {
        return mRows.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    /** Gets {@link TestListItem} with the given test name. */
    public TestListItem getItemByName(String testName) {
        for (TestListItem item : mRows) {
            if (item != null && item.testName != null && item.testName.equals(testName)) {
                return item;
            }
        }
        return null;
    }

    public int getTestResult(int position) {
        TestListItem item = getItem(position);
        return mTestResults.containsKey(item.testName)
                ? mTestResults.get(item.testName)
                : TestResult.TEST_RESULT_NOT_EXECUTED;
    }

    public String getTestDetails(int position) {
        TestListItem item = getItem(position);
        return mTestDetails.containsKey(item.testName) ? mTestDetails.get(item.testName) : null;
    }

    public ReportLog getReportLog(int position) {
        TestListItem item = getItem(position);
        return mReportLogs.containsKey(item.testName) ? mReportLogs.get(item.testName) : null;
    }

    /**
     * Get test result histories.
     *
     * @param position The position of test.
     * @return A {@link TestResultHistoryCollection} object containing test result histories of
     *     tests.
     */
    public TestResultHistoryCollection getHistoryCollection(int position) {
        TestListItem item = getItem(position);
        if (item == null) {
            return null;
        }
        return mHistories.containsKey(item.testName) ? mHistories.get(item.testName) : null;
    }

    /**
     * Get test screenshots metadata
     *
     * @param position The position of test
     * @return A {@link TestScreenshotsMetadata} object containing test screenshots metadata.
     */
    public TestScreenshotsMetadata getScreenshotsMetadata(String mode, int position) {
        TestListItem item = getItem(mode, position);
        return mScreenshotsMetadata.containsKey(item.testName)
                ? mScreenshotsMetadata.get(item.testName)
                : null;
    }

    /**
     * Get test item by the given display mode and position.
     *
     * @param mode The display mode.
     * @param position The position of test.
     * @return A {@link TestListItem} object containing the test item.
     */
    public TestListItem getItem(String mode, int position) {
        return mDisplayModesTests.get(mode).get(position);
    }

    /**
     * Get test item count by the given display mode.
     *
     * @param mode The display mode.
     * @return A count of test items.
     */
    public int getCount(String mode) {
        return mDisplayModesTests.getOrDefault(mode, new ArrayList<>()).size();
    }

    /**
     * Get test result by the given display mode and position.
     *
     * @param mode The display mode.
     * @param position The position of test.
     * @return The test item result.
     */
    public int getTestResult(String mode, int position) {
        TestListItem item = mDisplayModesTests.get(mode).get(position);
        return mTestResults.containsKey(item.testName)
                ? mTestResults.get(item.testName)
                : TestResult.TEST_RESULT_NOT_EXECUTED;
    }

    /**
     * Get test details by the given display mode and position.
     *
     * @param mode The display mode.
     * @param position The position of test.
     * @return A string containing the test details.
     */
    public String getTestDetails(String mode, int position) {
        TestListItem item = mDisplayModesTests.get(mode).get(position);
        return mTestDetails.containsKey(item.testName) ? mTestDetails.get(item.testName) : null;
    }

    /**
     * Get test report log by the given display mode and position.
     *
     * @param mode The display mode.
     * @param position The position of test.
     * @return A {@link ReportLog} object containing the test report log of the test item.
     */
    public ReportLog getReportLog(String mode, int position) {
        TestListItem item = mDisplayModesTests.get(mode).get(position);
        return mReportLogs.containsKey(item.testName) ? mReportLogs.get(item.testName) : null;
    }

    /**
     * Get test result histories by the given display mode and position.
     *
     * @param mode The display mode.
     * @param position The position of test.
     * @return A {@link TestResultHistoryCollection} object containing the test result histories of
     *     the test item.
     */
    public TestResultHistoryCollection getHistoryCollection(String mode, int position) {
        TestListItem item = mDisplayModesTests.get(mode).get(position);
        return mHistories.containsKey(item.testName) ? mHistories.get(item.testName) : null;
    }

    public boolean allTestsPassed() {
        for (TestListItem item : mRows) {
            if (item != null
                    && item.isTest()
                    && (!mTestResults.containsKey(item.testName)
                            || (mTestResults.get(item.testName)
                                    != TestResult.TEST_RESULT_PASSED))) {
                return false;
            }
        }
        return true;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        TextView textView;
        if (convertView == null) {
            int layout = getLayout(position);
            textView = (TextView) mLayoutInflater.inflate(layout, parent, false);
        } else {
            textView = (TextView) convertView;
        }

        TestListItem item = getItem(position);

        if (item == null) {
            return textView;
        }

        textView.setText(item.title);
        textView.setPadding(PADDING, 0, PADDING, 0);
        textView.setCompoundDrawablePadding(PADDING);

        if (item.isTest()) {
            int testResult = getTestResult(position);
            int backgroundResource = 0;
            int iconResource = 0;

            /** TODO: Remove fs_ prefix from feature icons since they are used here too. */
            switch (testResult) {
                case TestResult.TEST_RESULT_PASSED:
                    backgroundResource = R.drawable.test_pass_gradient;
                    iconResource = R.drawable.fs_good;
                    break;

                case TestResult.TEST_RESULT_FAILED:
                    backgroundResource = R.drawable.test_fail_gradient;
                    iconResource = R.drawable.fs_error;
                    break;

                case TestResult.TEST_RESULT_NOT_EXECUTED:
                    break;

                default:
                    throw new IllegalArgumentException("Unknown test result: " + testResult);
            }

            textView.setBackgroundResource(backgroundResource);
            textView.setCompoundDrawablesWithIntrinsicBounds(0, 0, iconResource, 0);
        }

        return textView;
    }

    /**
     * Uses {@link DeviceStateManager} to determine if the device is foldable or not. It relies on
     * the OEM exposing supported states, and setting
     * com.android.internal.R.array.config_foldedDeviceStates correctly with the folded states.
     *
     * @return true if the device is foldable, false otherwise
     */
    public boolean isFoldableDevice() {
        DeviceStateManager deviceStateManager = mContext.getSystemService(DeviceStateManager.class);
        if (deviceStateManager == null) {
            return false;
        }
        Set<Integer> supportedStates =
                Arrays.stream(deviceStateManager.getSupportedStates())
                        .boxed()
                        .collect(Collectors.toSet());
        int identifier =
                mContext.getResources()
                        .getIdentifier("config_foldedDeviceStates", "array", "android");
        int[] foldedDeviceStates = mContext.getResources().getIntArray(identifier);
        return Arrays.stream(foldedDeviceStates).anyMatch(supportedStates::contains);
    }

    private int getLayout(int position) {
        int viewType = getItemViewType(position);
        switch (viewType) {
            case CATEGORY_HEADER_VIEW_TYPE:
                return R.layout.test_category_row;
            case TEST_VIEW_TYPE:
                return android.R.layout.simple_list_item_1;
            default:
                throw new IllegalArgumentException("Illegal view type: " + viewType);
        }
    }

    public static Object deserialize(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
        ObjectInputStream objectInput = null;
        try {
            objectInput = new ObjectInputStream(byteStream);
            return objectInput.readObject();
        } catch (IOException e) {
            return null;
        } catch (ClassNotFoundException e) {
            return null;
        } finally {
            try {
                if (objectInput != null) {
                    objectInput.close();
                }
                byteStream.close();
            } catch (IOException e) {
                // Ignore close exception.
            }
        }
    }

    /**
     * Sets test name suffix. In the folded mode, the suffix is [folded]; otherwise, it is empty
     * string.
     *
     * @param mode A string of current display mode.
     * @param name A string of test name.
     * @return A string of test name with suffix, [folded], in the folded mode. A string of input
     *     test name in the unfolded mode.
     */
    public static String setTestNameSuffix(String mode, String name) {
        if (name != null
                && mode.equalsIgnoreCase(DisplayMode.FOLDED.toString())
                && !name.endsWith(DisplayMode.FOLDED.asSuffix())) {
            return name + DisplayMode.FOLDED.asSuffix();
        }
        return name;
    }

    /**
     * Removes test name suffix. In the unfolded mode, remove the suffix [folded].
     *
     * @param mode A string of current display mode.
     * @param name A string of test name.
     * @return A string of test name without suffix, [folded], in the unfolded mode. A string of
     *     input test name in the folded mode.
     */
    public static String removeTestNameSuffix(String mode, String name) {
        if (name != null
                && mode.equalsIgnoreCase(DisplayMode.UNFOLDED.toString())
                && name.endsWith(DisplayMode.FOLDED.asSuffix())) {
            return name.substring(0, name.length() - DisplayMode.FOLDED.asSuffix().length());
        }
        return name;
    }
}