src/com/android/managedprovisioning/finalization/FinalizationController.java - platform/packages/apps/ManagedProvisioning - Git at Google

 /*
  * Copyright 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 com.android.managedprovisioning.finalization;

 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE;
 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE;

 import static com.android.internal.util.Preconditions.checkNotNull;

 import android.annotation.IntDef;
 import android.app.Activity;
 import android.app.NotificationManager;
 import android.os.Bundle;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.managedprovisioning.analytics.DeferredMetricsReader;
 import com.android.managedprovisioning.common.NotificationHelper;
 import com.android.managedprovisioning.common.ProvisionLogger;
 import com.android.managedprovisioning.common.SettingsFacade;
 import com.android.managedprovisioning.common.Utils;
 import com.android.managedprovisioning.model.ProvisioningParams;
 import com.android.managedprovisioning.provisioning.Constants;

 import java.io.File;

 /**
  * Controller for the finalization of managed provisioning.  This class should be invoked after
  * {@link PreFinalizationController}.  Provisioning is finalized via calls to
  * {@link #provisioningFinalized()} and {@link #commitFinalizedState()}.  Different instances of
  * this class will be tailored to run these two methods at different points in the Setup Wizard user
  * flows, based on the type of FinalizationControllerLogic they are constructed with.
  */
 public final class FinalizationController {

     static final int PROVISIONING_FINALIZED_RESULT_NO_CHILD_ACTIVITY_LAUNCHED = 1;
     static final int PROVISIONING_FINALIZED_RESULT_CHILD_ACTIVITY_LAUNCHED = 2;
     static final int PROVISIONING_FINALIZED_RESULT_SKIPPED = 3;
     @IntDef({
             PROVISIONING_FINALIZED_RESULT_NO_CHILD_ACTIVITY_LAUNCHED,
             PROVISIONING_FINALIZED_RESULT_CHILD_ACTIVITY_LAUNCHED,
             PROVISIONING_FINALIZED_RESULT_SKIPPED})
     @interface ProvisioningFinalizedResult {}

     private static final int DPC_SETUP_REQUEST_CODE = 1;
     private static final int FINAL_SCREEN_REQUEST_CODE = 2;

     private final FinalizationControllerLogic mFinalizationControllerLogic;
     private final Activity mActivity;
     private final Utils mUtils;
     private final SettingsFacade mSettingsFacade;
     private final UserProvisioningStateHelper mUserProvisioningStateHelper;
     private final ProvisioningIntentProvider mProvisioningIntentProvider;
     private final NotificationHelper mNotificationHelper;
     private final DeferredMetricsReader mDeferredMetricsReader;
     private @ProvisioningFinalizedResult int mProvisioningFinalizedResult;
     private ProvisioningParamsUtils mProvisioningParamsUtils;

     public FinalizationController(Activity activity,
             FinalizationControllerLogic finalizationControllerLogic,
             UserProvisioningStateHelper userProvisioningStateHelper) {
         this(
                 activity,
                 finalizationControllerLogic,
                 new Utils(),
                 new SettingsFacade(),
                 userProvisioningStateHelper,
                 new NotificationHelper(activity),
                 new DeferredMetricsReader(
                         Constants.getDeferredMetricsFile(activity)),
                 new ProvisioningParamsUtils());
     }

     public FinalizationController(Activity activity,
             FinalizationControllerLogic finalizationControllerLogic) {
         this(
                 activity,
                 finalizationControllerLogic,
                 new Utils(),
                 new SettingsFacade(),
                 new UserProvisioningStateHelper(activity),
                 new NotificationHelper(activity),
                 new DeferredMetricsReader(
                         Constants.getDeferredMetricsFile(activity)),
                 new ProvisioningParamsUtils());
     }

     @VisibleForTesting
     FinalizationController(Activity activity,
             FinalizationControllerLogic finalizationControllerLogic,
             Utils utils,
             SettingsFacade settingsFacade,
             UserProvisioningStateHelper helper,
             NotificationHelper notificationHelper,
             DeferredMetricsReader deferredMetricsReader,
             ProvisioningParamsUtils provisioningParamsUtils) {
         mActivity = checkNotNull(activity);
         mFinalizationControllerLogic = checkNotNull(finalizationControllerLogic);
         mUtils = checkNotNull(utils);
         mSettingsFacade = checkNotNull(settingsFacade);
         mUserProvisioningStateHelper = checkNotNull(helper);
         mProvisioningIntentProvider = new ProvisioningIntentProvider();
         mNotificationHelper = checkNotNull(notificationHelper);
         mDeferredMetricsReader = checkNotNull(deferredMetricsReader);
         mProvisioningParamsUtils = provisioningParamsUtils;
     }

     @VisibleForTesting
     final PrimaryProfileFinalizationHelper getPrimaryProfileFinalizationHelper(
             ProvisioningParams params) {
         return new PrimaryProfileFinalizationHelper(params.accountToMigrate,
                 params.keepAccountMigrated, mUtils.getManagedProfile(mActivity),
                 params.inferDeviceAdminPackageName(), mUtils,
                 mUtils.isAdminIntegratedFlow(params));
     }

     /**
      * This method is invoked when provisioning is finalized.
      *
      * <p>This method has to be invoked after
      * {@link PreFinalizationController#deviceManagementEstablished(ProvisioningParams)}
      * was called. It is commonly invoked at the end of the setup flow, if provisioning occurs
      * during the setup flow. It loads the provisioning params from the storage, notifies the DPC
      * about the completed provisioning and sets the right user provisioning states.
      *
      * <p>To retrieve the resulting state of this method, use
      * {@link #getProvisioningFinalizedResult()}
      *
      * <p>This method may be called multiple times.  {@link #commitFinalizedState()} ()} must be
      * called after the final call to this method.  If this method is called again after that, it
      * will return immediately without taking any action.
      */
     final void provisioningFinalized() {
         mProvisioningFinalizedResult = PROVISIONING_FINALIZED_RESULT_SKIPPED;

         if (mUserProvisioningStateHelper.isStateUnmanagedOrFinalized()) {
             ProvisionLogger.logw("provisioningFinalized called, but state is finalized or "
                     + "unmanaged");
             return;
         }

         final ProvisioningParams params = loadProvisioningParams();
         if (params == null) {
             ProvisionLogger.logw("FinalizationController invoked, but no stored params");
             return;
         }

         if (!mFinalizationControllerLogic.isReadyForFinalization(params)) {
             return;
         }

         mProvisioningFinalizedResult = PROVISIONING_FINALIZED_RESULT_NO_CHILD_ACTIVITY_LAUNCHED;
         if (mUtils.isAdminIntegratedFlow(params)) {
             // Don't send ACTION_PROFILE_PROVISIONING_COMPLETE broadcast to DPC or launch DPC by
             // ACTION_PROVISIONING_SUCCESSFUL intent if it's admin integrated flow.
             if (mUtils.isDeviceOwnerAction(params.provisioningAction)) {
                 mProvisioningIntentProvider.launchFinalizationScreenForResult(mActivity, params,
                         FINAL_SCREEN_REQUEST_CODE);
                 mProvisioningFinalizedResult =
                         PROVISIONING_FINALIZED_RESULT_CHILD_ACTIVITY_LAUNCHED;
             }
         } else {
             if (params.provisioningAction.equals(ACTION_PROVISION_MANAGED_PROFILE)) {
                 mProvisioningFinalizedResult =
                         mFinalizationControllerLogic.notifyDpcManagedProfile(
                                 params, DPC_SETUP_REQUEST_CODE);
             } else {
                 mProvisioningFinalizedResult =
                         mFinalizationControllerLogic.notifyDpcManagedDeviceOrUser(
                                 params, DPC_SETUP_REQUEST_CODE);
             }
         }
     }

     /**
      * @throws IllegalStateException if {@link #provisioningFinalized()} was not called before.
      */
     final @ProvisioningFinalizedResult int getProvisioningFinalizedResult() {
         if (mProvisioningFinalizedResult == 0) {
             throw new IllegalStateException("provisioningFinalized() has not been called.");
         }
         return mProvisioningFinalizedResult;
     }

     @VisibleForTesting
     final void clearParamsFile() {
         final File file = mProvisioningParamsUtils.getProvisioningParamsFile(mActivity);
         if (file != null) {
             file.delete();
         }
     }

     private ProvisioningParams loadProvisioningParams() {
         final File file = mProvisioningParamsUtils.getProvisioningParamsFile(mActivity);
         final ProvisioningParams params = ProvisioningParams.load(file);
         return params;
     }

     /**
      * Update the system's provisioning state, and commit any other irreversible changes that
      * must wait until finalization is 100% completed.
      */
     private void commitFinalizedState(ProvisioningParams params) {
         if (ACTION_PROVISION_MANAGED_DEVICE.equals(params.provisioningAction)) {
             mNotificationHelper.showPrivacyReminderNotification(
                     mActivity, NotificationManager.IMPORTANCE_DEFAULT);
         } else if (ACTION_PROVISION_MANAGED_PROFILE.equals(params.provisioningAction)
                 && mFinalizationControllerLogic.shouldFinalizePrimaryProfile(params)) {
             getPrimaryProfileFinalizationHelper(params)
                     .finalizeProvisioningInPrimaryProfile(mActivity, null);
         }

         mUserProvisioningStateHelper.markUserProvisioningStateFinalized(params);

         mDeferredMetricsReader.scheduleDumpMetrics(mActivity);
         clearParamsFile();
     }

     /**
      * This method is called by the parent activity to force the final commit of all state changes.
      * After this is called, any further calls to {@link #provisioningFinalized()} will return
      * immediately without taking any action.
      */
     final void commitFinalizedState() {
         final ProvisioningParams params = loadProvisioningParams();
         if (params == null) {
             ProvisionLogger.logw(
                     "Attempt to commitFinalizedState when params have already been deleted");
         } else {
             commitFinalizedState(loadProvisioningParams());
         }
     }

     /**
      * This method is called when onSaveInstanceState() executes on the finalization activity.
      */
     final void saveInstanceState(Bundle outState) {
         mFinalizationControllerLogic.saveInstanceState(outState);
     }

     /**
      * When saved instance state is passed to the finalization activity in its onCreate() method,
      * that state is passed to the FinalizationControllerLogic object here so it can be restored.
      */
     final void restoreInstanceState(Bundle savedInstanceState) {
         mFinalizationControllerLogic.restoreInstanceState(savedInstanceState,
                 loadProvisioningParams());
     }

     /**
      * Cleanup that must happen when the finalization activity is destroyed, even if we haven't yet
      * called {@link #commitFinalizedState()} to finalize the system's provisioning state.
      */
     final void activityDestroyed(boolean isFinishing) {
         mFinalizationControllerLogic.activityDestroyed(isFinishing);
     }
 }
	/*
	* Copyright 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 com.android.managedprovisioning.finalization;

	import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE;
	import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE;

	import static com.android.internal.util.Preconditions.checkNotNull;

	import android.annotation.IntDef;
	import android.app.Activity;
	import android.app.NotificationManager;
	import android.os.Bundle;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.managedprovisioning.analytics.DeferredMetricsReader;
	import com.android.managedprovisioning.common.NotificationHelper;
	import com.android.managedprovisioning.common.ProvisionLogger;
	import com.android.managedprovisioning.common.SettingsFacade;
	import com.android.managedprovisioning.common.Utils;
	import com.android.managedprovisioning.model.ProvisioningParams;
	import com.android.managedprovisioning.provisioning.Constants;

	import java.io.File;

	/**
	* Controller for the finalization of managed provisioning. This class should be invoked after
	* {@link PreFinalizationController}. Provisioning is finalized via calls to
	* {@link #provisioningFinalized()} and {@link #commitFinalizedState()}. Different instances of
	* this class will be tailored to run these two methods at different points in the Setup Wizard user
	* flows, based on the type of FinalizationControllerLogic they are constructed with.
	*/
	public final class FinalizationController {

	static final int PROVISIONING_FINALIZED_RESULT_NO_CHILD_ACTIVITY_LAUNCHED = 1;
	static final int PROVISIONING_FINALIZED_RESULT_CHILD_ACTIVITY_LAUNCHED = 2;
	static final int PROVISIONING_FINALIZED_RESULT_SKIPPED = 3;
	@IntDef({
	PROVISIONING_FINALIZED_RESULT_NO_CHILD_ACTIVITY_LAUNCHED,
	PROVISIONING_FINALIZED_RESULT_CHILD_ACTIVITY_LAUNCHED,
	PROVISIONING_FINALIZED_RESULT_SKIPPED})
	@interface ProvisioningFinalizedResult {}

	private static final int DPC_SETUP_REQUEST_CODE = 1;
	private static final int FINAL_SCREEN_REQUEST_CODE = 2;

	private final FinalizationControllerLogic mFinalizationControllerLogic;
	private final Activity mActivity;
	private final Utils mUtils;
	private final SettingsFacade mSettingsFacade;
	private final UserProvisioningStateHelper mUserProvisioningStateHelper;
	private final ProvisioningIntentProvider mProvisioningIntentProvider;
	private final NotificationHelper mNotificationHelper;
	private final DeferredMetricsReader mDeferredMetricsReader;
	private @ProvisioningFinalizedResult int mProvisioningFinalizedResult;
	private ProvisioningParamsUtils mProvisioningParamsUtils;

	public FinalizationController(Activity activity,
	FinalizationControllerLogic finalizationControllerLogic,
	UserProvisioningStateHelper userProvisioningStateHelper) {
	this(
	activity,
	finalizationControllerLogic,
	new Utils(),
	new SettingsFacade(),
	userProvisioningStateHelper,
	new NotificationHelper(activity),
	new DeferredMetricsReader(
	Constants.getDeferredMetricsFile(activity)),
	new ProvisioningParamsUtils());
	}

	public FinalizationController(Activity activity,
	FinalizationControllerLogic finalizationControllerLogic) {
	this(
	activity,
	finalizationControllerLogic,
	new Utils(),
	new SettingsFacade(),
	new UserProvisioningStateHelper(activity),
	new NotificationHelper(activity),
	new DeferredMetricsReader(
	Constants.getDeferredMetricsFile(activity)),
	new ProvisioningParamsUtils());
	}

	@VisibleForTesting
	FinalizationController(Activity activity,
	FinalizationControllerLogic finalizationControllerLogic,
	Utils utils,
	SettingsFacade settingsFacade,
	UserProvisioningStateHelper helper,
	NotificationHelper notificationHelper,
	DeferredMetricsReader deferredMetricsReader,
	ProvisioningParamsUtils provisioningParamsUtils) {
	mActivity = checkNotNull(activity);
	mFinalizationControllerLogic = checkNotNull(finalizationControllerLogic);
	mUtils = checkNotNull(utils);
	mSettingsFacade = checkNotNull(settingsFacade);
	mUserProvisioningStateHelper = checkNotNull(helper);
	mProvisioningIntentProvider = new ProvisioningIntentProvider();
	mNotificationHelper = checkNotNull(notificationHelper);
	mDeferredMetricsReader = checkNotNull(deferredMetricsReader);
	mProvisioningParamsUtils = provisioningParamsUtils;
	}

	@VisibleForTesting
	final PrimaryProfileFinalizationHelper getPrimaryProfileFinalizationHelper(
	ProvisioningParams params) {
	return new PrimaryProfileFinalizationHelper(params.accountToMigrate,
	params.keepAccountMigrated, mUtils.getManagedProfile(mActivity),
	params.inferDeviceAdminPackageName(), mUtils,
	mUtils.isAdminIntegratedFlow(params));
	}

	/**
	* This method is invoked when provisioning is finalized.
	*
	* <p>This method has to be invoked after
	* {@link PreFinalizationController#deviceManagementEstablished(ProvisioningParams)}
	* was called. It is commonly invoked at the end of the setup flow, if provisioning occurs
	* during the setup flow. It loads the provisioning params from the storage, notifies the DPC
	* about the completed provisioning and sets the right user provisioning states.
	*
	* <p>To retrieve the resulting state of this method, use
	* {@link #getProvisioningFinalizedResult()}
	*
	* <p>This method may be called multiple times. {@link #commitFinalizedState()} ()} must be
	* called after the final call to this method. If this method is called again after that, it
	* will return immediately without taking any action.
	*/
	final void provisioningFinalized() {
	mProvisioningFinalizedResult = PROVISIONING_FINALIZED_RESULT_SKIPPED;

	if (mUserProvisioningStateHelper.isStateUnmanagedOrFinalized()) {
	ProvisionLogger.logw("provisioningFinalized called, but state is finalized or "
	+ "unmanaged");
	return;
	}

	final ProvisioningParams params = loadProvisioningParams();
	if (params == null) {
	ProvisionLogger.logw("FinalizationController invoked, but no stored params");
	return;
	}

	if (!mFinalizationControllerLogic.isReadyForFinalization(params)) {
	return;
	}

	mProvisioningFinalizedResult = PROVISIONING_FINALIZED_RESULT_NO_CHILD_ACTIVITY_LAUNCHED;
	if (mUtils.isAdminIntegratedFlow(params)) {
	// Don't send ACTION_PROFILE_PROVISIONING_COMPLETE broadcast to DPC or launch DPC by
	// ACTION_PROVISIONING_SUCCESSFUL intent if it's admin integrated flow.
	if (mUtils.isDeviceOwnerAction(params.provisioningAction)) {
	mProvisioningIntentProvider.launchFinalizationScreenForResult(mActivity, params,
	FINAL_SCREEN_REQUEST_CODE);
	mProvisioningFinalizedResult =
	PROVISIONING_FINALIZED_RESULT_CHILD_ACTIVITY_LAUNCHED;
	}
	} else {
	if (params.provisioningAction.equals(ACTION_PROVISION_MANAGED_PROFILE)) {
	mProvisioningFinalizedResult =
	mFinalizationControllerLogic.notifyDpcManagedProfile(
	params, DPC_SETUP_REQUEST_CODE);
	} else {
	mProvisioningFinalizedResult =
	mFinalizationControllerLogic.notifyDpcManagedDeviceOrUser(
	params, DPC_SETUP_REQUEST_CODE);
	}
	}
	}

	/**
	* @throws IllegalStateException if {@link #provisioningFinalized()} was not called before.
	*/
	final @ProvisioningFinalizedResult int getProvisioningFinalizedResult() {
	if (mProvisioningFinalizedResult == 0) {
	throw new IllegalStateException("provisioningFinalized() has not been called.");
	}
	return mProvisioningFinalizedResult;
	}

	@VisibleForTesting
	final void clearParamsFile() {
	final File file = mProvisioningParamsUtils.getProvisioningParamsFile(mActivity);
	if (file != null) {
	file.delete();
	}
	}

	private ProvisioningParams loadProvisioningParams() {
	final File file = mProvisioningParamsUtils.getProvisioningParamsFile(mActivity);
	final ProvisioningParams params = ProvisioningParams.load(file);
	return params;
	}

	/**
	* Update the system's provisioning state, and commit any other irreversible changes that
	* must wait until finalization is 100% completed.
	*/
	private void commitFinalizedState(ProvisioningParams params) {
	if (ACTION_PROVISION_MANAGED_DEVICE.equals(params.provisioningAction)) {
	mNotificationHelper.showPrivacyReminderNotification(
	mActivity, NotificationManager.IMPORTANCE_DEFAULT);
	} else if (ACTION_PROVISION_MANAGED_PROFILE.equals(params.provisioningAction)
	&& mFinalizationControllerLogic.shouldFinalizePrimaryProfile(params)) {
	getPrimaryProfileFinalizationHelper(params)
	.finalizeProvisioningInPrimaryProfile(mActivity, null);
	}

	mUserProvisioningStateHelper.markUserProvisioningStateFinalized(params);

	mDeferredMetricsReader.scheduleDumpMetrics(mActivity);
	clearParamsFile();
	}

	/**
	* This method is called by the parent activity to force the final commit of all state changes.
	* After this is called, any further calls to {@link #provisioningFinalized()} will return
	* immediately without taking any action.
	*/
	final void commitFinalizedState() {
	final ProvisioningParams params = loadProvisioningParams();
	if (params == null) {
	ProvisionLogger.logw(
	"Attempt to commitFinalizedState when params have already been deleted");
	} else {
	commitFinalizedState(loadProvisioningParams());
	}
	}

	/**
	* This method is called when onSaveInstanceState() executes on the finalization activity.
	*/
	final void saveInstanceState(Bundle outState) {
	mFinalizationControllerLogic.saveInstanceState(outState);
	}

	/**
	* When saved instance state is passed to the finalization activity in its onCreate() method,
	* that state is passed to the FinalizationControllerLogic object here so it can be restored.
	*/
	final void restoreInstanceState(Bundle savedInstanceState) {
	mFinalizationControllerLogic.restoreInstanceState(savedInstanceState,
	loadProvisioningParams());
	}

	/**
	* Cleanup that must happen when the finalization activity is destroyed, even if we haven't yet
	* called {@link #commitFinalizedState()} to finalize the system's provisioning state.
	*/
	final void activityDestroyed(boolean isFinishing) {
	mFinalizationControllerLogic.activityDestroyed(isFinishing);
	}
	}