From 545a779f0df2825067679bee09bc966ca12b5974 Mon Sep 17 00:00:00 2001
From: Yorke Lee <yorkelee@google.com>
Date: Tue, 29 Sep 2015 15:02:34 -0700
Subject: First pass for Dialer onboarding flow

* Add OnboardingActivity that controls the onboarding the UI
ensuring that the user grants the necessary permissions before
the Dialer can start.
* Add first pass (no graphics, eyeballed measurements) for the
screens that request for default dialer as well as permissions
* OnboardingActivity is not actually launched at this moment - will
be tied in to the various Dialer activities in a follow up CL.
* Add tests for logic that controls the display of the screens in
anticipation of future additions to the onboarding flow.
* Add mockito library to DialerTests's Android.mk

Bug: 24270592

Change-Id: I00d0f75edaecaa85042b136b0d830b5fbb3a0a73
---
 AndroidManifest.xml                                |   6 +
 res/layout/onboarding_activity.xml                 |  21 ++
 res/layout/onboarding_screen_fragment.xml          |  66 ++++++
 res/values/colors.xml                              |   5 +
 res/values/strings.xml                             |  18 ++
 res/values/styles.xml                              |   7 +
 .../android/dialer/onboard/OnboardingActivity.java | 245 +++++++++++++++++++++
 .../dialer/onboard/OnboardingController.java       |  85 +++++++
 .../android/dialer/onboard/OnboardingFragment.java |  93 ++++++++
 .../android/dialer/onboard/PermissionsChecker.java |  27 +++
 tests/Android.mk                                   |   3 +
 .../onboard/DefaultDialerOnboardScreenTest.java    |  57 +++++
 .../dialer/onboard/OnboardingControllerTest.java   | 176 +++++++++++++++
 .../onboard/PermissionsOnboardScreenTest.java      |  65 ++++++
 14 files changed, 874 insertions(+)
 create mode 100644 res/layout/onboarding_activity.xml
 create mode 100644 res/layout/onboarding_screen_fragment.xml
 create mode 100644 src/com/android/dialer/onboard/OnboardingActivity.java
 create mode 100644 src/com/android/dialer/onboard/OnboardingController.java
 create mode 100644 src/com/android/dialer/onboard/OnboardingFragment.java
 create mode 100644 src/com/android/dialer/onboard/PermissionsChecker.java
 create mode 100644 tests/src/com/android/dialer/onboard/DefaultDialerOnboardScreenTest.java
 create mode 100644 tests/src/com/android/dialer/onboard/OnboardingControllerTest.java
 create mode 100644 tests/src/com/android/dialer/onboard/PermissionsOnboardScreenTest.java

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index e58d2ce9c..94333eb1e 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -244,6 +244,12 @@
         <activity android:name="com.android.contacts.common.vcard.ExportVCardActivity"
                   android:theme="@style/BackgroundOnlyTheme"/>
 
+        <activity
+            android:name="com.android.dialer.onboard.OnboardingActivity"
+            android:theme="@style/OnboardingFlowTheme"
+            android:screenOrientation="nosensor"
+            android:exported="false" />
+
         <service
             android:name="com.android.contacts.common.vcard.VCardService"
             android:exported="false"/>
