/*
 * Copyright (C) 2013 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.notifications;

import static android.app.Notification.VISIBILITY_PRIVATE;
import static android.app.NotificationManager.IMPORTANCE_LOW;
import static android.app.NotificationManager.IMPORTANCE_MAX;
import static android.app.NotificationManager.IMPORTANCE_NONE;
import static android.provider.Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS;
import static android.provider.Settings.EXTRA_APP_PACKAGE;
import static android.provider.Settings.EXTRA_CHANNEL_ID;

import static com.android.cts.verifier.notifications.MockListener.JSON_FLAGS;
import static com.android.cts.verifier.notifications.MockListener.JSON_ICON;
import static com.android.cts.verifier.notifications.MockListener.JSON_ID;
import static com.android.cts.verifier.notifications.MockListener.JSON_LAST_AUDIBLY_ALERTED;
import static com.android.cts.verifier.notifications.MockListener.JSON_PACKAGE;
import static com.android.cts.verifier.notifications.MockListener.JSON_REASON;
import static com.android.cts.verifier.notifications.MockListener.JSON_STATS;
import static com.android.cts.verifier.notifications.MockListener.JSON_TAG;
import static com.android.cts.verifier.notifications.MockListener.JSON_WHEN;
import static com.android.cts.verifier.notifications.MockListener.REASON_LISTENER_CANCEL;

import android.annotation.SuppressLint;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationChannelGroup;
import android.app.PendingIntent;
import android.app.Person;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.content.pm.ShortcutInfo;
import android.content.pm.ShortcutManager;
import android.graphics.drawable.Icon;
import android.os.Bundle;
import android.os.SystemClock;
import android.provider.Settings;
import android.provider.Settings.Secure;
import android.service.notification.NotificationListenerService;
import android.service.notification.StatusBarNotification;
import android.util.ArraySet;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.RemoteViews;

import androidx.core.app.NotificationCompat;

import com.android.cts.verifier.R;

import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;

public class NotificationListenerVerifierActivity extends InteractiveVerifierActivity
        implements Runnable {
    static final String TAG = "NoListenerVerifier";
    private static final String NOTIFICATION_CHANNEL_ID = TAG;
    private static final String NOISY_NOTIFICATION_CHANNEL_ID = TAG + "noisy";
    protected static final String PREFS = "listener_prefs";
    final int NUM_NOTIFICATIONS_SENT = 3; // # notifications sent by sendNotifications()

    private String mTag1;
    private String mTag2;
    private String mTag3;
    private String mTag4;
    private int mIcon1;
    private int mIcon2;
    private int mIcon3;
    private int mIcon4;
    private int mId1;
    private int mId2;
    private int mId3;
    private int mId4;
    private long mWhen1;
    private long mWhen2;
    private long mWhen3;
    private long mWhen4;
    private int mFlag1;
    private int mFlag2;
    private int mFlag3;

    @Override
    protected int getTitleResource() {
        return R.string.nls_test;
    }

    @Override
    protected int getInstructionsResource() {
        return R.string.nls_info;
    }

    // Test Setup

    @Override
    protected List<InteractiveTestCase> createTestItems() {
        boolean isAutomotive = getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_AUTOMOTIVE);
        List<InteractiveTestCase> tests = new ArrayList<>(17);
        tests.add(new IsEnabledTest());
        tests.add(new ServiceStartedTest());
        tests.add(new NotificationReceivedTest());
        /*
        // TODO (b/200701618): re-enable tests if conditions in 3.8.3.1 change to MUST
        if (!isAutomotive) {
            tests.add(new SendUserToChangeFilter());
            tests.add(new AskIfFilterChanged());
            tests.add(new NotificationTypeFilterTest());
            tests.add(new ResetChangeFilter());
        }*/
        tests.add(new LongMessageTest());
        tests.add(new DataIntactTest());
        tests.add(new AudiblyAlertedTest());
        tests.add(new DismissOneTest());
        tests.add(new DismissOneWithReasonTest());
        tests.add(new DismissOneWithStatsTest());
        tests.add(new DismissAllTest());
        tests.add(new SnoozeNotificationForTimeTest());
        tests.add(new SnoozeNotificationForTimeCancelTest());
        tests.add(new GetSnoozedNotificationTest());
        tests.add(new EnableHintsTest());
        tests.add(new ReceiveAppBlockNoticeTest());
        tests.add(new ReceiveAppUnblockNoticeTest());
        if (!isAutomotive) {
            tests.add(new ReceiveChannelBlockNoticeTest());
            tests.add(new ReceiveGroupBlockNoticeTest());
        }
        tests.add(new RequestUnbindTest());
        tests.add(new RequestBindTest());
        tests.add(new MessageBundleTest());
        tests.add(new ConversationOrderingTest());
        tests.add(new HunDisplayTest());
        tests.add(new EnableHintsTest());
        tests.add(new IsDisabledTest());
        tests.add(new ServiceStoppedTest());
        tests.add(new NotificationNotReceivedTest());
        return tests;
    }

    private void createChannels() {
        NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
                NOTIFICATION_CHANNEL_ID, IMPORTANCE_LOW);
        NotificationChannel noisyChannel = new NotificationChannel(NOISY_NOTIFICATION_CHANNEL_ID,
                NOISY_NOTIFICATION_CHANNEL_ID, IMPORTANCE_MAX);
        noisyChannel.setVibrationPattern(new long[]{100, 0, 100});
        mNm.createNotificationChannel(channel);
        mNm.createNotificationChannel(noisyChannel);
    }

    private void deleteChannels() {
        mNm.deleteNotificationChannel(NOTIFICATION_CHANNEL_ID);
        mNm.deleteNotificationChannel(NOISY_NOTIFICATION_CHANNEL_ID);
    }

    @SuppressLint("NewApi")
    private void sendNotifications() {
        mTag1 = UUID.randomUUID().toString();
        Log.d(TAG, "Sending #1: " + mTag1);
        mTag2 = UUID.randomUUID().toString();
        Log.d(TAG, "Sending #2: " + mTag2);
        mTag3 = UUID.randomUUID().toString();
        Log.d(TAG, "Sending #3: " + mTag3);

        mWhen1 = System.currentTimeMillis() + 1;
        mWhen2 = System.currentTimeMillis() + 2;
        mWhen3 = System.currentTimeMillis() + 3;

        mIcon1 = R.drawable.ic_stat_alice;
        mIcon2 = R.drawable.ic_stat_bob;
        mIcon3 = R.drawable.ic_stat_charlie;

        mId1 = NOTIFICATION_ID + 1;
        mId2 = NOTIFICATION_ID + 2;
        mId3 = NOTIFICATION_ID + 3;

        mPackageString = "com.android.cts.verifier";

        Notification n1 = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                .setContentTitle("ClearTest 1")
                .setContentText(mTag1)
                .setSmallIcon(mIcon1)
                .setWhen(mWhen1)
                .setDeleteIntent(makeIntent(1, mTag1))
                .setOnlyAlertOnce(true)
                .build();
        mNm.notify(mTag1, mId1, n1);
        mFlag1 = Notification.FLAG_ONLY_ALERT_ONCE;

        Notification n2 = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                .setContentTitle("ClearTest 2")
                .setContentText(mTag2)
                .setSmallIcon(mIcon2)
                .setWhen(mWhen2)
                .setDeleteIntent(makeIntent(2, mTag2))
                .setAutoCancel(true)
                .build();
        mNm.notify(mTag2, mId2, n2);
        mFlag2 = Notification.FLAG_AUTO_CANCEL;

        Notification n3 = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                .setContentTitle("ClearTest 3")
                .setContentText(mTag3)
                .setSmallIcon(mIcon3)
                .setWhen(mWhen3)
                .setDeleteIntent(makeIntent(3, mTag3))
                .setAutoCancel(true)
                .setOnlyAlertOnce(true)
                .build();
        mNm.notify(mTag3, mId3, n3);
        mFlag3 = Notification.FLAG_ONLY_ALERT_ONCE | Notification.FLAG_AUTO_CANCEL;
    }

    private void sendNoisyNotification() {
        mTag4 = UUID.randomUUID().toString();
        Log.d(TAG, "Sending noisy notif: " + mTag4);

        mWhen4 = System.currentTimeMillis() + 4;
        mIcon4 = R.drawable.ic_stat_charlie;
        mId4 = NOTIFICATION_ID + 4;
        mPackageString = "com.android.cts.verifier";

        Notification n1 = new Notification.Builder(mContext, NOISY_NOTIFICATION_CHANNEL_ID)
                .setContentTitle("NoisyTest 1")
                .setContentText(mTag4)
                .setSmallIcon(mIcon4)
                .setWhen(mWhen4)
                .setDeleteIntent(makeIntent(4, mTag4))
                .setCategory(Notification.CATEGORY_REMINDER)
                .build();
        mNm.notify(mTag4, mId4, n1);
    }

    // Tests
    private class NotificationReceivedTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_note_received);

        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            MockListener.getInstance().resetData();
            deleteChannels();
        }

        @Override
        protected void test() {
            if (MockListener.getInstance().getPosted(mTag1) != null) {
                status = PASS;
            } else {
                logFail();
                status = FAIL;
            }
        }
    }

    private class LongMessageTest extends InteractiveTestCase {
        private ViewGroup mParent;
        @Override
        protected View inflate(ViewGroup parent) {
            mParent = createAutoItem(parent, R.string.nls_anr);
            return mParent;
        }

        @Override
        protected void setUp() {
            createChannels();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 20000; i++) {
                sb.append("\u2009\u200a" + "\u200E\u200F" + "stuff");
            }
            Notification.Builder builder = new Notification.Builder(
                    mContext, NOTIFICATION_CHANNEL_ID)
                    .setSmallIcon(R.drawable.ic_stat_alice)
                    .setContentTitle("This is an long notification")
                    .setContentText("Innocuous content")
                    .setStyle(new Notification.MessagingStyle("Fake person")
                            .addMessage("hey how is it goin", 0, "Person 1")
                            .addMessage("hey", 0, "Person 1")
                            .addMessage("u there", 0, "Person 1")
                            .addMessage("how you like tHIS", 0, "Person 1")
                            .addMessage(sb.toString(), 0, "Person 1")
                    );
            mTag1 = UUID.randomUUID().toString();
            mId1 = NOTIFICATION_ID + 1;
            mPackageString = "com.android.cts.verifier";
            mNm.notify(mTag1, mId1, builder.build());
            status = READY;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            MockListener.getInstance().resetData();
            deleteChannels();
        }

        @Override
        protected void test() {
            StatusBarNotification sbn = MockListener.getInstance().getPosted(mTag1);
            if (sbn == null) {
                logFail();
                status = FAIL;
            } else {
                ViewGroup parent = mParent.findViewById(R.id.feedback);
                parent.setVisibility(View.VISIBLE);
                final Notification.Builder recoveredBuilder = Notification.Builder.recoverBuilder(
                        NotificationListenerVerifierActivity.this,
                        sbn.getNotification());
                RemoteViews rv = recoveredBuilder.createContentView();
                View v = rv.apply(NotificationListenerVerifierActivity.this, parent);
                parent.addView(v);
            }
            if (MockListener.getInstance().getPosted(mTag1) != null) {
                status = PASS;
            } else {
                logFail();
                status = FAIL;
            }
        }
    }

    /**
     * Creates a notification channel. Sends the user to settings to block the channel. Waits
     * to receive the broadcast that the channel was blocked, and confirms that the broadcast
     * contains the correct extras.
     */
    protected class ReceiveChannelBlockNoticeTest extends InteractiveTestCase {
        private String mChannelId;
        private int mRetries = 2;
        private View mView;
        @Override
        protected View inflate(ViewGroup parent) {
            mView = createNlsSettingsItem(parent, R.string.nls_block_channel);
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(false);
            return mView;
        }

        @Override
        protected void setUp() {
            mChannelId = UUID.randomUUID().toString();
            NotificationChannel channel = new NotificationChannel(
                    mChannelId, "ReceiveChannelBlockNoticeTest", IMPORTANCE_LOW);
            mNm.createNotificationChannel(channel);
            status = READY;
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(true);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            NotificationChannel channel = mNm.getNotificationChannel(mChannelId);
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);

            if (channel.getImportance() == IMPORTANCE_NONE) {
                if (prefs.contains(mChannelId) && prefs.getBoolean(mChannelId, false)) {
                    status = PASS;
                } else {
                    if (mRetries > 0) {
                        mRetries--;
                        status = RETEST;
                    } else {
                        status = FAIL;
                    }
                }
            } else {
                // user hasn't jumped to settings to block the channel yet
                status = WAIT_FOR_USER;
            }

            next();
        }

        protected void tearDown() {
            MockListener.getInstance().resetData();
            mNm.deleteNotificationChannel(mChannelId);
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = prefs.edit();
            editor.remove(mChannelId);
        }

        @Override
        protected Intent getIntent() {
         return new Intent(Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS)
                 .putExtra(EXTRA_APP_PACKAGE, mContext.getPackageName())
                 .putExtra(EXTRA_CHANNEL_ID, mChannelId);
        }
    }

    /**
     * Creates a notification channel group. Sends the user to settings to block the group. Waits
     * to receive the broadcast that the group was blocked, and confirms that the broadcast contains
     * the correct extras.
     */
    protected class ReceiveGroupBlockNoticeTest extends InteractiveTestCase {
        private String mGroupId;
        private int mRetries = 2;
        private View mView;
        @Override
        protected View inflate(ViewGroup parent) {
            mView = createNlsSettingsItem(parent, R.string.nls_block_group);
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(false);
            return mView;
        }

        @Override
        protected void setUp() {
            mGroupId = UUID.randomUUID().toString();
            NotificationChannelGroup group
                    = new NotificationChannelGroup(mGroupId, "ReceiveChannelGroupBlockNoticeTest");
            mNm.createNotificationChannelGroup(group);
            NotificationChannel channel = new NotificationChannel(
                    mGroupId, "ReceiveChannelBlockNoticeTest", IMPORTANCE_LOW);
            channel.setGroup(mGroupId);
            mNm.createNotificationChannel(channel);
            status = READY;
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(true);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            NotificationChannelGroup group = mNm.getNotificationChannelGroup(mGroupId);
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);

            if (group.isBlocked()) {
                if (prefs.contains(mGroupId) && prefs.getBoolean(mGroupId, false)) {
                    status = PASS;
                } else {
                    if (mRetries > 0) {
                        mRetries--;
                        status = RETEST;
                    } else {
                        status = FAIL;
                    }
                }
            } else {
                // user hasn't jumped to settings to block the group yet
                status = WAIT_FOR_USER;
            }

            next();
        }

        protected void tearDown() {
            MockListener.getInstance().resetData();
            mNm.deleteNotificationChannelGroup(mGroupId);
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = prefs.edit();
            editor.remove(mGroupId);
        }

        @Override
        protected Intent getIntent() {
            return new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS)
                    .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
                    .putExtra(EXTRA_APP_PACKAGE, mContext.getPackageName());
        }
    }

    /**
     * Sends the user to settings to block the app. Waits to receive the broadcast that the app was
     * blocked, and confirms that the broadcast contains the correct extras.
     */
    protected class ReceiveAppBlockNoticeTest extends InteractiveTestCase {
        private int mRetries = 2;
        private View mView;
        @Override
        protected View inflate(ViewGroup parent) {
            mView = createNlsSettingsItem(parent, R.string.nls_block_app);
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(false);
            return mView;
        }

        @Override
        protected void setUp() {
            status = READY;
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(true);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);

            if (!mNm.areNotificationsEnabled()) {
                Log.d(TAG, "Got broadcast " + prefs.contains(mContext.getPackageName()));
                Log.d(TAG, "Broadcast contains correct data? " +
                        prefs.getBoolean(mContext.getPackageName(), false));
                if (prefs.contains(mContext.getPackageName())
                        && prefs.getBoolean(mContext.getPackageName(), false)) {
                    status = PASS;
                } else {
                    if (mRetries > 0) {
                        mRetries--;
                        status = RETEST;
                    } else {
                        status = FAIL;
                    }
                }
            } else {
                Log.d(TAG, "Notifications still enabled");
                // user hasn't jumped to settings to block the app yet
                status = WAIT_FOR_USER;
            }

            next();
        }

        protected void tearDown() {
            MockListener.getInstance().resetData();
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = prefs.edit();
            editor.remove(mContext.getPackageName());
        }

        @Override
        protected Intent getIntent() {
            return new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS)
                    .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
                    .putExtra(EXTRA_APP_PACKAGE, mContext.getPackageName());
        }
    }

    /**
     * Sends the user to settings to unblock the app. Waits to receive the broadcast that the app
     * was unblocked, and confirms that the broadcast contains the correct extras.
     */
    protected class ReceiveAppUnblockNoticeTest extends InteractiveTestCase {
        private int mRetries = 2;
        private View mView;
        @Override
        protected View inflate(ViewGroup parent) {
            mView = createNlsSettingsItem(parent, R.string.nls_unblock_app);
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(false);
            return mView;
        }

        @Override
        protected void setUp() {
            status = READY;
            Button button = mView.findViewById(R.id.nls_action_button);
            button.setEnabled(true);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);

            if (mNm.areNotificationsEnabled()) {
                if (prefs.contains(mContext.getPackageName())
                        && !prefs.getBoolean(mContext.getPackageName(), true)) {
                    status = PASS;
                } else {
                    if (mRetries > 0) {
                        mRetries--;
                        status = RETEST;
                    } else {
                        status = FAIL;
                    }
                }
            } else {
                // user hasn't jumped to settings to block the app yet
                status = WAIT_FOR_USER;
            }

            next();
        }

        protected void tearDown() {
            MockListener.getInstance().resetData();
            SharedPreferences prefs = mContext.getSharedPreferences(
                    NotificationListenerVerifierActivity.PREFS, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = prefs.edit();
            editor.remove(mContext.getPackageName());
        }

        @Override
        protected Intent getIntent() {
            return new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS)
                    .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
                    .putExtra(EXTRA_APP_PACKAGE, mContext.getPackageName());
        }
    }

    private class DataIntactTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_payload_intact);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void test() {
            List<JSONObject> result = new ArrayList<>(MockListener.getInstance().getPosted());

            Set<String> found = new HashSet<String>();
            if (result.size() == 0) {
                status = FAIL;
                return;
            }
            boolean pass = true;
            for (JSONObject payload : result) {
                try {
                    pass &= checkEquals(mPackageString,
                            payload.getString(JSON_PACKAGE),
                            "data integrity test: notification package (%s, %s)");
                    String tag = payload.getString(JSON_TAG);
                    if (mTag1.equals(tag)) {
                        found.add(mTag1);
                        pass &= checkEquals(mIcon1, payload.getInt(JSON_ICON),
                                "data integrity test: notification icon (%d, %d)");
                        pass &= checkFlagSet(mFlag1, payload.getInt(JSON_FLAGS),
                                "data integrity test: notification flags (%d, %d)");
                        pass &= checkEquals(mId1, payload.getInt(JSON_ID),
                                "data integrity test: notification ID (%d, %d)");
                        pass &= checkEquals(mWhen1, payload.getLong(JSON_WHEN),
                                "data integrity test: notification when (%d, %d)");
                    } else if (mTag2.equals(tag)) {
                        found.add(mTag2);
                        pass &= checkEquals(mIcon2, payload.getInt(JSON_ICON),
                                "data integrity test: notification icon (%d, %d)");
                        pass &= checkFlagSet(mFlag2, payload.getInt(JSON_FLAGS),
                                "data integrity test: notification flags (%d, %d)");
                        pass &= checkEquals(mId2, payload.getInt(JSON_ID),
                                "data integrity test: notification ID (%d, %d)");
                        pass &= checkEquals(mWhen2, payload.getLong(JSON_WHEN),
                                "data integrity test: notification when (%d, %d)");
                    } else if (mTag3.equals(tag)) {
                        found.add(mTag3);
                        pass &= checkEquals(mIcon3, payload.getInt(JSON_ICON),
                                "data integrity test: notification icon (%d, %d)");
                        pass &= checkFlagSet(mFlag3, payload.getInt(JSON_FLAGS),
                                "data integrity test: notification flags (%d, %d)");
                        pass &= checkEquals(mId3, payload.getInt(JSON_ID),
                                "data integrity test: notification ID (%d, %d)");
                        pass &= checkEquals(mWhen3, payload.getLong(JSON_WHEN),
                                "data integrity test: notification when (%d, %d)");
                    }
                } catch (JSONException e) {
                    pass = false;
                    Log.e(TAG, "failed to unpack data from mocklistener", e);
                }
            }

            pass &= found.size() >= 3;
            status = pass ? PASS : FAIL;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            MockListener.getInstance().resetData();
            deleteChannels();
        }
    }

    private class AudiblyAlertedTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_audibly_alerted);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            sendNoisyNotification();
            status = READY;
        }

        @Override
        protected void test() {
            List<JSONObject> result = new ArrayList<>(MockListener.getInstance().getPosted());

            Set<String> found = new HashSet<>();
            if (result.size() == 0) {
                status = FAIL;
                return;
            }
            boolean pass = true;
            for (JSONObject payload : result) {
                try {
                    String tag = payload.getString(JSON_TAG);
                    if (mTag4.equals(tag)) {
                        found.add(mTag4);
                        boolean lastAudiblyAlertedSet
                                = payload.getLong(JSON_LAST_AUDIBLY_ALERTED) > -1;
                        if (!lastAudiblyAlertedSet) {
                            logWithStack(
                                    "noisy notification test: getLastAudiblyAlertedMillis not set");
                        }
                        pass &= lastAudiblyAlertedSet;
                    } else if (payload.getString(JSON_PACKAGE).equals(mPackageString)) {
                        found.add(tag);
                        boolean lastAudiblyAlertedSet
                                = payload.getLong(JSON_LAST_AUDIBLY_ALERTED) > 0;
                        if (lastAudiblyAlertedSet) {
                            logWithStack(
                                    "noisy notification test: getLastAudiblyAlertedMillis set "
                                            + "incorrectly");
                        }
                        pass &= !lastAudiblyAlertedSet;
                    }
                } catch (JSONException e) {
                    pass = false;
                    Log.e(TAG, "failed to unpack data from mocklistener", e);
                }
            }

            pass &= found.size() >= 4;
            status = pass ? PASS : FAIL;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            MockListener.getInstance().resetData();
            deleteChannels();
        }
    }

    private class DismissOneTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_clear_one);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.getInstance().cancelNotification(
                        MockListener.getInstance().getKeyForTag(mTag1));
                status = RETEST;
            } else {
                List<String> result = new ArrayList<>(MockListener.getInstance().mRemoved);
                if (result.size() != 0
                        && result.contains(mTag1)
                        && !result.contains(mTag2)
                        && !result.contains(mTag3)) {
                    status = PASS;
                } else {
                    logFail();
                    status = FAIL;
                }
            }
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
        }
    }

    private class DismissOneWithReasonTest extends InteractiveTestCase {
        int mRetries = 3;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_clear_one_reason);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.getInstance().cancelNotification(
                        MockListener.getInstance().getKeyForTag(mTag1));
                status = RETEST;
            } else {
                List<JSONObject> result =
                        new ArrayList<>(MockListener.getInstance().mRemovedReason.values());
                boolean pass = false;
                for (JSONObject payload : result) {
                    try {
                        pass |= (checkEquals(mTag1,
                                payload.getString(JSON_TAG),
                                "data dismissal test: notification tag (%s, %s)")
                                && checkEquals(REASON_LISTENER_CANCEL,
                                payload.getInt(JSON_REASON),
                                "data dismissal test: reason (%d, %d)"));
                        if(pass) {
                            break;
                        }
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
                if (pass) {
                    status = PASS;
                } else {
                    if (--mRetries > 0) {
                        sleep(100);
                        status = RETEST;
                    } else {
                        status = FAIL;
                    }
                }
            }
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
        }
    }

    private class DismissOneWithStatsTest extends InteractiveTestCase {
        int mRetries = 3;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_clear_one_stats);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.getInstance().cancelNotification(
                        MockListener.getInstance().getKeyForTag(mTag1));
                status = RETEST;
            } else {
                List<JSONObject> result =
                        new ArrayList<>(MockListener.getInstance().mRemovedReason.values());
                boolean pass = true;
                for (JSONObject payload : result) {
                    try {
                        pass &= (payload.getBoolean(JSON_STATS) == false);
                    } catch (JSONException e) {
                        e.printStackTrace();
                        pass = false;
                    }
                }
                if (pass) {
                    status = PASS;
                } else {
                    if (--mRetries > 0) {
                        sleep(100);
                        status = RETEST;
                    } else {
                        logFail("Notification listener got populated stats object.");
                        status = FAIL;
                    }
                }
            }
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
        }
    }

    private class DismissAllTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_clear_all);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.getInstance().cancelAllNotifications();
                status = RETEST;
            } else {
                List<String> result = new ArrayList<>(MockListener.getInstance().mRemoved);
                if (result.size() != 0
                        && result.contains(mTag1)
                        && result.contains(mTag2)
                        && result.contains(mTag3)) {
                    status = PASS;
                } else {
                    logFail();
                    status = FAIL;
                }
            }
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
        }
    }

    private class IsDisabledTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createNlsSettingsItem(parent, R.string.nls_disable_service);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            String listeners = Secure.getString(getContentResolver(),
                    ENABLED_NOTIFICATION_LISTENERS);
            if (listeners == null || !listeners.contains(LISTENER_PATH)) {
                status = PASS;
            } else {
                status = WAIT_FOR_USER;
            }
        }

        @Override
        protected void tearDown() {
            MockListener.getInstance().resetData();
        }

        @Override
        protected Intent getIntent() {
            return new Intent(ACTION_NOTIFICATION_LISTENER_SETTINGS);
        }
    }

    private class ServiceStoppedTest extends InteractiveTestCase {
        int mRetries = 3;
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_service_stopped);
        }

        @Override
        protected void test() {
            if (mNm.getEffectsSuppressor() == null && (MockListener.getInstance() == null
                    || !MockListener.getInstance().isConnected)) {
                status = PASS;
            } else {
                if (--mRetries > 0) {
                    sleep(100);
                    status = RETEST;
                } else {
                    status = FAIL;
                }
            }
        }

        @Override
        protected Intent getIntent() {
            return new Intent(ACTION_NOTIFICATION_LISTENER_SETTINGS);
        }
    }

    private class NotificationNotReceivedTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_note_missed);

        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void test() {
            if (MockListener.getInstance() == null) {
                status = PASS;
            } else {
                if (MockListener.getInstance().mPosted.size() == 0) {
                    status = PASS;
                } else {
                    logFail();
                    status = FAIL;
                }
            }
            next();
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            if (MockListener.getInstance() != null) {
                MockListener.getInstance().resetData();
            }
        }
    }

    private class RequestUnbindTest extends InteractiveTestCase {
        int mRetries = 5;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_snooze);

        }

        @Override
        protected void setUp() {
            status = READY;
            MockListener.getInstance().requestListenerHints(
                    MockListener.HINT_HOST_DISABLE_CALL_EFFECTS);
        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.getInstance().requestUnbind();
                status = RETEST;
            } else {
                if (mNm.getEffectsSuppressor() == null && !MockListener.getInstance().isConnected) {
                    status = PASS;
                } else {
                    if (--mRetries > 0) {
                        status = RETEST;
                    } else {
                        logFail();
                        status = FAIL;
                    }
                }
                next();
            }
        }
    }

    private class RequestBindTest extends InteractiveTestCase {
        int mRetries = 5;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_unsnooze);

        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.requestRebind(MockListener.COMPONENT_NAME);
                status = RETEST;
            } else {
                if (MockListener.getInstance().isConnected) {
                    status = PASS;
                    next();
                } else {
                    if (--mRetries > 0) {
                        status = RETEST;
                        next();
                    } else {
                        logFail();
                        status = FAIL;
                    }
                }
            }
        }
    }

    private class EnableHintsTest extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_hints);

        }

        @Override
        protected void test() {
            if (status == READY) {
                MockListener.getInstance().requestListenerHints(
                        MockListener.HINT_HOST_DISABLE_CALL_EFFECTS);
                status = RETEST;
            } else {
                int result = MockListener.getInstance().getCurrentListenerHints();
                if ((result & MockListener.HINT_HOST_DISABLE_CALL_EFFECTS)
                        == MockListener.HINT_HOST_DISABLE_CALL_EFFECTS) {
                    status = PASS;
                    next();
                } else {
                    logFail();
                    status = FAIL;
                }
            }
        }
    }

    private class SnoozeNotificationForTimeTest extends InteractiveTestCase {
        final static int READY_TO_SNOOZE = 0;
        final static int SNOOZED = 1;
        final static int READY_TO_CHECK_FOR_UNSNOOZE = 2;
        int state = -1;
        long snoozeTime = 3000;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_snooze_one_time);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
            state = READY_TO_SNOOZE;
            delay();
        }

        @Override
        protected void test() {
            status = RETEST;
            if (state == READY_TO_SNOOZE) {
                MockListener.getInstance().snoozeNotification(
                        MockListener.getInstance().getKeyForTag(mTag1), snoozeTime);
                state = SNOOZED;
            } else if (state == SNOOZED) {
                List<JSONObject> result =
                        new ArrayList<>(MockListener.getInstance().mRemovedReason.values());
                boolean pass = false;
                for (JSONObject payload : result) {
                    try {
                        pass |= (checkEquals(mTag1,
                                payload.getString(JSON_TAG),
                                "data dismissal test: notification tag (%s, %s)")
                                && checkEquals(MockListener.REASON_SNOOZED,
                                payload.getInt(JSON_REASON),
                                "data dismissal test: reason (%d, %d)"));
                        if (pass) {
                            break;
                        }
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
                if (!pass) {
                    logFail();
                    status = FAIL;
                    next();
                    return;
                } else {
                    state = READY_TO_CHECK_FOR_UNSNOOZE;
                }
            } else {
                if (MockListener.getInstance().getPosted(mTag1) != null) {
                    status = PASS;
                } else {
                    logFail();
                    status = FAIL;
                }
            }
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
            delay();
        }
    }

    /**
     * Posts notifications, snoozes one of them. Verifies that it is snoozed. Cancels all
     * notifications and reposts them. Confirms that the original notification is still snoozed.
     */
    private class SnoozeNotificationForTimeCancelTest extends InteractiveTestCase {

        final static int READY_TO_SNOOZE = 0;
        final static int SNOOZED = 1;
        final static int READY_TO_CHECK_FOR_SNOOZE = 2;
        int state = -1;
        long snoozeTime = 10000;
        private String tag;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_snooze_one_time);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            tag = mTag1;
            status = READY;
            state = READY_TO_SNOOZE;
            delay();
        }

        @Override
        protected void test() {
            status = RETEST;
            if (state == READY_TO_SNOOZE) {
                MockListener.getInstance().snoozeNotification(
                        MockListener.getInstance().getKeyForTag(tag), snoozeTime);
                state = SNOOZED;
            } else if (state == SNOOZED) {
                List<String> result = getSnoozed();
                if (result.size() >= 1
                        && result.contains(tag)) {
                    // cancel and repost
                    sendNotifications();
                    state = READY_TO_CHECK_FOR_SNOOZE;
                } else {
                    logFail();
                    status = FAIL;
                }
            } else {
                List<String> result = getSnoozed();
                if (result.size() >= 1
                        && result.contains(tag)) {
                    status = PASS;
                } else {
                    logFail();
                    status = FAIL;
                }
            }
        }

        private List<String> getSnoozed() {
            List<String> result = new ArrayList<>();
            StatusBarNotification[] snoozed = MockListener.getInstance().getSnoozedNotifications();
            for (StatusBarNotification sbn : snoozed) {
                result.add(sbn.getTag());
            }
            return result;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
        }
    }

    private class GetSnoozedNotificationTest extends InteractiveTestCase {
        final static int READY_TO_SNOOZE = 0;
        final static int SNOOZED = 1;
        final static int READY_TO_CHECK_FOR_GET_SNOOZE = 2;
        int state = -1;
        long snoozeTime = 30000;

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_get_snoozed);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
            state = READY_TO_SNOOZE;
        }

        @Override
        protected void test() {
            status = RETEST;
            if (state == READY_TO_SNOOZE) {
                MockListener.getInstance().snoozeNotification(
                        MockListener.getInstance().getKeyForTag(mTag1), snoozeTime);
                MockListener.getInstance().snoozeNotification(
                        MockListener.getInstance().getKeyForTag(mTag2), snoozeTime);
                state = SNOOZED;
            } else if (state == SNOOZED) {
                List<JSONObject> result =
                        new ArrayList<>(MockListener.getInstance().mRemovedReason.values());
                if (result.size() == 0) {
                    status = FAIL;
                    return;
                }
                boolean pass = false;
                for (JSONObject payload : result) {
                    try {
                        pass |= (checkEquals(mTag1,
                                payload.getString(JSON_TAG),
                                "data dismissal test: notification tag (%s, %s)")
                                && checkEquals(MockListener.REASON_SNOOZED,
                                payload.getInt(JSON_REASON),
                                "data dismissal test: reason (%d, %d)"));
                        if (pass) {
                            break;
                        }
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
                if (!pass) {
                    logFail();
                    status = FAIL;
                } else {
                    state = READY_TO_CHECK_FOR_GET_SNOOZE;
                }
            } else {
                List<String> result = new ArrayList<>();
                StatusBarNotification[] snoozed =
                        MockListener.getInstance().getSnoozedNotifications();
                for (StatusBarNotification sbn : snoozed) {
                    result.add(sbn.getTag());
                }
                if (result.size() >= 2
                        && result.contains(mTag1)
                        && result.contains(mTag2)) {
                    status = PASS;
                } else {
                    logFail();
                    status = FAIL;
                }
            }
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            MockListener.getInstance().resetData();
            delay();
        }
    }

    /** Tests that the extras {@link Bundle} in a MessagingStyle#Message is preserved. */
    private class MessageBundleTest extends InteractiveTestCase {
        private final String extrasKey1 = "extras_key_1";
        private final CharSequence extrasValue1 = "extras_value_1";
        private final String extrasKey2 = "extras_key_2";
        private final CharSequence extrasValue2 = "extras_value_2";

        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.msg_extras_preserved);
        }

        @Override
        protected void setUp() {
            createChannels();
            sendMessagingNotification();
            status = READY;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            delay();
        }

        private void sendMessagingNotification() {
            mTag1 = UUID.randomUUID().toString();
            mNm.cancelAll();
            mWhen1 = System.currentTimeMillis() + 1;
            mIcon1 = R.drawable.ic_stat_alice;
            mId1 = NOTIFICATION_ID + 1;

            Notification.MessagingStyle.Message msg1 =
                    new Notification.MessagingStyle.Message("text1", 0 /* timestamp */, "sender1");
            msg1.getExtras().putCharSequence(extrasKey1, extrasValue1);

            Notification.MessagingStyle.Message msg2 =
                    new Notification.MessagingStyle.Message("text2", 1 /* timestamp */, "sender2");
            msg2.getExtras().putCharSequence(extrasKey2, extrasValue2);

            Notification.MessagingStyle style = new Notification.MessagingStyle("display_name");
            style.addMessage(msg1);
            style.addMessage(msg2);

            Notification n1 = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                    .setContentTitle("ClearTest 1")
                    .setContentText(mTag1.toString())
                    .setPriority(Notification.PRIORITY_LOW)
                    .setSmallIcon(mIcon1)
                    .setWhen(mWhen1)
                    .setDeleteIntent(makeIntent(1, mTag1))
                    .setOnlyAlertOnce(true)
                    .setStyle(style)
                    .build();
            mNm.notify(mTag1, mId1, n1);
            mFlag1 = Notification.FLAG_ONLY_ALERT_ONCE;
        }

        // Returns true on success.
        private boolean verifyMessage(
                NotificationCompat.MessagingStyle.Message message,
                String extrasKey,
                CharSequence extrasValue) {
            return message.getExtras() != null
                    && message.getExtras().getCharSequence(extrasKey) != null
                    && message.getExtras().getCharSequence(extrasKey).equals(extrasValue);
        }

        @Override
        protected void test() {
            List<Notification> result =
                    new ArrayList<>(MockListener.getInstance().mPostedNotifications);
            if (result.size() != 1 || result.get(0) == null) {
                logFail();
                status = FAIL;
                next();
                return;
            }
            // Can only read in MessagingStyle using the compat class.
            NotificationCompat.MessagingStyle readStyle =
                    NotificationCompat.MessagingStyle
                            .extractMessagingStyleFromNotification(
                                    result.get(0));
            if (readStyle == null || readStyle.getMessages().size() != 2) {
                status = FAIL;
                logFail();
                next();
                return;
            }

            if (!verifyMessage(readStyle.getMessages().get(0), extrasKey1,
                    extrasValue1)
                    || !verifyMessage(
                    readStyle.getMessages().get(1), extrasKey2, extrasValue2)) {
                status = FAIL;
                logFail();
                next();
                return;
            }

            status = PASS;
        }
    }

    /**
     * Tests that conversation notifications appear at the top of the shade, if the device supports
     * a separate conversation section
     */
    private class ConversationOrderingTest extends InteractiveTestCase {
        private static final String SHARE_SHORTCUT_ID = "shareShortcut";
        private static final String SHORTCUT_CATEGORY =
                "com.android.cts.verifier.notifications.SHORTCUT_CATEGORY";

        @Override
        protected void setUp() {
            createChannels();
            createDynamicShortcut();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            delay();
        }

        @Override
        protected View inflate(ViewGroup parent) {
            return createPassFailItem(parent, R.string.conversation_section_ordering);
        }

        private void createDynamicShortcut() {
            Person person = new Person.Builder()
                    .setBot(false)
                    .setIcon(Icon.createWithResource(mContext, R.drawable.ic_stat_alice))
                    .setName("Person A")
                    .setImportant(true)
                    .build();

            Set<String> categorySet = new ArraySet<>();
            categorySet.add(SHORTCUT_CATEGORY);
            Intent shortcutIntent =
                    new Intent(mContext, BubbleActivity.class);
            shortcutIntent.setAction(Intent.ACTION_VIEW);

            ShortcutInfo shortcut = new ShortcutInfo.Builder(mContext, SHARE_SHORTCUT_ID)
                    .setShortLabel(SHARE_SHORTCUT_ID)
                    .setIcon(Icon.createWithResource(mContext, R.drawable.ic_stat_alice))
                    .setIntent(shortcutIntent)
                    .setPerson(person)
                    .setCategories(categorySet)
                    .setLongLived(true)
                    .build();

            ShortcutManager scManager =
                    (ShortcutManager) mContext.getSystemService(Context.SHORTCUT_SERVICE);
            scManager.addDynamicShortcuts(Arrays.asList(shortcut));
        }

        private void sendNotifications() {
            mTag1 = UUID.randomUUID().toString();
            mId1 = NOTIFICATION_ID + 1;

            Person person = new Person.Builder()
                    .setName("Person A")
                    .build();

            Notification n1 = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                    .setContentTitle("ConversationOrderingTest")
                    .setContentText(mTag1)
                    .setSmallIcon(R.drawable.ic_stat_alice)
                    .setShortcutId(SHARE_SHORTCUT_ID)
                    .setStyle(new Notification.MessagingStyle(person)
                            .setConversationTitle("Bubble Chat")
                            .addMessage("Hello?",
                                    SystemClock.currentThreadTimeMillis() - 300000, person)
                            .addMessage("Is it me you're looking for?",
                                    SystemClock.currentThreadTimeMillis(), person)
                    )
                    .build();
            mNm.notify(mTag1, mId1, n1);

            mTag2 = UUID.randomUUID().toString();
            mId2 = mId1 + 1;
            Notification n2 = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                    .setContentTitle("Non-Person Notification")
                    .setContentText(mTag1)
                    .setSmallIcon(R.drawable.ic_stat_alice)
                    .build();
            mNm.notify(mTag2, mId2, n2);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            status = WAIT_FOR_USER;
            next();
        }
    }

    /**
     * Tests that heads-up notifications appear with the view, resources, and actions provided
     * in Notification.Builder.
     */
    private class HunDisplayTest extends InteractiveTestCase {

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            status = READY;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            deleteChannels();
            delay();
        }

        @Override
        protected View inflate(ViewGroup parent) {
            return createPassFailItem(parent, R.string.hun_display);
        }

        private void sendNotifications() {
            mTag1 = UUID.randomUUID().toString();
            mId1 = NOTIFICATION_ID + 1;

            Notification n1 = new Notification.Builder(mContext, NOISY_NOTIFICATION_CHANNEL_ID)
                    .setContentTitle("HunDisplayTest")
                    .setContentText(mTag1)
                    .setSmallIcon(R.drawable.ic_stat_alice)
                    .setLargeIcon(Icon.createWithResource(mContext, R.drawable.test_pass_gradient))
                    .addAction(generateAction(1))
                    .addAction(generateAction(2))
                    .build();
            mNm.notify(mTag1, mId1, n1);
        }

        private Notification.Action generateAction(int num) {
            PendingIntent pi = PendingIntent.getActivity(mContext, num,
                    new Intent(Settings.ACTION_ALL_APPS_NOTIFICATION_SETTINGS),
                    PendingIntent.FLAG_IMMUTABLE);
            return new Notification.Action.Builder(
                    Icon.createWithResource(mContext, R.drawable.ic_android),
                    mContext.getString(R.string.action, num), pi)
                    .build();
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            status = WAIT_FOR_USER;
            next();
        }
    }

    /**
     * Sends the user to settings filter out silent notifications for this notification listener.
     * Sends silent and not silent notifs and makes sure only the non silent is received
     */
    private class NotificationTypeFilterTest extends InteractiveTestCase {
        int mRetries = 3;
        @Override
        protected View inflate(ViewGroup parent) {
            return createAutoItem(parent, R.string.nls_filter_test);

        }

        @Override
        protected void setUp() {
            createChannels();
            sendNotifications();
            sendNoisyNotification();
            status = READY;
        }

        @Override
        protected void tearDown() {
            mNm.cancelAll();
            MockListener.getInstance().resetData();
            deleteChannels();
        }

        @Override
        protected void test() {
            if (MockListener.getInstance().getPosted(mTag4) == null) {
                Log.d(TAG, "Could not find " + mTag4);
                if (--mRetries > 0) {
                    sleep(100);
                    status = RETEST;
                } else {
                    status = FAIL;
                }
            } else if (MockListener.getInstance().getPosted(mTag2) != null) {
                logFail("Found" + mTag2);
                status = FAIL;
            } else {
                status = PASS;
            }
        }
    }

    protected class SendUserToChangeFilter extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createUserItem(
                    parent, R.string.cp_start_settings,  R.string.nls_change_type_filter);
        }

        @Override
        protected void setUp() {
            // note: it's expected that the '0' type will be ignored since we've specified a
            // type in the manifest
            ArrayList<String> pkgs = new ArrayList<>();
            pkgs.add("com.android.settings");
            MockListener.getInstance().migrateNotificationFilter(0, pkgs);
            status = READY;
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            if (getIntent().resolveActivity(mPackageManager) == null) {
                logFail("no settings activity");
                status = FAIL;
            } else {
                if (buttonPressed) {
                    status = PASS;
                } else {
                    status = RETEST_AFTER_LONG_DELAY;
                }
                next();
            }
        }

        protected void tearDown() {
            // wait for the service to start
            delay();
        }

        @Override
        protected Intent getIntent() {
            Intent intent = new Intent(Settings.ACTION_NOTIFICATION_LISTENER_DETAIL_SETTINGS);
            intent.putExtra(Settings.EXTRA_NOTIFICATION_LISTENER_COMPONENT_NAME,
                    MockListener.COMPONENT_NAME.flattenToString());
            return intent;
        }
    }

    protected class ResetChangeFilter extends SendUserToChangeFilter {
        @Override
        protected View inflate(ViewGroup parent) {
            return createUserItem(
                    parent, R.string.cp_start_settings,  R.string.nls_reset_type_filter);
        }
    }

    protected class AskIfFilterChanged extends InteractiveTestCase {
        @Override
        protected View inflate(ViewGroup parent) {
            return createPassFailItem(parent, R.string.nls_original_filter_verification);
        }

        @Override
        boolean autoStart() {
            return true;
        }

        @Override
        protected void test() {
            status = WAIT_FOR_USER;
            next();
        }
    }
}