Add CtsVerifier test for Screen Pinning

Some lock task functionality is tested through xts, however this does
not cover the user based portions of screen pinning, such as user
being able to exit anytime through back+overview.  This adds a quick
check of the API and that the user is still able to exit.

Bug: 18992713
Change-Id: I04017c76308c9dfd5b48b123cb398bb5a4c29509
(cherry picked from commit 5ece998a073b1e78433115b53fc0d5e097b7eec8)
diff --git a/apps/CtsVerifier/AndroidManifest.xml b/apps/CtsVerifier/AndroidManifest.xml
index 41ee319..53d493e 100644
--- a/apps/CtsVerifier/AndroidManifest.xml
+++ b/apps/CtsVerifier/AndroidManifest.xml
@@ -1500,6 +1500,15 @@
                     android:value="android.software.live_tv" />
         </activity>
 
+        <activity android:name=".screenpinning.ScreenPinningTestActivity"
+            android:label="@string/screen_pinning_test">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.cts.intent.category.MANUAL_TEST" />
+            </intent-filter>
+            <meta-data android:name="test_category" android:value="@string/test_category_other" />
+        </activity>
+
         <activity android:name=".tv.MockTvInputSettingsActivity">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
diff --git a/apps/CtsVerifier/res/layout/screen_pinning.xml b/apps/CtsVerifier/res/layout/screen_pinning.xml
new file mode 100644
index 0000000..f1d7b65
--- /dev/null
+++ b/apps/CtsVerifier/res/layout/screen_pinning.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2014 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.
+-->
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <TextView
+        android:id="@+id/error_text"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content" />
+
+    <ScrollView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentTop="true" >
+
+        <RelativeLayout
+            android:id="@+id/instructions_group"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical" >
+
+            <LinearLayout
+                android:id="@+id/instructions_list"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:orientation="vertical" >
+
+            </LinearLayout>
+
+            <Button
+                android:id="@+id/next_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_alignParentEnd="true"
+                android:layout_below="@id/instructions_list"
+                android:text="@string/next_button_text" />
+
+        </RelativeLayout>
+    </ScrollView>
+
+    <include
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        layout="@layout/pass_fail_buttons" />
+
+</RelativeLayout>
\ No newline at end of file
diff --git a/apps/CtsVerifier/res/values/strings.xml b/apps/CtsVerifier/res/values/strings.xml
index cb0a1d8..748abb5 100644
--- a/apps/CtsVerifier/res/values/strings.xml
+++ b/apps/CtsVerifier/res/values/strings.xml
@@ -1444,4 +1444,18 @@
 
     <!-- A list of fully-qualified test classes that should not be run. -->
     <string-array name="disabled_tests" />
