android/managedprovisioning/ProfileOwnerProvisioningService.java

/*
 * Copyright 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.
 */

package com.android.managedprovisioning;

import static android.app.admin.DeviceAdminReceiver.ACTION_PROFILE_PROVISIONING_COMPLETE;
import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE;
import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE;

import android.accounts.AccountManager;
import android.app.Activity;
import android.app.ActivityManagerNative;
import android.app.IActivityManager;
import android.app.Service;
import android.app.admin.DevicePolicyManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.IPackageManager;
import android.content.pm.PackageManager;
import android.content.pm.UserInfo;
import android.os.AsyncTask;
import android.os.IBinder;
import android.os.Process;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import android.support.v4.content.LocalBroadcastManager;

import com.android.managedprovisioning.common.Utils;
import com.android.managedprovisioning.CrossProfileIntentFiltersHelper;
import com.android.managedprovisioning.model.ProvisioningParams;
import com.android.managedprovisioning.task.DeleteNonRequiredAppsTask;
import com.android.managedprovisioning.task.DisableBluetoothSharingTask;
import com.android.managedprovisioning.task.DisableInstallShortcutListenersTask;
import com.android.managedprovisioning.task.ManagedProfileSettingsTask;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * Service that runs the profile owner provisioning.
 *
 * <p>This service is started from and sends updates to the {@link ProfileOwnerProvisioningActivity},
 * which contains the provisioning UI.
 */
public class ProfileOwnerProvisioningService extends Service {
    // Intent actions for communication with DeviceOwnerProvisioningService.
    public static final String ACTION_PROVISIONING_SUCCESS =
            "com.android.managedprovisioning.provisioning_success";
    public static final String ACTION_PROVISIONING_ERROR =
            "com.android.managedprovisioning.error";
    public static final String ACTION_PROVISIONING_CANCELLED =
            "com.android.managedprovisioning.cancelled";
    public static final String EXTRA_LOG_MESSAGE_KEY = "ProvisioningErrorLogMessage";

    // Maximum time we will wait for ACTION_USER_UNLOCK until we give up and continue without
    // account migration.
    private static final int USER_UNLOCKED_TIMEOUT_SECONDS = 120; // 2 minutes

    // Status flags for the provisioning process.
    /** Provisioning not started. */
    private static final int STATUS_UNKNOWN = 0;
    /** Provisioning started, no errors or cancellation requested received. */
    private static final int STATUS_STARTED = 1;
    /** Provisioning in progress, but user has requested cancellation. */
    private static final int STATUS_CANCELLING = 2;
    // Final possible states for the provisioning process.
    /** Provisioning completed successfully. */
    private static final int STATUS_DONE = 3;
    /** Provisioning failed and cleanup complete. */
    private static final int STATUS_ERROR = 4;
    /** Provisioning cancelled and cleanup complete. */
    private static final int STATUS_CANCELLED = 5;

    private IPackageManager mIpm;
    private UserInfo mManagedProfileOrUserInfo;
    private AccountManager mAccountManager;
    private UserManager mUserManager;
    private UserUnlockedReceiver mUnlockedReceiver;

    private AsyncTask<Intent, Void, Void> runnerTask;

    // MessageId of the last error message.
    private String mLastErrorMessage = null;

    // Current status of the provisioning process.
    private int mProvisioningStatus = STATUS_UNKNOWN;

    private ProvisioningParams mParams;

    private final Utils mUtils = new Utils();