diff --git a/res/layout/onboarding_activity.xml b/res/layout/onboarding_activity.xml
new file mode 100644
index 000000000..a893ce4e7
--- /dev/null
+++ b/res/layout/onboarding_activity.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:id="@+id/onboarding_fragment_container">
+</FrameLayout>
diff --git a/res/layout/onboarding_screen_fragment.xml b/res/layout/onboarding_screen_fragment.xml
new file mode 100644
index 000000000..f4136aed7
--- /dev/null
+++ b/res/layout/onboarding_screen_fragment.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:padding="20dp" >
+
+    <TextView
+        android:id="@+id/onboarding_screen_title"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_above="@+id/onboarding_screen_content"
+        android:textAppearance="?android:attr/textAppearanceLarge"
+        android:textColor="@color/onboarding_primary_text_color" />
+
+    <TextView
+        android:id="@id/onboarding_screen_content"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_above="@+id/onboarding_buttons_container"
+        android:layout_marginTop="20dp"
+        android:textColor="@color/onboarding_primary_text_color" />
+
+    <LinearLayout
+        android:id="@id/onboarding_buttons_container"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:layout_marginTop="20dp" >
+
+        <Button
+            android:id="@+id/onboard_skip_button"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="@string/onboarding_skip_button"
+            android:textColor="@color/onboarding_primary_text_color"
+            style="?android:attr/borderlessButtonStyle" />
+
+        <Button
+            android:id="@+id/onboard_next_button"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="@string/onboarding_next_button"
+            android:textColor="@color/onboarding_primary_text_color"
+            style="?android:attr/borderlessButtonStyle" />
+
+    </LinearLayout>
+</RelativeLayout>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index a747927d1..ad493e147 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -111,4 +111,9 @@
     <color name="delete_icon_tint">#6D6D6D</color>
     <color name="blocked_number_background">#E0E0E0</color>
     <color name="blocked_number_accent_color">#42A5F5</color>
+
+    <!-- Colors for onboarding flow -->
+    <color name="onboarding_primary_text_color">#ffffff</color>
+    <color name="onboarding_default_dialer_screen_background_color">#e06055</color>
+    <color name="onboarding_permissions_screen_background_color">#689f38</color>
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index c8b238f03..b8c4e97a2 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -884,4 +884,22 @@
 
     <!-- Shown as a message that notifies the user that the Phone app cannot write to system settings, which is why the system settings app is being launched directly instead.-->
     <string name="toast_cannot_write_system_settings">Phone app does not have permission to write to system settings.</string>
+
+    <!-- Title of the onboarding screen that asks the user to make Phone the default Phone app -->
+    <string name="request_default_dialer_screen_title">A better way of calling is calling</string>
+
+    <!-- Content of the onboarding screen that asks the user to make Phone the default Phone app -->
+    <string name="request_default_dialer_screen_content">Make Phone your default phone app to be able to do things like see who\'s calling you, even when they\'re not in your contacts.</string>
+
+    <!-- Title of the onboarding screen that asks the user to grant us the Contacts and Phone permissions -->
+    <string name="request_permissions_screen_title">Get talking to your friends and family</string>
+
+    <!-- Content of the onboarding screen that asks the user to grant us the Contacts and Phone permissions -->
+    <string name="request_permissions_screen_content">Phone will need to access your phone and contacts to make calls to people in your contacts.</string>
+
+    <!-- The label of the button used to skip a screen in the onboarding flow -->
+    <string name="onboarding_skip_button">Skip</string>
+
+    <!-- The label of the button used to go to the next screen in the onboarding flow -->
+    <string name="onboarding_next_button">Next</string>
 </resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 17b4a2561..86c3ad47d 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -109,6 +109,13 @@
         <item name="actionOverflowButtonStyle">@style/DialtactsActionBarOverflowWhite</item>
     </style>
 
+    <style name="OnboardingFlowTheme" parent="DialtactsThemeWithoutActionBarOverlay">
+        <item name="android:windowActionBar">false</item>
+        <item name="windowActionBar">false</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="windowNoTitle">true</item>
+    </style>
+
     <!-- Hide the actionbar title during the activity preview -->
     <style name="DialtactsActivityTheme" parent="DialtactsTheme">
         <!-- Styles that require AppCompat compatibility, remember to update both sets -->