+
+    <!-- Strings for screen pinning test -->
+    <string name="screen_pinning_test">Screen Pinning Test</string>
+    <string name="screen_pin_instructions">Pressing next will prompt you to enter screen pinning, allow this app to enter screen pinning.</string>
+    <string name="screen_pin_check_pinned">Press Next to verify the app is pinned.</string>
+    <string name="screen_pin_no_exit">Try to leave the app without unpinning the screen. Press next once you have verified you cannot leave.</string>
+    <string name="screen_pin_exit">Use interactions defined by your device to unpin such as long pressing the back and overview button, then press next.</string>
+    <string name="screen_pinning_done">All tests completed successfully.</string>
+
+    <string name="error_screen_no_longer_pinned">The screen was no longer pinned.</string>
+    <string name="error_screen_already_pinned">Cannot start the test with the screen already pinned.</string>
+    <string name="error_screen_pinning_did_not_start">Screen was not pinned.</string>
+    <string name="error_screen_pinning_did_not_exit">Screen was not unpinned.</string>
+    <string name="error_screen_pinning_couldnt_exit">Could not exit screen pinning through API.</string>
 </resources>
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/screenpinning/ScreenPinningTestActivity.java b/apps/CtsVerifier/src/com/android/cts/verifier/screenpinning/ScreenPinningTestActivity.java
new file mode 100644
index 0000000..200865e
--- /dev/null
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/screenpinning/ScreenPinningTestActivity.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2015 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.screenpinning;
+
+import android.app.ActivityManager;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.android.cts.verifier.PassFailButtons;
+import com.android.cts.verifier.R;
+
+public class ScreenPinningTestActivity extends PassFailButtons.Activity {
+
+    private static final String TAG = "ScreenPinningTestActivity";
+    private static final String KEY_CURRENT_TEST = "keyCurrentTest";
+
+    private Test[] mTests;
+    private int mTestIndex;
+
+    private ActivityManager mActivityManager;
+    private Button mNextButton;
+    private LinearLayout mInstructions;
+
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.screen_pinning);
+        setPassFailButtonClickListeners();
+
+        mTests = new Test[] {
+            // Verify not already pinned.
+            mCheckStartedUnpinned,
+            // Enter pinning, verify pinned, try leaving and have the user exit.
+            mCheckStartPinning,
+            mCheckIsPinned,
+            mCheckTryLeave,
+            mCheckUnpin,
+            // Enter pinning, verify pinned, and use APIs to exit.
+            mCheckStartPinning,
+            mCheckIsPinned,
+            mCheckUnpinFromCode,
+            // All done.
+            mDone,
+        };
+
+        mActivityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
+        mInstructions = (LinearLayout) findViewById(R.id.instructions_list);
+
+        mNextButton = (Button) findViewById(R.id.next_button);
+        mNextButton.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if ((mTestIndex >= 0) && (mTestIndex < mTests.length)) {
+                    mTests[mTestIndex].onNextClick();
+                }
+            }
+        });
+
+        // Don't allow pass until all tests complete.
+        findViewById(R.id.pass_button).setVisibility(View.GONE);
+
+        // Figure out if we are in a test or starting from the beginning.
+        if (savedInstanceState != null && savedInstanceState.containsKey(KEY_CURRENT_TEST)) {
+            mTestIndex = savedInstanceState.getInt(KEY_CURRENT_TEST);
+        } else {
+            mTestIndex = 0;
+        }
+        // Display any pre-existing text.
+        for (int i = 0; i < mTestIndex; i++) {
+            mTests[i].showText();
+        }
+        mTests[mTestIndex].run();
+    };
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        outState.putInt(KEY_CURRENT_TEST, mTestIndex);
+    }
+
+    @Override
+    public void onBackPressed() {
+        // Block back button so we can test screen pinning exit functionality.
+        // Users can still leave by pressing fail (or when done the pass) button.
+    }
+
+    private void show(int id) {
+        TextView tv = new TextView(this);
+        tv.setPadding(10, 10, 10, 30);
+        tv.setText(id);
+        mInstructions.addView(tv);
+    }
+
+    private void succeed() {
+        runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                mTestIndex++;
+                if (mTestIndex < mTests.length) {
+                    mTests[mTestIndex].run();
+                } else {
+                    mNextButton.setVisibility(View.GONE);
+                    findViewById(R.id.pass_button).setVisibility(View.VISIBLE);
+                }
+            }
+        });
+    }
+
+    private void error(int errorId) {
+        error(errorId, new Throwable());
+    }
+
+    private void error(final int errorId, final Throwable cause) {
+        runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                String error = getString(errorId);
+                Log.d(TAG, error, cause);
+                // No more instructions needed.
+                findViewById(R.id.instructions_group).setVisibility(View.GONE);
+
+                ((TextView) findViewById(R.id.error_text)).setText(error);
+            }
+        });
+    }
+
+    // Verify we don't start in screen pinning.
+    private final Test mCheckStartedUnpinned = new Test(0) {
+        public void run() {
+            if (mActivityManager.isInLockTaskMode()) {
+                error(R.string.error_screen_already_pinned);
+            } else {
+                succeed();
+            }
+        }
+    };
+
+    // Start screen pinning by having the user click next then confirm it for us.
+    private final Test mCheckStartPinning = new Test(R.string.screen_pin_instructions) {
+        protected void onNextClick() {
+            startLockTask();
+            succeed();
+        }
+    };
+
+    // Click next and check that we got pinned.
+    // Wait for the user to click next to verify that they got back from the prompt
+    // successfully.
+    private final Test mCheckIsPinned = new Test(R.string.screen_pin_check_pinned) {
+        protected void onNextClick() {
+            if (mActivityManager.isInLockTaskMode()) {
+                succeed();
+            } else {
+                error(R.string.error_screen_pinning_did_not_start);
+            }
+        }
+    };
+
+    // Tell user to try to leave.
+    private final Test mCheckTryLeave = new Test(R.string.screen_pin_no_exit) {
+        protected void onNextClick() {
+            if (mActivityManager.isInLockTaskMode()) {
+                succeed();
+            } else {
+                error(R.string.error_screen_no_longer_pinned);
+            }
+        }
+    };
+
+    // Verify that the user unpinned and it worked.
+    private final Test mCheckUnpin = new Test(R.string.screen_pin_exit) {
+        protected void onNextClick() {
+            if (!mActivityManager.isInLockTaskMode()) {
+                succeed();
+            } else {
+                error(R.string.error_screen_pinning_did_not_exit);
+            }
+        }
+    };
+
+    // Unpin from code and check that it worked.
+    private final Test mCheckUnpinFromCode = new Test(0) {
+        protected void run() {
+            if (!mActivityManager.isInLockTaskMode()) {
+                error(R.string.error_screen_pinning_did_not_start);
+                return;
+            }
+            stopLockTask();
+            if (!mActivityManager.isInLockTaskMode()) {
+                succeed();
+            } else {
+                error(R.string.error_screen_pinning_couldnt_exit);
+            }
+        };
+    };
+
+    private final Test mDone = new Test(R.string.screen_pinning_done) {
+        protected void run() {
+            showText();
+            succeed();
+        };
+    };
+
+    private abstract class Test {
+        private final int mResId;
+
+        public Test(int showId) {
+            mResId = showId;
+        }
+
+        protected void run() {
+            showText();
+        }
+
+        public void showText() {
+            if (mResId == 0) {
+                return;
+            }
+            show(mResId);
+        }
+
+        protected void onNextClick() {
+        }
+    }
+
+}