    private class RunnerTask extends AsyncTask<Intent, Void, Void> {
        @Override
        protected Void doInBackground(Intent ... intents) {
            // Atomically move to STATUS_STARTED at most once.
            synchronized (ProfileOwnerProvisioningService.this) {
                if (mProvisioningStatus == STATUS_UNKNOWN) {
                    mProvisioningStatus = STATUS_STARTED;
                } else {
                    // Process already started, don't start again.
                    return null;
                }
            }

            try {
                initialize(intents[0]);
                startManagedProfileOrUserProvisioning();
            } catch (ProvisioningException e) {
                // Handle internal errors.
                error(e.getMessage(), e);
                finish();
            } catch (Exception e) {
                // General catch-all to ensure process cleans up in all cases.
                error("Failed to initialize managed profile, aborting.", e);
                finish();
            }

            return null;
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();

        mIpm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
        mAccountManager = (AccountManager) getSystemService(Context.ACCOUNT_SERVICE);
        mUserManager = (UserManager) getSystemService(Context.USER_SERVICE);

        runnerTask = new RunnerTask();
    }

    @Override
    public int onStartCommand(final Intent intent, int flags, int startId) {
        if (ProfileOwnerProvisioningActivity.ACTION_CANCEL_PROVISIONING.equals(intent.getAction())) {
            ProvisionLogger.logd("Cancelling profile owner provisioning service");
            cancelProvisioning();
            return START_NOT_STICKY;
        }

        ProvisionLogger.logd("Starting profile owner provisioning service");

        try {
            runnerTask.execute(intent);
        } catch (IllegalStateException e) {
            // runnerTask is either in progress, or finished.
            ProvisionLogger.logd(
                    "ProfileOwnerProvisioningService: Provisioning already started, "
                    + "second provisioning intent not being processed, only reporting status.");
            reportStatus();
        }
        return START_NOT_STICKY;
    }

    private void reportStatus() {
        synchronized (this) {
            switch (mProvisioningStatus) {
                case STATUS_DONE:
                    notifyActivityOfSuccess();
                    break;
                case STATUS_CANCELLED:
                    notifyActivityCancelled();
                    break;
                case STATUS_ERROR:
                    notifyActivityError();
                    break;
                case STATUS_UNKNOWN:
                case STATUS_STARTED:
                case STATUS_CANCELLING:
                    // Don't notify UI of status when just-started/in-progress.
                    break;
            }
        }
    }

    private void cancelProvisioning() {
        synchronized (this) {
            switch (mProvisioningStatus) {
                case STATUS_DONE:
                    // Process completed, we should honor user request to cancel
                    // though.
                    mProvisioningStatus = STATUS_CANCELLING;
                    cleanupUserProfile();
                    mProvisioningStatus = STATUS_CANCELLED;
                    reportStatus();
                    break;
                case STATUS_UNKNOWN:
                    // Process hasn't started, move straight to cancelled state.
                    mProvisioningStatus = STATUS_CANCELLED;
                    reportStatus();
                    break;
                case STATUS_STARTED:
                    // Process is mid-flow, flag up that the user has requested
                    // cancellation.
                    mProvisioningStatus = STATUS_CANCELLING;
                    break;
                case STATUS_CANCELLING:
                    // Cancellation already being processed.
                    break;
                case STATUS_CANCELLED:
                case STATUS_ERROR:
                    // Process already completed, nothing left to cancel.
                    break;
            }
        }
    }

    private void initialize(Intent intent) {
        // Load the ProvisioningParams (from message in Intent).
        mParams = (ProvisioningParams) intent.getParcelableExtra(
                ProvisioningParams.EXTRA_PROVISIONING_PARAMS);
        if (mParams.accountToMigrate != null) {
            ProvisionLogger.logi("Migrating account to managed profile");
        }
    }

