/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.app.notification.legacy29.cts;

import static android.service.notification.NotificationAssistantService.FEEDBACK_RATING;

import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;
import static junit.framework.TestCase.assertFalse;
import static junit.framework.TestCase.assertNotNull;

import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeFalse;

import android.app.Instrumentation;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Person;
import android.app.StatusBarManager;
import android.app.UiAutomation;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.os.SystemClock;
import android.provider.Telephony;
import android.service.notification.Adjustment;
import android.service.notification.NotificationAssistantService;
import android.service.notification.NotificationListenerService;
import android.service.notification.StatusBarNotification;

import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

import junit.framework.Assert;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@RunWith(AndroidJUnit4.class)
public class NotificationAssistantServiceTest {

    final String TAG = "NotAsstServiceTest";
    final String NOTIFICATION_CHANNEL_ID = "NotificationAssistantServiceTest";
    final int ICON_ID = android.R.drawable.sym_def_app_icon;
    final long SLEEP_TIME = 1000; // milliseconds

    private TestNotificationAssistant mNotificationAssistantService;
    private TestNotificationListener mNotificationListenerService;
    private NotificationManager mNotificationManager;
    private StatusBarManager mStatusBarManager;
    private Context mContext;
    private UiAutomation mUi;

    private boolean isWatch() {
      return mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH);
    }

    @Before
    public void setUp() throws IOException {
        mUi = InstrumentationRegistry.getInstrumentation().getUiAutomation();
        mContext = InstrumentationRegistry.getContext();
        mNotificationManager = (NotificationManager) mContext.getSystemService(
                Context.NOTIFICATION_SERVICE);
        mNotificationManager.createNotificationChannel(new NotificationChannel(
                NOTIFICATION_CHANNEL_ID, "name", NotificationManager.IMPORTANCE_DEFAULT));
        mStatusBarManager = (StatusBarManager) mContext.getSystemService(
                Context.STATUS_BAR_SERVICE);
    }

    @After
    public void tearDown() throws IOException {
        if (mNotificationListenerService != null) mNotificationListenerService.resetData();

        toggleListenerAccess(false);
        toggleAssistantAccess(false);
        mUi.dropShellPermissionIdentity();
    }

    @Test
    public void testOnNotificationEnqueued() throws Exception {
        toggleListenerAccess(true);
        Thread.sleep(SLEEP_TIME);

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_USER_SENTIMENT);
        mUi.dropShellPermissionIdentity();

        mNotificationListenerService = TestNotificationListener.getInstance();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        // No modification because the Notification Assistant is not enabled
        assertEquals(NotificationListenerService.Ranking.USER_SENTIMENT_NEUTRAL,
                out.getUserSentiment());
        mNotificationListenerService.resetData();

        toggleAssistantAccess(true);
        Thread.sleep(SLEEP_TIME); // wait for listener and assistant to be allowed
        mNotificationAssistantService = TestNotificationAssistant.getInstance();

        sendNotification(1, ICON_ID);
        sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        // Assistant gets correct rank
        assertTrue(mNotificationAssistantService.notificationRank >= 0);
        // Assistant modifies notification
        assertEquals(NotificationListenerService.Ranking.USER_SENTIMENT_POSITIVE,
                out.getUserSentiment());
    }

    @Test
    public void testAdjustNotification_userSentimentKey() throws Exception {
        setUpListeners();

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_USER_SENTIMENT);
        mUi.dropShellPermissionIdentity();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        assertEquals(NotificationListenerService.Ranking.USER_SENTIMENT_POSITIVE,
                out.getUserSentiment());

        Bundle signals = new Bundle();
        signals.putInt(Adjustment.KEY_USER_SENTIMENT,
                NotificationListenerService.Ranking.USER_SENTIMENT_NEGATIVE);
        Adjustment adjustment = new Adjustment(sbn.getPackageName(), sbn.getKey(), signals, "",
                sbn.getUser());

        mNotificationAssistantService.adjustNotification(adjustment);
        Thread.sleep(SLEEP_TIME); // wait for adjustment to be processed

        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        assertEquals(NotificationListenerService.Ranking.USER_SENTIMENT_NEGATIVE,
                out.getUserSentiment());
    }

    @Test
    public void testAdjustNotification_importanceKey() throws Exception {
        setUpListeners();

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_IMPORTANCE);
        mUi.dropShellPermissionIdentity();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        int currentImportance = out.getImportance();
        int newImportance = currentImportance == NotificationManager.IMPORTANCE_DEFAULT
                ? NotificationManager.IMPORTANCE_HIGH : NotificationManager.IMPORTANCE_DEFAULT;

        Bundle signals = new Bundle();
        signals.putInt(Adjustment.KEY_IMPORTANCE, newImportance);
        Adjustment adjustment = new Adjustment(sbn.getPackageName(), sbn.getKey(), signals, "",
                sbn.getUser());

        mNotificationAssistantService.adjustNotification(adjustment);
        Thread.sleep(SLEEP_TIME); // wait for adjustment to be processed

        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        assertEquals(newImportance, out.getImportance());
    }

    @Test
    public void testAdjustNotifications_rankingScoreKey() throws Exception {
        setUpListeners();

        try {
            mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
            mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_RANKING_SCORE);
            mUi.dropShellPermissionIdentity();

            sendNotification(1, ICON_ID);
            StatusBarNotification sbn1 = getFirstNotificationFromPackage(
                    TestNotificationListener.PKG);
            NotificationListenerService.Ranking out1 = new NotificationListenerService.Ranking();

            sendNotification(2, ICON_ID);
            StatusBarNotification sbn2 = getFirstNotificationFromPackage(
                    TestNotificationListener.PKG);
            NotificationListenerService.Ranking out2 = new NotificationListenerService.Ranking();

            mNotificationListenerService.mRankingMap.getRanking(sbn1.getKey(), out1);
            mNotificationListenerService.mRankingMap.getRanking(sbn2.getKey(), out2);

            int currentRank1 = out1.getRank();
            int currentRank2 = out2.getRank();

            float rankingScore1 = (currentRank1 > currentRank2) ? 1f : 0;
            float rankingScore2 = (currentRank1 > currentRank2) ? 0 : 1f;

            Bundle signals = new Bundle();
            signals.putFloat(Adjustment.KEY_RANKING_SCORE, rankingScore1);
            Adjustment adjustment = new Adjustment(sbn1.getPackageName(), sbn1.getKey(), signals, "",
                    sbn1.getUser());
            Bundle signals2 = new Bundle();
            signals2.putFloat(Adjustment.KEY_RANKING_SCORE, rankingScore2);
            Adjustment adjustment2 = new Adjustment(sbn2.getPackageName(), sbn2.getKey(), signals2, "",
                    sbn2.getUser());
            mNotificationAssistantService.adjustNotifications(List.of(adjustment, adjustment2));
            Thread.sleep(SLEEP_TIME); // wait for adjustments to be processed

            mNotificationListenerService.mRankingMap.getRanking(sbn1.getKey(), out1);
            mNotificationListenerService.mRankingMap.getRanking(sbn2.getKey(), out2);

            // verify the relative ordering changed
            int newRank1 = out1.getRank();
            int newRank2 = out2.getRank();
            if (currentRank1 > currentRank2) {
                assertTrue(newRank1 < newRank2);
            } else {
                assertTrue(newRank1 > newRank2);
            }
        } finally {
            mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
            mNotificationManager.disallowAssistantAdjustment(Adjustment.KEY_RANKING_SCORE);
            mUi.dropShellPermissionIdentity();
        }
    }

    @Test
    public void testAdjustNotification_smartActionKey() throws Exception {
        setUpListeners();

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_CONTEXTUAL_ACTIONS);
        mUi.dropShellPermissionIdentity();

        PendingIntent sendIntent = PendingIntent.getActivity(mContext, 0,
                new Intent(Intent.ACTION_SEND), PendingIntent.FLAG_MUTABLE_UNAUDITED);
        Notification.Action sendAction = new Notification.Action.Builder(ICON_ID, "SEND",
                sendIntent).build();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        List<Notification.Action> smartActions = out.getSmartActions();
        if (smartActions != null) {
            for (int i = 0; i < smartActions.size(); i++) {
                Notification.Action action = smartActions.get(i);
                assertNotEquals(sendIntent, action.actionIntent);
            }
        }

        ArrayList<Notification.Action> extraAction = new ArrayList<>();
        extraAction.add(sendAction);
        Bundle signals = new Bundle();
        signals.putParcelableArrayList(Adjustment.KEY_CONTEXTUAL_ACTIONS, extraAction);
        Adjustment adjustment = new Adjustment(sbn.getPackageName(), sbn.getKey(), signals, "",
                sbn.getUser());

        mNotificationAssistantService.adjustNotification(adjustment);
        Thread.sleep(SLEEP_TIME); //wait for adjustment to be processed

        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        boolean actionFound = false;
        smartActions = out.getSmartActions();
        for (int i = 0; i < smartActions.size(); i++) {
            Notification.Action action = smartActions.get(i);
            actionFound = actionFound || action.actionIntent.equals(sendIntent);
        }
        assertTrue(actionFound);
    }

    @Test
    public void testAdjustNotification_smartReplyKey() throws Exception {
        setUpListeners();
        CharSequence smartReply = "Smart Reply!";

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_TEXT_REPLIES);
        mUi.dropShellPermissionIdentity();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        List<CharSequence> smartReplies = out.getSmartReplies();
        if (smartReplies != null) {
            for (int i = 0; i < smartReplies.size(); i++) {
                CharSequence reply = smartReplies.get(i);
                assertNotEquals(smartReply, reply);
            }
        }

        ArrayList<CharSequence> extraReply = new ArrayList<>();
        extraReply.add(smartReply);
        Bundle signals = new Bundle();
        signals.putCharSequenceArrayList(Adjustment.KEY_TEXT_REPLIES, extraReply);
        Adjustment adjustment = new Adjustment(sbn.getPackageName(), sbn.getKey(), signals, "",
                sbn.getUser());

        mNotificationAssistantService.adjustNotification(adjustment);
        Thread.sleep(SLEEP_TIME); //wait for adjustment to be processed

        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        boolean replyFound = false;
        smartReplies = out.getSmartReplies();
        for (int i = 0; i < smartReplies.size(); i++) {
            CharSequence reply = smartReplies.get(i);
            replyFound = replyFound || reply.equals(smartReply);
        }
        assertTrue(replyFound);
    }

    @Test
    public void testAdjustNotification_importanceKey_notAllowed() throws Exception {
        setUpListeners();

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.disallowAssistantAdjustment(Adjustment.KEY_IMPORTANCE);
        mUi.dropShellPermissionIdentity();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(
                TestNotificationListener.PKG);
        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        int currentImportance = out.getImportance();
        int newImportance = currentImportance == NotificationManager.IMPORTANCE_DEFAULT
                ? NotificationManager.IMPORTANCE_HIGH : NotificationManager.IMPORTANCE_DEFAULT;

        Bundle signals = new Bundle();
        signals.putInt(Adjustment.KEY_IMPORTANCE, newImportance);
        Adjustment adjustment = new Adjustment(sbn.getPackageName(), sbn.getKey(), signals, "",
                sbn.getUser());

        mNotificationAssistantService.adjustNotification(adjustment);
        Thread.sleep(SLEEP_TIME); // wait for adjustment to be processed

        mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);

        assertEquals(currentImportance, out.getImportance());

    }

    @Test
    public void testAdjustNotification_rankingScoreKey_notAllowed() throws Exception {
        setUpListeners();

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.cancelAll();
        mNotificationManager.disallowAssistantAdjustment(Adjustment.KEY_RANKING_SCORE);
        mUi.dropShellPermissionIdentity();

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn1 = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out1 = new NotificationListenerService.Ranking();

        sendNotification(2, ICON_ID);
        StatusBarNotification sbn2 = getFirstNotificationFromPackage(TestNotificationListener.PKG);
        NotificationListenerService.Ranking out2 = new NotificationListenerService.Ranking();

        mNotificationListenerService.mRankingMap.getRanking(sbn1.getKey(), out1);
        mNotificationListenerService.mRankingMap.getRanking(sbn2.getKey(), out2);

        int currentRank1 = out1.getRank();
        int currentRank2 = out2.getRank();

        float rankingScore1 = (currentRank1 > currentRank2) ? 1f: 0;
        float rankingScore2 = (currentRank1 > currentRank2) ? 0: 1f;

        Bundle signals = new Bundle();
        signals.putFloat(Adjustment.KEY_RANKING_SCORE, rankingScore1);
        Adjustment adjustment = new Adjustment(sbn1.getPackageName(), sbn1.getKey(), signals, "",
                sbn1.getUser());
        mNotificationAssistantService.adjustNotification(adjustment);
        signals = new Bundle();
        signals.putFloat(Adjustment.KEY_RANKING_SCORE, rankingScore2);
        adjustment = new Adjustment(sbn2.getPackageName(), sbn2.getKey(), signals, "",
                sbn2.getUser());
        mNotificationAssistantService.adjustNotification(adjustment);
        Thread.sleep(SLEEP_TIME); // wait for adjustments to be processed

        mNotificationListenerService.mRankingMap.getRanking(sbn1.getKey(), out1);
        mNotificationListenerService.mRankingMap.getRanking(sbn2.getKey(), out2);

        // verify the relative ordering remains the same
        int newRank1 = out1.getRank();
        int newRank2 = out2.getRank();
        if (currentRank1 > currentRank2) {
            assertTrue(newRank1 > newRank2);
        } else {
            assertTrue(newRank1 < newRank2);
        }
    }

    @Test
    public void testGetAllowedAssistantCapabilities_permission() throws Exception {
        toggleAssistantAccess(false);

        try {
            mNotificationManager.getAllowedAssistantAdjustments();
            fail(" Non assistants cannot call this method");
        } catch (SecurityException e) {
            //pass
        }
    }

    @Test
    public void testGetAllowedAssistantCapabilities() throws Exception {
        toggleAssistantAccess(true);
        Thread.sleep(SLEEP_TIME); // wait for assistant to be allowed
        mNotificationAssistantService = TestNotificationAssistant.getInstance();
        mNotificationAssistantService.onAllowedAdjustmentsChanged();
        assertNotNull(mNotificationAssistantService.currentCapabilities);

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE");
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_SNOOZE_CRITERIA);

        Thread.sleep(SLEEP_TIME);
        assertTrue(mNotificationAssistantService.currentCapabilities.contains(
                Adjustment.KEY_SNOOZE_CRITERIA));

        mNotificationManager.disallowAssistantAdjustment(Adjustment.KEY_SNOOZE_CRITERIA);
        Thread.sleep(SLEEP_TIME);
        assertFalse(mNotificationAssistantService.currentCapabilities.contains(
                Adjustment.KEY_SNOOZE_CRITERIA));

        // just in case KEY_SNOOZE_CRITERIA was included in the original set, test adding again
        mNotificationManager.allowAssistantAdjustment(Adjustment.KEY_SNOOZE_CRITERIA);
        Thread.sleep(SLEEP_TIME);
        assertTrue(mNotificationAssistantService.currentCapabilities.contains(
                Adjustment.KEY_SNOOZE_CRITERIA));

        mUi.dropShellPermissionIdentity();
    }

    @Test
    public void testOnNotificationSnoozedUntilContext() throws Exception {
        final String snoozeContext = "@SnoozeContext1@";

        setUpListeners(); // also enables assistant

        sendNotification(1001, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);

        // simulate the user snoozing the notification
        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
        runCommand(String.format("cmd notification snooze --condition %s %s", snoozeContext,
                sbn.getKey()), instrumentation);

        Thread.sleep(SLEEP_TIME);

        assertTrue(String.format("snoozed notification <%s> was not removed", sbn.getKey()),
                mNotificationListenerService.checkRemovedKey(sbn.getKey()));

        assertEquals(String.format("snoozed notification <%s> was not observed by NAS", sbn.getKey()),
                sbn.getKey(), mNotificationAssistantService.snoozedKey);
        assertEquals(snoozeContext, mNotificationAssistantService.snoozedUntilContext);
    }

    @Test
    public void testUnsnoozeFromNAS() throws Exception {
        final String snoozeContext = "@SnoozeContext2@";

        setUpListeners(); // also enables assistant

        sendNotification(1002, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);

        // simulate the user snoozing the notification
        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
        runCommand(String.format("cmd notification snooze --context %s %s", snoozeContext,
            sbn.getKey()), instrumentation);

        Thread.sleep(SLEEP_TIME);

        // unsnooze from listener
        mNotificationAssistantService = TestNotificationAssistant.getInstance();
        android.util.Log.v(TAG, "unsnoozing from listener: " + sbn.getKey());
        mNotificationAssistantService.unsnoozeNotification(sbn.getKey());

        Thread.sleep(SLEEP_TIME);

        NotificationListenerService.Ranking out = new NotificationListenerService.Ranking();
        boolean found = mNotificationListenerService.mRankingMap.getRanking(sbn.getKey(), out);
        assertTrue("notification <" + sbn.getKey()
                + "> was not restored when unsnoozed from listener",
                found);
    }

    @Test
    public void testOnActionInvoked_methodExists() throws Exception {
        setUpListeners();
        final Intent intent = new Intent(Intent.ACTION_MAIN, Telephony.Threads.CONTENT_URI);

        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP
                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.setAction(Intent.ACTION_MAIN);

        final PendingIntent pendingIntent = PendingIntent.getActivity(mContext, 0, intent, PendingIntent.FLAG_MUTABLE_UNAUDITED);
        Notification.Action action = new Notification.Action.Builder(null, "",
                pendingIntent).build();
        // This method has to exist and the call cannot fail
        mNotificationAssistantService.onActionInvoked("", action,
                NotificationAssistantService.SOURCE_FROM_APP);
    }

    @Test
    public void testOnNotificationDirectReplied_methodExists() throws Exception {
        setUpListeners();
        // This method has to exist and the call cannot fail
        mNotificationAssistantService.onNotificationDirectReplied("");
    }

    @Test
    public void testOnNotificationExpansionChanged_methodExists() throws Exception {
        setUpListeners();
        // This method has to exist and the call cannot fail
        mNotificationAssistantService.onNotificationExpansionChanged("", true, true);
    }

    @Test
    public void testOnNotificationVisibilityChanged() throws Exception {
        if (isTelevision()) {
            return;
        }
        assumeFalse("Status bar service not supported", isWatch());
        setUpListeners();
        turnScreenOn();
        mUi.adoptShellPermissionIdentity("android.permission.EXPAND_STATUS_BAR");

        sendConversationNotification(mNotificationAssistantService.notificationId);
        Thread.sleep(SLEEP_TIME * 2);

        // Initialize as closed
        mStatusBarManager.collapsePanels();
        Thread.sleep(SLEEP_TIME * 2);

        mStatusBarManager.expandNotificationsPanel();
        Thread.sleep(SLEEP_TIME * 2);
        assertTrue(mNotificationAssistantService.notificationVisible);

        mStatusBarManager.collapsePanels();
        Thread.sleep(SLEEP_TIME * 2);
        assertFalse(mNotificationAssistantService.notificationVisible);

        mUi.dropShellPermissionIdentity();
    }

    @Test
    public void testOnNotificationsSeen() throws Exception {
        if (isTelevision()) {
            return;
        }
        assumeFalse("Status bar service not supported", isWatch());
        setUpListeners();
        turnScreenOn();
        mUi.adoptShellPermissionIdentity("android.permission.EXPAND_STATUS_BAR");

        mNotificationAssistantService.resetNotificationVisibilityCounts();

        // Initialize as closed
        mStatusBarManager.collapsePanels();

        sendNotification(1, ICON_ID);
        assertEquals(0, mNotificationAssistantService.notificationSeenCount);

        mStatusBarManager.expandNotificationsPanel();
        Thread.sleep(SLEEP_TIME * 2);
        assertTrue(mNotificationAssistantService.notificationSeenCount > 0);

        mStatusBarManager.collapsePanels();
        mUi.dropShellPermissionIdentity();
    }

    @Test
    public void testOnPanelRevealedAndHidden() throws Exception {
        if (isTelevision()) {
            return;
        }
        assumeFalse("Status bar service not supported", isWatch());
        setUpListeners();
        turnScreenOn();
        mUi.adoptShellPermissionIdentity("android.permission.EXPAND_STATUS_BAR");

        // Initialize as closed
        mStatusBarManager.collapsePanels();
        assertFalse(mNotificationAssistantService.isPanelOpen);

        mStatusBarManager.expandNotificationsPanel();
        Thread.sleep(SLEEP_TIME * 2);
        assertTrue(mNotificationAssistantService.isPanelOpen);

        mStatusBarManager.collapsePanels();
        Thread.sleep(SLEEP_TIME * 2);
        assertFalse(mNotificationAssistantService.isPanelOpen);

        mUi.dropShellPermissionIdentity();
    }

    @Test
    public void testOnSuggestedReplySent_methodExists() throws Exception {
        setUpListeners();
        // This method has to exist and the call cannot fail
        mNotificationAssistantService.onSuggestedReplySent("", "",
                NotificationAssistantService.SOURCE_FROM_APP);
    }

    @Test
    public void testOnNotificationClicked() throws Exception {
        if (isTelevision()) {
            return;
        }

        setUpListeners();
        turnScreenOn();
        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE", "android.permission.EXPAND_STATUS_BAR");

        mNotificationAssistantService.resetNotificationClickCount();

        // Initialize as closed
        mStatusBarManager.collapsePanels();
        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);

        mStatusBarManager.expandNotificationsPanel();
        Thread.sleep(SLEEP_TIME * 2);
        mStatusBarManager.clickNotification(sbn.getKey(), 1, 1, true);
        Thread.sleep(SLEEP_TIME * 2);

        assertEquals(1, mNotificationAssistantService.notificationClickCount);

        mStatusBarManager.collapsePanels();
        mUi.dropShellPermissionIdentity();

    }

    @Test
    public void testOnNotificationFeedbackReceived() throws Exception {
        setUpListeners(); // also enables assistant
        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE", "android.permission.EXPAND_STATUS_BAR");

        sendNotification(1, ICON_ID);
        StatusBarNotification sbn = getFirstNotificationFromPackage(TestNotificationListener.PKG);

        Bundle feedback = new Bundle();
        feedback.putInt(FEEDBACK_RATING, 1);

        mStatusBarManager.sendNotificationFeedback(sbn.getKey(), feedback);
        Thread.sleep(SLEEP_TIME * 2);
        assertEquals(1, mNotificationAssistantService.notificationFeedback);

        mUi.dropShellPermissionIdentity();
    }

    private StatusBarNotification getFirstNotificationFromPackage(String PKG)
            throws InterruptedException {
        StatusBarNotification sbn = mNotificationListenerService.mPosted.poll(SLEEP_TIME,
                TimeUnit.MILLISECONDS);
        assertNotNull(sbn);
        while (!sbn.getPackageName().equals(PKG)) {
            sbn = mNotificationListenerService.mPosted.poll(SLEEP_TIME, TimeUnit.MILLISECONDS);
        }
        assertNotNull(sbn);
        return sbn;
    }

    private void setUpListeners() throws Exception {
        toggleListenerAccess(true);
        toggleAssistantAccess(true);
        Thread.sleep(2 * SLEEP_TIME); // wait for listener and assistant to be allowed

        mNotificationListenerService = TestNotificationListener.getInstance();
        mNotificationAssistantService = TestNotificationAssistant.getInstance();

        assertNotNull(mNotificationListenerService);
        assertNotNull(mNotificationAssistantService);
    }

    private void sendNotification(final int id, final int icon) throws Exception {
        sendNotification(id, null, icon);
    }

    private void sendNotification(final int id, String groupKey, final int icon) throws Exception {
        final Intent intent = new Intent(Intent.ACTION_MAIN, Telephony.Threads.CONTENT_URI);

        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP
                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.setAction(Intent.ACTION_MAIN);

        final PendingIntent pendingIntent = PendingIntent.getActivity(mContext, 0, intent, PendingIntent.FLAG_MUTABLE_UNAUDITED);
        final Notification notification =
                new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                        .setSmallIcon(icon)
                        .setWhen(System.currentTimeMillis())
                        .setContentTitle("notify#" + id)
                        .setContentText("This is #" + id + "notification  ")
                        .setContentIntent(pendingIntent)
                        .setGroup(groupKey)
                        .build();
        mNotificationManager.notify(id, notification);
    }

    private void sendConversationNotification(final int id) {
        Person person = new Person.Builder()
                .setName("test")
                .build();
        final Notification notification = new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)
                .setContentTitle("foo")
                .setShortcutId("shareShortcut")
                .setStyle(new Notification.MessagingStyle(person)
                        .setConversationTitle("Test Chat")
                        .addMessage("Hello?",
                                SystemClock.currentThreadTimeMillis() - 300000, person)
                        .addMessage("Is it me you're looking for?",
                                SystemClock.currentThreadTimeMillis(), person)
                )
                .setSmallIcon(ICON_ID)
                .build();
        mNotificationManager.notify(id, notification);
    }

    private void turnScreenOn() throws IOException {
        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
        runCommand("input keyevent KEYCODE_WAKEUP", instrumentation);
        runCommand("wm dismiss-keyguard", instrumentation);
    }

    private boolean isTelevision() {
        PackageManager packageManager = mContext.getPackageManager();
        return packageManager != null
                && (packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
                || packageManager.hasSystemFeature(PackageManager.FEATURE_TELEVISION));
    }

    private void toggleListenerAccess(boolean on) throws IOException {

        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
        String componentName = TestNotificationListener.getId();

        String command = " cmd notification " + (on ? "allow_listener " : "disallow_listener ")
                + componentName;

        runCommand(command, instrumentation);

        final ComponentName listenerComponent = TestNotificationListener.getComponentName();
        final NotificationManager nm = mContext.getSystemService(NotificationManager.class);
        Assert.assertTrue(listenerComponent + " has not been " + (on ? "allowed" : "disallowed"),
                nm.isNotificationListenerAccessGranted(listenerComponent) == on);
    }

    private void toggleAssistantAccess(boolean on) {
        final ComponentName assistantComponent = TestNotificationAssistant.getComponentName();

        mUi.adoptShellPermissionIdentity("android.permission.STATUS_BAR_SERVICE",
                "android.permission.REQUEST_NOTIFICATION_ASSISTANT_SERVICE");
        mNotificationManager.setNotificationAssistantAccessGranted(assistantComponent, on);

        assertTrue(assistantComponent + " has not been " + (on ? "allowed" : "disallowed"),
                mNotificationManager.isNotificationAssistantAccessGranted(assistantComponent)
                        == on);
        if (on) {
            assertEquals(assistantComponent,
                    mNotificationManager.getAllowedNotificationAssistant());
        } else {
            assertNotEquals(assistantComponent,
                    mNotificationManager.getAllowedNotificationAssistant());
        }

        mUi.dropShellPermissionIdentity();
    }

    private void runCommand(String command, Instrumentation instrumentation) throws IOException {
        UiAutomation uiAutomation = instrumentation.getUiAutomation();
        // Execute command
        System.out.println("runCommand: <<<" + command + ">>>");
        try (ParcelFileDescriptor fd = uiAutomation.executeShellCommand(command)) {
            assertNotNull("Failed to execute shell command: " + command, fd);
            // Wait for the command to finish by reading until EOF
            try (BufferedReader in = new BufferedReader(new FileReader(fd.getFileDescriptor()))) {
                String line;
                while (null != (line = in.readLine())) {
                    android.util.Log.v(TAG, "runCommand: output: " + line);
                }
            } catch (IOException e) {
                throw new IOException("Could not read stdout of command: " + command, e);
            }
        }
    }
}