diff --git a/src/com/android/dialer/onboard/OnboardingActivity.java b/src/com/android/dialer/onboard/OnboardingActivity.java
new file mode 100644
index 000000000..75378e99d
--- /dev/null
+++ b/src/com/android/dialer/onboard/OnboardingActivity.java
@@ -0,0 +1,245 @@
+/*
+ * 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.dialer.onboard;
+
+import static android.Manifest.permission.CALL_PHONE;
+import static android.Manifest.permission.READ_CONTACTS;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.app.FragmentTransaction;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.telecom.TelecomManager;
+
+import com.android.contacts.common.util.PermissionsUtil;
+import com.android.dialer.TransactionSafeActivity;
+import com.android.dialer.onboard.OnboardingController.OnboardingScreen;
+import com.android.dialer.onboard.OnboardingController.OnboardingUi;
+import com.android.dialer.util.TelecomUtil;
+import com.android.dialer.R;
+
+/**
+ * Activity hosting the onboarding UX flow that appears when you launch Dialer and you don't have
+ * the necessary permissions to run the app.
+ */
+public class OnboardingActivity extends TransactionSafeActivity implements OnboardingUi,
+        PermissionsChecker, OnboardingFragment.HostInterface {
+    public static final String KEY_ALREADY_REQUESTED_DEFAULT_DIALER =
+            "key_already_requested_default_dialer";
+
+    public static final int SCREEN_DEFAULT_DIALER = 0;
+    public static final int SCREEN_PERMISSIONS = 1;
+    public static final int SCREEN_COUNT = 2;
+
+    private OnboardingController mOnboardingController;
+
+    private DefaultDialerOnboardingScreen mDefaultDialerOnboardingScreen;
+    private PermissionsOnboardingScreen mPermissionsOnboardingScreen;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.onboarding_activity);
+        mOnboardingController = new OnboardingController(this);
+        mDefaultDialerOnboardingScreen = new DefaultDialerOnboardingScreen(this);
+        mPermissionsOnboardingScreen = new PermissionsOnboardingScreen(this);
+        mOnboardingController.addScreen(mDefaultDialerOnboardingScreen);
+        mOnboardingController.addScreen(mPermissionsOnboardingScreen);
+
+        mOnboardingController.showNextScreen();
+    }
+
+    @Override
+    public void showScreen(int screenId) {
+        if (!isSafeToCommitTransactions()) {
+            return;
+        }
+        final Fragment fragment;
+        switch (screenId) {
+            case SCREEN_DEFAULT_DIALER:
+                fragment = mDefaultDialerOnboardingScreen.getFragment();
+                break;
+            case SCREEN_PERMISSIONS:
+                fragment = mPermissionsOnboardingScreen.getFragment();
+                break;
+            default:
+                return;
+        }
+
+        final FragmentTransaction ft = getFragmentManager().beginTransaction();
+        ft.setCustomAnimations(android.R.animator.fade_in, android.R.animator.fade_out);
+        ft.replace(R.id.onboarding_fragment_container, fragment);
+        ft.commit();
+    }
+
+    @Override
+    public void completeOnboardingFlow() {
+        final Editor editor = PreferenceManager.getDefaultSharedPreferences(this).edit();
+        editor.putBoolean(KEY_ALREADY_REQUESTED_DEFAULT_DIALER, true).apply();
+        finish();
+    }
+
+    @Override
+    public boolean hasPhonePermissions() {
+        return PermissionsUtil.hasPhonePermissions(this);
+    }
+
+    @Override
+    public boolean hasContactsPermissions() {
+        return PermissionsUtil.hasContactsPermissions(this);
+    }
+
+    @Override
+    public boolean isDefaultOrSystemDialer() {
+        return TelecomUtil.hasModifyPhoneStatePermission(this);
+    }
+
+    @Override
+    public boolean previouslyRequestedDefaultDialer() {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
+        return preferences.getBoolean(KEY_ALREADY_REQUESTED_DEFAULT_DIALER, false);
+    }
+
+    /**
+     * Triggers the screen-specific logic that should occur when the next button is clicked.
+     */
+    @Override
+    public void onNextClicked(int screenId) {
+        switch (screenId) {
+            case SCREEN_DEFAULT_DIALER:
+                mDefaultDialerOnboardingScreen.onNextClicked(this);
+                break;
+            case SCREEN_PERMISSIONS:
+                mPermissionsOnboardingScreen.onNextClicked(this);
+                break;
+            default:
+                return;
+        }
+    }
+
+    @Override
+    public void onSkipClicked(int screenId) {
+        mOnboardingController.onScreenResult(screenId, false);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == SCREEN_DEFAULT_DIALER
+                && resultCode == RESULT_OK) {
+            mOnboardingController.onScreenResult(SCREEN_DEFAULT_DIALER, true);
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions,
+            int[] grantResults) {
+        boolean allPermissionsGranted = true;
+        if (requestCode == SCREEN_PERMISSIONS) {
+            if (permissions.length == 0 && grantResults.length == 0) {
+                // Cancellation of permissions dialog
+                allPermissionsGranted = false;
+            } else {
+                for (int result : grantResults) {
+                    if (result == PackageManager.PERMISSION_DENIED) {
+                        allPermissionsGranted = false;
+                    }
+                }
+            }
+
+            if (allPermissionsGranted) {
+                mOnboardingController.onScreenResult(SCREEN_PERMISSIONS, true);
+            }
+        }
+    }
+
+    public static class DefaultDialerOnboardingScreen extends OnboardingScreen {
+        private PermissionsChecker mPermissionsChecker;
+
+        public DefaultDialerOnboardingScreen(PermissionsChecker permissionsChecker) {
+            mPermissionsChecker = permissionsChecker;
+        }
+
+        @Override
+        public boolean shouldShowScreen() {
+            return !mPermissionsChecker.previouslyRequestedDefaultDialer()
+                    && !mPermissionsChecker.isDefaultOrSystemDialer();
+        }
+
+        @Override
+        public boolean canSkipScreen() {
+            return true;
+        }
+
+        public Fragment getFragment() {
+            return new OnboardingFragment(
+                    SCREEN_DEFAULT_DIALER,
+                    canSkipScreen(),
+                    R.color.onboarding_default_dialer_screen_background_color,
+                    R.string.request_default_dialer_screen_title,
+                    R.string.request_default_dialer_screen_content
+            );
+        }
+
+        @Override
+        public void onNextClicked(Activity activity) {
+            final Intent intent = new Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER);
+            intent.putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME,
+                    activity.getPackageName());
+            activity.startActivityForResult(intent, SCREEN_DEFAULT_DIALER);
+        }
+    }
+
+    public static class PermissionsOnboardingScreen extends OnboardingScreen {
+        private PermissionsChecker mPermissionsChecker;
+
+        public PermissionsOnboardingScreen(PermissionsChecker permissionsChecker) {
+            mPermissionsChecker = permissionsChecker;
+        }
+
+        @Override
+        public boolean shouldShowScreen() {
+            return !(mPermissionsChecker.hasPhonePermissions()
+                    && mPermissionsChecker.hasContactsPermissions());
+        }
+
+        @Override
+        public boolean canSkipScreen() {
+            return false;
+        }
+
+        public Fragment getFragment() {
+            return new OnboardingFragment(
+                    SCREEN_PERMISSIONS,
+                    canSkipScreen(),
+                    R.color.onboarding_permissions_screen_background_color,
+                    R.string.request_permissions_screen_title,
+                    R.string.request_permissions_screen_content
+            );
+        }
+
+        @Override
+        public void onNextClicked(Activity activity) {
+            activity.requestPermissions(new String[] {CALL_PHONE, READ_CONTACTS},
+                    SCREEN_PERMISSIONS);
+        }
+    }
+}
diff --git a/src/com/android/dialer/onboard/OnboardingController.java b/src/com/android/dialer/onboard/OnboardingController.java
new file mode 100644
index 000000000..f799479ed
--- /dev/null
+++ b/src/com/android/dialer/onboard/OnboardingController.java
@@ -0,0 +1,85 @@
+/*
+ * 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.dialer.onboard;
+
+import android.app.Activity;
+
+import java.util.ArrayList;
+
+/**
+ * Class that manages the display of various fragments that show the user prompts asking for
+ * certain privileged positions.
+ */
+public class OnboardingController {
+    public static abstract class OnboardingScreen {
+        public abstract boolean shouldShowScreen();
+        public abstract boolean canSkipScreen();
+        public abstract void onNextClicked(Activity activity);
+    }
+
+    public interface OnboardingUi {
+        public void showScreen(int screenId);
+        /**
+         * Called when all the necessary permissions have been granted and the main activity
+         * can launch.
+         */
+        public void completeOnboardingFlow();
+    }
+
+    private int mCurrentScreen = -1;
+    private OnboardingUi mOnboardingUi;
+    private ArrayList<OnboardingScreen> mScreens = new ArrayList<> ();
+
+    public OnboardingController(OnboardingUi onBoardingUi) {
+        mOnboardingUi = onBoardingUi;
+    }
+
+    public void addScreen(OnboardingScreen screen) {
+        mScreens.add(screen);
+    }
+
+    public void showNextScreen() {
+        mCurrentScreen++;
+
+        if (mCurrentScreen >= mScreens.size()) {
+            // Reached the end of onboarding flow
+            mOnboardingUi.completeOnboardingFlow();
+            return;
+        }
+
+        if (mScreens.get(mCurrentScreen).shouldShowScreen()) {
+            mOnboardingUi.showScreen(mCurrentScreen);
+        } else {
+            showNextScreen();
+        }
+    }
+
+    public void onScreenResult(int screenId, boolean success) {
+        if (screenId >= mScreens.size()) {
+            return;
+        }
+
+        // Show the next screen in the onboarding flow only under the following situations:
+        // 1) Success was indicated, and the
+        // 2) The user tried to skip the screen, and the screen can be skipped
+        if (success && !mScreens.get(mCurrentScreen).shouldShowScreen()) {
+            showNextScreen();
+        } else if (mScreens.get(mCurrentScreen).canSkipScreen()) {
+            showNextScreen();
+        }
+    }
+}
diff --git a/src/com/android/dialer/onboard/OnboardingFragment.java b/src/com/android/dialer/onboard/OnboardingFragment.java
new file mode 100644
index 000000000..77b265b2c
--- /dev/null
+++ b/src/com/android/dialer/onboard/OnboardingFragment.java
@@ -0,0 +1,93 @@
+/*
+ * 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.dialer.onboard;
+
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import com.android.dialer.R;
+
+public class OnboardingFragment extends Fragment implements OnClickListener {
+    public static final String ARG_SCREEN_ID = "arg_screen_id";
+    public static final String ARG_CAN_SKIP_SCREEN = "arg_can_skip_screen";
+    public static final String ARG_BACKGROUND_COLOR_RESOURCE = "arg_background_color";
+    public static final String ARG_TEXT_TITLE_RESOURCE = "arg_text_title_resource";
+    public static final String ARG_TEXT_CONTENT_RESOURCE = "arg_text_content_resource";
+
+    private int mScreenId;
+
+    public interface HostInterface {
+        public void onNextClicked(int screenId);
+        public void onSkipClicked(int screenId);
+    }
+
+    public OnboardingFragment() {}
+
+    public OnboardingFragment(int screenId, boolean canSkipScreen, int backgroundColorResourceId,
+            int textTitleResourceId, int textContentResourceId) {
+        final Bundle args = new Bundle();
+        args.putInt(ARG_SCREEN_ID, screenId);
+        args.putBoolean(ARG_CAN_SKIP_SCREEN, canSkipScreen);
+        args.putInt(ARG_BACKGROUND_COLOR_RESOURCE, backgroundColorResourceId);
+        args.putInt(ARG_TEXT_TITLE_RESOURCE, textTitleResourceId);
+        args.putInt(ARG_TEXT_CONTENT_RESOURCE, textContentResourceId);
+        setArguments(args);
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mScreenId = getArguments().getInt(ARG_SCREEN_ID);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        final View view = inflater.inflate(R.layout.onboarding_screen_fragment, container, false);
+        view.setBackgroundColor(getResources().getColor(
+                getArguments().getInt(ARG_BACKGROUND_COLOR_RESOURCE), null));
+        ((TextView) view.findViewById(R.id.onboarding_screen_content)).
+                setText(getArguments().getInt(ARG_TEXT_CONTENT_RESOURCE));
+        ((TextView) view.findViewById(R.id.onboarding_screen_title)).
+        setText(getArguments().getInt(ARG_TEXT_TITLE_RESOURCE));
+        if (!getArguments().getBoolean(ARG_CAN_SKIP_SCREEN)) {
+            view.findViewById(R.id.onboard_skip_button).setVisibility(View.INVISIBLE);
+        }
+
+        view.findViewById(R.id.onboard_skip_button).setOnClickListener(this);
+        view.findViewById(R.id.onboard_next_button).setOnClickListener(this);
+
+        return view;
+    }
+
+    int getScreenId() {
+        return mScreenId;
+    }
+
+    @Override
+    public void onClick(View v) {
+        if (v.getId() == R.id.onboard_skip_button) {
+            ((HostInterface) getActivity()).onSkipClicked(getScreenId());
+        } else if (v.getId() == R.id.onboard_next_button) {
+            ((HostInterface) getActivity()).onNextClicked(getScreenId());
+        }
+    }
+}
diff --git a/src/com/android/dialer/onboard/PermissionsChecker.java b/src/com/android/dialer/onboard/PermissionsChecker.java
new file mode 100644
index 000000000..78d175e6f
--- /dev/null
+++ b/src/com/android/dialer/onboard/PermissionsChecker.java
@@ -0,0 +1,27 @@
+/*
+ * 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.dialer.onboard;
+
+/**
+ * Defines a mockable interface used to verify whether certain permissions/privileged operations
+ * are possible.
+ */
+public interface PermissionsChecker {
+    public boolean hasPhonePermissions();
+    public boolean hasContactsPermissions();
+    public boolean isDefaultOrSystemDialer();
+    public boolean previouslyRequestedDefaultDialer();
+}
diff --git a/tests/Android.mk b/tests/Android.mk
index 21beca8fd..07f4f00d9 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -16,6 +16,9 @@ src_dirs := src \
 # Include all test java files.
 LOCAL_SRC_FILES := $(call all-java-files-under, $(src_dirs))
 