    /**
     * This is the core method to create a managed profile or user. It goes through every
     * provisioning step.
     */
    private void startManagedProfileOrUserProvisioning() throws ProvisioningException {

        ProvisionLogger.logd("Starting managed profile or user provisioning");

        if(isProvisioningManagedUser()) {
            mManagedProfileOrUserInfo = mUserManager.getUserInfo(mUserManager.getUserHandle());
            if(mManagedProfileOrUserInfo == null) {
                throw raiseError("Couldn't get current user information");
            }
        } else {
            // Work through the provisioning steps in their corresponding order
            createProfile(getString(R.string.default_managed_profile_name));
        }
        if (mManagedProfileOrUserInfo != null) {
            final DeleteNonRequiredAppsTask deleteNonRequiredAppsTask;
            final DisableInstallShortcutListenersTask disableInstallShortcutListenersTask;
            final DisableBluetoothSharingTask disableBluetoothSharingTask;
            final ManagedProfileSettingsTask managedProfileSettingsTask =
                    new ManagedProfileSettingsTask(this, mManagedProfileOrUserInfo.id);

            disableInstallShortcutListenersTask = new DisableInstallShortcutListenersTask(this,
                    mManagedProfileOrUserInfo.id);
            disableBluetoothSharingTask = new DisableBluetoothSharingTask(
                    mManagedProfileOrUserInfo.id);
            // TODO Add separate set of apps for MANAGED_USER, currently same as of DEVICE_OWNER.
            deleteNonRequiredAppsTask = new DeleteNonRequiredAppsTask(this,
                    mParams.deviceAdminComponentName.getPackageName(),
                    (isProvisioningManagedUser() ? DeleteNonRequiredAppsTask.MANAGED_USER
                            : DeleteNonRequiredAppsTask.PROFILE_OWNER),
                    true /* creating new profile */,
                    mManagedProfileOrUserInfo.id, false /* delete non-required system apps */,
                    new DeleteNonRequiredAppsTask.Callback() {

                        @Override
                        public void onSuccess() {
                            // Need to explicitly handle exceptions here, as
                            // onError() is not invoked for failures in
                            // onSuccess().
                            try {
                                disableBluetoothSharingTask.run();
                                if (!isProvisioningManagedUser()) {
                                    managedProfileSettingsTask.run();
                                    disableInstallShortcutListenersTask.run();
                                }
                                setUpUserOrProfile();
                            } catch (ProvisioningException e) {
                                error(e.getMessage(), e);
                            } catch (Exception e) {
                                error("Provisioning failed", e);
                            }
                            finish();
                        }

                        @Override
                        public void onError() {
                            // Raise an error with a tracing exception attached.
                            error("Delete non required apps task failed.", new Exception());
                            finish();
                        }
                    });

            deleteNonRequiredAppsTask.run();
        }
    }

    /**
     * Called when the new profile or managed user is ready for provisioning (the profile is created
     * and all the apps not needed have been deleted).
     */
    private void setUpUserOrProfile() throws ProvisioningException {
        installMdmOnManagedProfile();
        setMdmAsActiveAdmin();
        setMdmAsManagedProfileOwner();

        if (!isProvisioningManagedUser()) {
            setOrganizationColor();
            setDefaultUserRestrictions();
            CrossProfileIntentFiltersHelper.setFilters(
                    getPackageManager(), getUserId(), mManagedProfileOrUserInfo.id);
            if (!startManagedProfile(mManagedProfileOrUserInfo.id)) {
                throw raiseError("Could not start user in background");
            }
            // Wait for ACTION_USER_UNLOCKED to be sent before trying to migrate the account.
            // Even if no account is present, we should not send the provisioning complete broadcast
            // before the managed profile user is properly started.
            if ((mUnlockedReceiver != null) && !mUnlockedReceiver.waitForUserUnlocked()) {
                return;
            }

            // Note: account migration must happen after setting the profile owner.
            // Otherwise, there will be a time interval where some apps may think that the account
            // does not have a profile owner.
            mUtils.maybeCopyAccount(this, mParams.accountToMigrate, Process.myUserHandle(),
                    mManagedProfileOrUserInfo.getUserHandle());
        }
    }

