1 /* 2 * Copyright 2016, The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.managedprovisioning.provisioning; 18 19 import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.PROVISIONING_PROVISIONING_ACTIVITY_TIME_MS; 20 21 import android.app.Activity; 22 import android.app.DialogFragment; 23 import android.os.Bundle; 24 import android.support.annotation.VisibleForTesting; 25 import android.view.accessibility.AccessibilityEvent; 26 import android.widget.TextView; 27 28 import com.android.managedprovisioning.R; 29 import com.android.managedprovisioning.common.DialogBuilder; 30 import com.android.managedprovisioning.common.ProvisionLogger; 31 import com.android.managedprovisioning.common.SetupGlifLayoutActivity; 32 import com.android.managedprovisioning.common.SimpleDialog; 33 import com.android.managedprovisioning.common.Utils; 34 import com.android.managedprovisioning.model.CustomizationParams; 35 import com.android.managedprovisioning.model.ProvisioningParams; 36 37 /** 38 * Progress activity shown whilst provisioning is ongoing. 39 * 40 * <p>This activity registers for updates of the provisioning process from the 41 * {@link ProvisioningManager}. It shows progress updates as provisioning progresses and handles 42 * showing of cancel and error dialogs.</p> 43 */ 44 public class ProvisioningActivity extends SetupGlifLayoutActivity 45 implements SimpleDialog.SimpleDialogListener, ProvisioningManagerCallback { 46 47 private static final String KEY_PROVISIONING_STARTED = "ProvisioningStarted"; 48 49 private static final String ERROR_DIALOG_OK = "ErrorDialogOk"; 50 private static final String ERROR_DIALOG_RESET = "ErrorDialogReset"; 51 private static final String CANCEL_PROVISIONING_DIALOG_OK = "CancelProvisioningDialogOk"; 52 private static final String CANCEL_PROVISIONING_DIALOG_RESET = "CancelProvisioningDialogReset"; 53 54 private ProvisioningParams mParams; 55 private ProvisioningManager mProvisioningManager; 56 ProvisioningActivity()57 public ProvisioningActivity() { 58 this(null, new Utils()); 59 } 60 61 @VisibleForTesting ProvisioningActivity(ProvisioningManager provisioningManager, Utils utils)62 public ProvisioningActivity(ProvisioningManager provisioningManager, Utils utils) { 63 super(utils); 64 mProvisioningManager = provisioningManager; 65 } 66 67 // Lazily initialize ProvisioningManager, since we can't call in ProvisioningManager.getInstance 68 // in constructor as base context is not available in constructor getProvisioningManager()69 private ProvisioningManager getProvisioningManager() { 70 if (mProvisioningManager == null) { 71 mProvisioningManager = ProvisioningManager.getInstance(this); 72 } 73 return mProvisioningManager; 74 } 75 76 @Override onCreate(Bundle savedInstanceState)77 protected void onCreate(Bundle savedInstanceState) { 78 super.onCreate(savedInstanceState); 79 mParams = getIntent().getParcelableExtra(ProvisioningParams.EXTRA_PROVISIONING_PARAMS); 80 initializeUi(mParams); 81 82 if (savedInstanceState == null 83 || !savedInstanceState.getBoolean(KEY_PROVISIONING_STARTED)) { 84 getProvisioningManager().maybeStartProvisioning(mParams); 85 } 86 } 87 88 @Override onSaveInstanceState(Bundle outState)89 protected void onSaveInstanceState(Bundle outState) { 90 super.onSaveInstanceState(outState); 91 outState.putBoolean(KEY_PROVISIONING_STARTED, true); 92 } 93 94 @Override onResume()95 protected void onResume() { 96 super.onResume(); 97 if (!isAnyDialogAdded()) { 98 getProvisioningManager().registerListener(this); 99 } 100 } 101 isAnyDialogAdded()102 private boolean isAnyDialogAdded() { 103 return isDialogAdded(ERROR_DIALOG_OK) 104 || isDialogAdded(ERROR_DIALOG_RESET) 105 || isDialogAdded(CANCEL_PROVISIONING_DIALOG_OK) 106 || isDialogAdded(CANCEL_PROVISIONING_DIALOG_RESET); 107 } 108 109 @Override onPause()110 public void onPause() { 111 getProvisioningManager().unregisterListener(this); 112 super.onPause(); 113 } 114 115 @Override onBackPressed()116 public void onBackPressed() { 117 // if EXTRA_PROVISIONING_SKIP_USER_CONSENT is specified, don't allow user to cancel 118 if (mParams.skipUserConsent) { 119 return; 120 } 121 122 showCancelProvisioningDialog(); 123 } 124 125 @Override preFinalizationCompleted()126 public void preFinalizationCompleted() { 127 ProvisionLogger.logi("ProvisioningActivity pre-finalization completed"); 128 setResult(Activity.RESULT_OK); 129 finish(); 130 } 131 132 @Override progressUpdate(int progressMessage)133 public void progressUpdate(int progressMessage) { 134 } 135 136 @Override error(int titleId, int messageId, boolean resetRequired)137 public void error(int titleId, int messageId, boolean resetRequired) { 138 SimpleDialog.Builder dialogBuilder = new SimpleDialog.Builder() 139 .setTitle(titleId) 140 .setMessage(messageId) 141 .setCancelable(false) 142 .setPositiveButtonMessage(resetRequired 143 ? R.string.reset : R.string.device_owner_error_ok); 144 145 showDialog(dialogBuilder, resetRequired ? ERROR_DIALOG_RESET : ERROR_DIALOG_OK); 146 } 147 148 @Override showDialog(DialogBuilder builder, String tag)149 protected void showDialog(DialogBuilder builder, String tag) { 150 // Whenever a dialog is shown, stop listening for further updates 151 getProvisioningManager().unregisterListener(this); 152 super.showDialog(builder, tag); 153 } 154 155 @Override getMetricsCategory()156 protected int getMetricsCategory() { 157 return PROVISIONING_PROVISIONING_ACTIVITY_TIME_MS; 158 } 159 showCancelProvisioningDialog()160 private void showCancelProvisioningDialog() { 161 final boolean isDoProvisioning = getUtils().isDeviceOwnerAction(mParams.provisioningAction); 162 final String dialogTag = isDoProvisioning ? CANCEL_PROVISIONING_DIALOG_RESET 163 : CANCEL_PROVISIONING_DIALOG_OK; 164 final int positiveResId = isDoProvisioning ? R.string.reset 165 : R.string.profile_owner_cancel_ok; 166 final int negativeResId = isDoProvisioning ? R.string.device_owner_cancel_cancel 167 : R.string.profile_owner_cancel_cancel; 168 final int dialogMsgResId = isDoProvisioning 169 ? R.string.this_will_reset_take_back_first_screen 170 : R.string.profile_owner_cancel_message; 171 172 SimpleDialog.Builder dialogBuilder = new SimpleDialog.Builder() 173 .setCancelable(false) 174 .setMessage(dialogMsgResId) 175 .setNegativeButtonMessage(negativeResId) 176 .setPositiveButtonMessage(positiveResId); 177 if (isDoProvisioning) { 178 dialogBuilder.setTitle(R.string.stop_setup_reset_device_question); 179 } 180 181 showDialog(dialogBuilder, dialogTag); 182 } 183 onProvisioningAborted()184 private void onProvisioningAborted() { 185 setResult(Activity.RESULT_CANCELED); 186 finish(); 187 } 188 189 @Override onNegativeButtonClick(DialogFragment dialog)190 public void onNegativeButtonClick(DialogFragment dialog) { 191 switch (dialog.getTag()) { 192 case CANCEL_PROVISIONING_DIALOG_OK: 193 case CANCEL_PROVISIONING_DIALOG_RESET: 194 dialog.dismiss(); 195 break; 196 default: 197 SimpleDialog.throwButtonClickHandlerNotImplemented(dialog); 198 } 199 getProvisioningManager().registerListener(this); 200 } 201 202 @Override onPositiveButtonClick(DialogFragment dialog)203 public void onPositiveButtonClick(DialogFragment dialog) { 204 switch (dialog.getTag()) { 205 case CANCEL_PROVISIONING_DIALOG_OK: 206 getProvisioningManager().cancelProvisioning(); 207 onProvisioningAborted(); 208 break; 209 case CANCEL_PROVISIONING_DIALOG_RESET: 210 getUtils().sendFactoryResetBroadcast(this, "DO provisioning cancelled by user"); 211 onProvisioningAborted(); 212 break; 213 case ERROR_DIALOG_OK: 214 onProvisioningAborted(); 215 break; 216 case ERROR_DIALOG_RESET: 217 getUtils().sendFactoryResetBroadcast(this, "Error during DO provisioning"); 218 onProvisioningAborted(); 219 break; 220 default: 221 SimpleDialog.throwButtonClickHandlerNotImplemented(dialog); 222 } 223 } 224 initializeUi(ProvisioningParams params)225 private void initializeUi(ProvisioningParams params) { 226 final boolean isDoProvisioning = getUtils().isDeviceOwnerAction(params.provisioningAction); 227 final int headerResId = isDoProvisioning ? R.string.setup_work_device 228 : R.string.setting_up_workspace; 229 final int titleResId = isDoProvisioning ? R.string.setup_device_progress 230 : R.string.setup_profile_progress; 231 232 initializeLayoutParams(R.layout.progress, headerResId, true, 233 CustomizationParams.createInstance(mParams, this, mUtils).statusBarColor); 234 setTitle(titleResId); 235 } 236 }