+LOCAL_STATIC_JAVA_LIBRARIES += \
+        mockito-target
+
 LOCAL_PACKAGE_NAME := DialerTests
 
 LOCAL_INSTRUMENTATION_FOR := Dialer
diff --git a/tests/src/com/android/dialer/onboard/DefaultDialerOnboardScreenTest.java b/tests/src/com/android/dialer/onboard/DefaultDialerOnboardScreenTest.java
new file mode 100644
index 000000000..f9724c14b
--- /dev/null
+++ b/tests/src/com/android/dialer/onboard/DefaultDialerOnboardScreenTest.java
@@ -0,0 +1,57 @@
+/*
+ * 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.dialer.onboard;
+
+import static org.mockito.Mockito.when;
+
+import android.test.AndroidTestCase;
+
+import com.android.dialer.onboard.OnboardingActivity.DefaultDialerOnboardingScreen;
+
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class DefaultDialerOnboardScreenTest extends AndroidTestCase {
+    private DefaultDialerOnboardingScreen mScreen;
+    @Mock private PermissionsChecker mPermissionsChecker;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        mScreen = new DefaultDialerOnboardingScreen(mPermissionsChecker);
+    }
+
+    public void testNeverRequestedForDefaultDialer_shouldShowScreen() {
+        when(mPermissionsChecker.previouslyRequestedDefaultDialer()).thenReturn(false);
+        assertTrue(mScreen.shouldShowScreen());
+    }
+
+    public void testAlreadyAskedForDefaultDialer_shouldNotShowScreen() {
+        when(mPermissionsChecker.previouslyRequestedDefaultDialer()).thenReturn(true);
+        assertFalse(mScreen.shouldShowScreen());
+    }
+
+    public void testAlreadySetAsDefaultDialer_shouldNotShowScreen() {
+        when(mPermissionsChecker.previouslyRequestedDefaultDialer()).thenReturn(false);
+        when(mPermissionsChecker.isDefaultOrSystemDialer()).thenReturn(true);
+        assertFalse(mScreen.shouldShowScreen());
+    }
+
+    public void testCanSkipScreen() {
+        assertTrue(mScreen.canSkipScreen());
+    }
+}
diff --git a/tests/src/com/android/dialer/onboard/OnboardingControllerTest.java b/tests/src/com/android/dialer/onboard/OnboardingControllerTest.java
new file mode 100644
index 000000000..d9c8ce5c0
--- /dev/null
+++ b/tests/src/com/android/dialer/onboard/OnboardingControllerTest.java
@@ -0,0 +1,176 @@
+/*
+ * 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.dialer.onboard;
+
+import android.app.Activity;
+import android.test.AndroidTestCase;
+
+public class OnboardingControllerTest extends AndroidTestCase {
+    private MockOnboardUi mOnboardUi;
+    private OnboardingController mController;
+
+    public class MockOnboardUi implements OnboardingController.OnboardingUi {
+        public int currentScreen = -1;
+        public boolean completedOnboardingFlow = false;
+
+        @Override
+        public void showScreen(int screenId) {
+            currentScreen = screenId;
+        }
+
+        @Override
+        public void completeOnboardingFlow() {
+            completedOnboardingFlow = true;
+        }
+    }
+
+    public class MockScreen extends OnboardingController.OnboardingScreen {
+        boolean shouldShowScreen;
+        boolean canSkipScreen;
+
+        public MockScreen(boolean shouldShowScreen, boolean canSkipScreen) {
+            this.shouldShowScreen = shouldShowScreen;
+            this.canSkipScreen = canSkipScreen;
+        }
+
+        @Override
+        public boolean shouldShowScreen() {
+            return shouldShowScreen;
+        }
+
+        @Override
+        public boolean canSkipScreen() {
+            return canSkipScreen;
+        }
+
+        @Override
+        public void onNextClicked(Activity activity) {
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mOnboardUi = new MockOnboardUi();
+        mController = new OnboardingController(mOnboardUi);
+    }
+
+    public void testNoScreensToDisplay_OnboardingFlowImmediatelyCompleted() {
+        mController.showNextScreen();
+        assertEquals(-1, mOnboardUi.currentScreen);
+        assertTrue(mOnboardUi.completedOnboardingFlow);
+    }
+
+    public void testSkipAllScreens_OnboardingFlowImmediatelyCompleted() {
+        mController.addScreen(new MockScreen(false /* shouldShowScreen */,
+                true /* canSkipScreen */));
+        mController.addScreen(new MockScreen(false /* shouldShowScreen */,
+                true /* canSkipScreen */));
+        mController.addScreen(new MockScreen(false /* shouldShowScreen */,
+                true /* canSkipScreen */));
+        mController.showNextScreen();
+        assertEquals(-1, mOnboardUi.currentScreen);
+        assertTrue(mOnboardUi.completedOnboardingFlow);
+    }
+
+    public void testFirstScreenNotNeeded_ShowsSecondScreen() {
+        mController.addScreen(new MockScreen(false /* shouldShowScreen */,
+                false /* canSkipScreen */));
+        mController.addScreen(new MockScreen(true /* shouldShowScreen */,
+                false /* canSkipScreen */));
+        mController.showNextScreen();
+        assertEquals(1, mOnboardUi.currentScreen);
+    }
+
+    public void testScreenRequired() {
+        final MockScreen mockScreen =
+                new MockScreen(true /* shouldShowScreen */, false /* canSkipScreen */);
+        mController.addScreen(mockScreen);
+
+        mController.showNextScreen();
+        assertEquals(0, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+
+        // User tried to skip an unskippable screen
+        mController.onScreenResult(0, false);
+        assertEquals(0, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+
+        // User said yes, but the underlying requirements have not been fulfilled yet, so don't
+        // show the next screen. Should be very rare in practice.
+        mController.onScreenResult(0, true);
+        assertEquals(0, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+
+        // Requirement has been fulfiled.
+        mockScreen.shouldShowScreen = false;
+        mController.onScreenResult(0, true);
+        assertTrue(mOnboardUi.completedOnboardingFlow);
+    }
+
+    /**
+     * Verifies the use case where completing the first screen will provide the necessary conditions
+     * to skip the second screen as well.
+     *
+     * For example, setting the default dialer in the first screen will automatically grant
+     * permissions such that the second permissions screen is no longer needed.
+     */
+    public void testFirstScreenCompleted_SkipsSecondScreen() {
+        final MockScreen mockScreen1 =
+                new MockScreen(true /* shouldShowScreen */, true /* canSkipScreen */);
+        final MockScreen mockScreen2 =
+                new MockScreen(true /* shouldShowScreen */, false /* canSkipScreen */);
+        mController.addScreen(mockScreen1);
+        mController.addScreen(mockScreen2);
+
+        mController.showNextScreen();
+        assertEquals(0, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+
+        // Screen 1 succeeded, screen 2 is no longer necessary
+        mockScreen2.shouldShowScreen = false;
+        mController.onScreenResult(0, true);
+        assertEquals(0, mOnboardUi.currentScreen);
+        assertTrue(mOnboardUi.completedOnboardingFlow);
+    }
+
+    /**
+     * Verifies the use case where skipping the first screen will proceed to show the second screen
+     * since the necessary conditions to skip the second screen have not been met.
+     */
+    public void testFirstScreenSkipped_ShowsSecondScreen() {
+        final MockScreen mockScreen1 =
+                new MockScreen(true /* shouldShowScreen */, true /* canSkipScreen */);
+        final MockScreen mockScreen2 =
+                new MockScreen(true /* shouldShowScreen */, false /* canSkipScreen */);
+        mController.addScreen(mockScreen1);
+        mController.addScreen(mockScreen2);
+
+        mController.showNextScreen();
+        assertEquals(0, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+
+        // Screen 1 skipped
+        mController.onScreenResult(0, false);
+        assertEquals(1, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+
+        // Repeatedly trying to skip screen 2 will not work since it is marked as unskippable.
+        mController.onScreenResult(1, false);
+        assertEquals(1, mOnboardUi.currentScreen);
+        assertFalse(mOnboardUi.completedOnboardingFlow);
+    }
+}
diff --git a/tests/src/com/android/dialer/onboard/PermissionsOnboardScreenTest.java b/tests/src/com/android/dialer/onboard/PermissionsOnboardScreenTest.java
new file mode 100644
index 000000000..ff5e3d5ae
--- /dev/null
+++ b/tests/src/com/android/dialer/onboard/PermissionsOnboardScreenTest.java
@@ -0,0 +1,65 @@
+/*
+ * 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.dialer.onboard;
+
+import static org.mockito.Mockito.when;
+
+import android.test.AndroidTestCase;
+
+import com.android.dialer.onboard.OnboardingActivity.PermissionsOnboardingScreen;
+
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class PermissionsOnboardScreenTest extends AndroidTestCase {
+    private PermissionsOnboardingScreen mScreen;
+    @Mock private PermissionsChecker mPermissionsChecker;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        mScreen = new PermissionsOnboardingScreen(mPermissionsChecker);
+    }
+
+    public void testMissingContactsAndPhonePermissions_shouldShowScreen() {
+        when(mPermissionsChecker.hasContactsPermissions()).thenReturn(false);
+        when(mPermissionsChecker.hasPhonePermissions()).thenReturn(false);
+        assertTrue(mScreen.shouldShowScreen());
+    }
+
+    public void testMissingContactsPermission_shouldShowScreen() {
+        when(mPermissionsChecker.hasContactsPermissions()).thenReturn(false);
+        when(mPermissionsChecker.hasPhonePermissions()).thenReturn(true);
+        assertTrue(mScreen.shouldShowScreen());
+    }
+
+    public void testMissingPhonePermission_shouldShowScreen() {
+        when(mPermissionsChecker.hasContactsPermissions()).thenReturn(true);
+        when(mPermissionsChecker.hasPhonePermissions()).thenReturn(false);
+        assertTrue(mScreen.shouldShowScreen());
+    }
+
+    public void testHasAllPermissions_shouldNotShowScreen() {
+        when(mPermissionsChecker.hasContactsPermissions()).thenReturn(true);
+        when(mPermissionsChecker.hasPhonePermissions()).thenReturn(true);
+        assertFalse(mScreen.shouldShowScreen());
+    }
+
+    public void testCanSkipScreen() {
+        assertFalse(mScreen.canSkipScreen());
+    }
+}
-- 
cgit v1.2.3