    /**
     * Notify the calling activity of our final status, perform any cleanup if
     * the process didn't succeed.
     */
    private void finish() {
        ProvisionLogger.logi("Finishing provisioning process, status: "
                             + mProvisioningStatus);
        // Reached the end of the provisioning process, take appropriate action
        // based on current mProvisioningStatus.
        synchronized (this) {
            switch (mProvisioningStatus) {
                case STATUS_STARTED:
                    // Provisioning process completed normally.
                    notifyMdmAndCleanup();
                    mProvisioningStatus = STATUS_DONE;
                    break;
                case STATUS_UNKNOWN:
                    // No idea how we could end up in finish() in this state,
                    // but for safety treat it as an error and fall-through to
                    // STATUS_ERROR.
                    mLastErrorMessage = "finish() invoked in STATUS_UNKNOWN";
                    mProvisioningStatus = STATUS_ERROR;
                    break;
                case STATUS_ERROR:
                    // Process errored out, cleanup partially created managed
                    // profile.
                    cleanupUserProfile();
                    break;
                case STATUS_CANCELLING:
                    // User requested cancellation during processing, remove
                    // the successfully created profile.
                    cleanupUserProfile();
                    mProvisioningStatus = STATUS_CANCELLED;
                    break;
                case STATUS_CANCELLED:
                case STATUS_DONE:
                    // Shouldn't be possible to already be in this state?!?
                    ProvisionLogger.logw("finish() invoked multiple times?");
                    break;
            }
        }

        ProvisionLogger.logi("Finished provisioning process, final status: "
                + mProvisioningStatus);

        // Notify UI activity of final status reached.
        reportStatus();
    }

    /**
     * Initialize the user that underlies the managed profile.
     * This is required so that the provisioning complete broadcast can be sent across to the
     * profile and apps can run on it.
     */
    private boolean startManagedProfile(int userId)  {
        ProvisionLogger.logd("Starting user in background");
        IActivityManager iActivityManager = ActivityManagerNative.getDefault();
        // Register a receiver for the Intent.ACTION_USER_UNLOCKED to know when the managed profile
        // has been started and unlocked.
        mUnlockedReceiver = new UserUnlockedReceiver(this, userId);
        try {
            return iActivityManager.startUserInBackground(userId);
        } catch (RemoteException neverThrown) {
            // Never thrown, as we are making local calls.
            ProvisionLogger.loge("This should not happen.", neverThrown);
        }
        return false;
    }

    private void notifyActivityOfSuccess() {
        Intent successIntent = new Intent(ACTION_PROVISIONING_SUCCESS);
        LocalBroadcastManager.getInstance(ProfileOwnerProvisioningService.this)
                .sendBroadcast(successIntent);
    }

    /**
     * Notify the mdm that provisioning has completed. When the mdm has received the intent, stop
     * the service and notify the {@link ProfileOwnerProvisioningActivity} so that it can finish
     * itself.
     */
    private void notifyMdmAndCleanup() {
        // Set DPM userProvisioningState appropriately and persist mParams for use during
        // FinalizationActivity if necessary.
        mUtils.markUserProvisioningStateInitiallyDone(this, mParams);

        if (mParams.provisioningAction.equals(ACTION_PROVISION_MANAGED_PROFILE)) {
            // Set the user_setup_complete flag on the managed-profile as setup-wizard is never run
            // for that user. This is not relevant for other cases since
            // Utils.markUserProvisioningStateInitiallyDone() communicates provisioning state to
            // setup-wizard via DPM.setUserProvisioningState() if necessary.
            mUtils.markUserSetupComplete(this, mManagedProfileOrUserInfo.id);
        }

        // If profile owner provisioning was started after current user setup is completed, then we
        // can directly send the ACTION_PROFILE_PROVISIONING_COMPLETE broadcast to the MDM.
        // But if the provisioning was started as part of setup wizard flow, we signal setup-wizard
        // should shutdown via DPM.setUserProvisioningState(), which will result in a finalization
        // intent being sent to us once setup-wizard finishes. As part of the finalization intent
        // handling we then broadcast ACTION_PROFILE_PROVISIONING_COMPLETE.
        if (mUtils.isUserSetupCompleted(this)) {
            UserHandle managedUserHandle = new UserHandle(mManagedProfileOrUserInfo.id);

            // Use an ordered broadcast, so that we only finish when the mdm has received it.
            // Avoids a lag in the transition between provisioning and the mdm.
            BroadcastReceiver mdmReceivedSuccessReceiver = new MdmReceivedSuccessReceiver(
                    mParams.accountToMigrate, mParams.deviceAdminComponentName.getPackageName());

            Intent completeIntent = new Intent(ACTION_PROFILE_PROVISIONING_COMPLETE);
            completeIntent.setComponent(mParams.deviceAdminComponentName);
            completeIntent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES |
                    Intent.FLAG_RECEIVER_FOREGROUND);
            if (mParams.adminExtrasBundle != null) {
                completeIntent.putExtra(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE,
                        mParams.adminExtrasBundle);
            }

            sendOrderedBroadcastAsUser(completeIntent, managedUserHandle, null,
                    mdmReceivedSuccessReceiver, null, Activity.RESULT_OK, null, null);
            ProvisionLogger.logd("Provisioning complete broadcast has been sent to user "
                    + managedUserHandle.getIdentifier());
        }
    }

    private void createProfile(String profileName) throws ProvisioningException {

        ProvisionLogger.logd("Creating managed profile with name " + profileName);

        mManagedProfileOrUserInfo = mUserManager.createProfileForUser(profileName,
                UserInfo.FLAG_MANAGED_PROFILE | UserInfo.FLAG_DISABLED,
                Process.myUserHandle().getIdentifier());

        if (mManagedProfileOrUserInfo == null) {
            throw raiseError("Couldn't create profile.");
        }
    }

    private void installMdmOnManagedProfile() throws ProvisioningException {
        ProvisionLogger.logd("Installing mobile device management app "
                + mParams.deviceAdminComponentName + " on managed profile");

        try {
            int status = mIpm.installExistingPackageAsUser(
                mParams.deviceAdminComponentName.getPackageName(), mManagedProfileOrUserInfo.id);
            switch (status) {
              case PackageManager.INSTALL_SUCCEEDED:
                  return;
              case PackageManager.INSTALL_FAILED_USER_RESTRICTED:
                  // Should not happen because we're not installing a restricted user
                  throw raiseError("Could not install mobile device management app on managed "
                          + "profile because the user is restricted");
              case PackageManager.INSTALL_FAILED_INVALID_URI:
                  // Should not happen because we already checked
                  throw raiseError("Could not install mobile device management app on managed "
                          + "profile because the package could not be found");
              default:
                  throw raiseError("Could not install mobile device management app on managed "
                          + "profile. Unknown status: " + status);
            }
        } catch (RemoteException neverThrown) {
            // Never thrown, as we are making local calls.
            ProvisionLogger.loge("This should not happen.", neverThrown);
        }
    }

    private void setMdmAsManagedProfileOwner() throws ProvisioningException {
        ProvisionLogger.logd("Setting package " + mParams.deviceAdminComponentName
                + " as managed profile owner.");

        DevicePolicyManager dpm =
                (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
        if (!dpm.setProfileOwner(
                mParams.deviceAdminComponentName,
                mParams.deviceAdminComponentName.getPackageName(),
                mManagedProfileOrUserInfo.id)) {
            ProvisionLogger.logw("Could not set profile owner.");
            throw raiseError("Could not set profile owner.");
        }
    }

    private void setMdmAsActiveAdmin() {
        ProvisionLogger.logd("Setting package " + mParams.deviceAdminComponentName
                + " as active admin.");

        DevicePolicyManager dpm =
                (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
        dpm.setActiveAdmin(mParams.deviceAdminComponentName, true /* refreshing*/,
                mManagedProfileOrUserInfo.id);
    }

    private void setOrganizationColor() {
        if (mParams.mainColor != null) {
            DevicePolicyManager dpm =
                    (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
            dpm.setOrganizationColorForUser(mParams.mainColor, mManagedProfileOrUserInfo.id);
        }
    }

    private ProvisioningException raiseError(String message) throws ProvisioningException {
        throw new ProvisioningException(message);
    }

    /**
     * Record the fact that an error occurred, change mProvisioningStatus to
     * reflect the fact the provisioning process failed
     */
    private void error(String dialogMessage, Exception e) {
        synchronized (this) {
            // Only case where an error condition should be notified is if we
            // are in the normal flow for provisioning. If the process has been
            // cancelled or already completed, then the fact there is an error
            // is almost irrelevant.
            if (mProvisioningStatus == STATUS_STARTED) {
                mProvisioningStatus = STATUS_ERROR;
                mLastErrorMessage = dialogMessage;

                ProvisionLogger.logw(
                        "Error occured during provisioning process: "
                        + dialogMessage,
                        e);
            } else {
                ProvisionLogger.logw(
                        "Unexpected error occured in status ["
                        + mProvisioningStatus + "]: " + dialogMessage,
                        e);
            }
        }
    }

    private void setDefaultUserRestrictions() {
        mUserManager.setUserRestriction(UserManager.DISALLOW_WALLPAPER, true,
                mManagedProfileOrUserInfo.getUserHandle());
    }

    private void notifyActivityError() {
        Intent intent = new Intent(ACTION_PROVISIONING_ERROR);
        intent.putExtra(EXTRA_LOG_MESSAGE_KEY, mLastErrorMessage);
        LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
    }

    private void notifyActivityCancelled() {
        Intent cancelIntent = new Intent(ACTION_PROVISIONING_CANCELLED);
        LocalBroadcastManager.getInstance(this).sendBroadcast(cancelIntent);
    }

    /**
     * Performs cleanup of any created user-profile on failure/cancellation.
     */
    private void cleanupUserProfile() {
        if (mManagedProfileOrUserInfo != null && !isProvisioningManagedUser()) {
            ProvisionLogger.logd("Removing managed profile");
            mUserManager.removeUser(mManagedProfileOrUserInfo.id);
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * Internal exception to allow provisioning process to terminal quickly and
     * cleanly on first error, rather than continuing to process despite errors
     * occurring.
     */
    private static class ProvisioningException extends Exception {
        public ProvisioningException(String detailMessage) {
            super(detailMessage);
        }
    }

    public boolean isProvisioningManagedUser() {
        return mParams.provisioningAction.equals(DevicePolicyManager.ACTION_PROVISION_MANAGED_USER);
    }

    /**
     * BroadcastReceiver that listens to {@link Intent#ACTION_USER_UNLOCKED} in order to provide
     * a blocking wait until the managed profile has been started and unlocked.
     */
    private static class UserUnlockedReceiver extends BroadcastReceiver {
        private static final IntentFilter FILTER = new IntentFilter(Intent.ACTION_USER_UNLOCKED);

        private final Semaphore semaphore = new Semaphore(0);
        private final Context mContext;
        private final int mUserId;

        UserUnlockedReceiver(Context context, int userId) {
            mContext = context;
            mUserId = userId;
            mContext.registerReceiverAsUser(this, new UserHandle(userId), FILTER, null, null);
        }

        @Override
        public void onReceive(Context context, Intent intent ) {
            if (!Intent.ACTION_USER_UNLOCKED.equals(intent.getAction())) {
                ProvisionLogger.logw("Unexpected intent: " + intent);
                return;
            }
            if (intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL) == mUserId) {
                ProvisionLogger.logd("Received ACTION_USER_UNLOCKED for user " + mUserId);
                semaphore.release();
                mContext.unregisterReceiver(this);
            }
        }

        public boolean waitForUserUnlocked() {
            ProvisionLogger.logd("Waiting for ACTION_USER_UNLOCKED");
            try {
                return semaphore.tryAcquire(USER_UNLOCKED_TIMEOUT_SECONDS, TimeUnit.SECONDS);
            } catch (InterruptedException ie) {
                mContext.unregisterReceiver(this);
                return false;
            }
        }
    }
 }