/*
 * Copyright (C) 2016 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.server.retaildemo;

import android.Manifest;
import android.app.ActivityManager;
import android.app.ActivityManagerInternal;
import android.app.AppGlobals;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.RetailDemoModeServiceInternal;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.IPackageManager;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.UserInfo;
import android.content.res.Configuration;
import android.database.ContentObserver;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraManager;
import android.media.AudioManager;
import android.media.AudioSystem;
import android.net.Uri;
import android.net.wifi.WifiManager;
import android.os.Environment;
import android.os.FileUtils;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
import android.os.RemoteException;
import android.os.SystemClock;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.CallLog;
import android.provider.MediaStore;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.KeyValueListParser;
import android.util.Slog;

import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
import com.android.internal.notification.SystemNotificationChannels;
import com.android.internal.os.BackgroundThread;
import com.android.internal.R;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.widget.LockPatternUtils;
import com.android.server.LocalServices;
import com.android.server.PreloadsFileCacheExpirationJobService;
import com.android.server.ServiceThread;
import com.android.server.SystemService;
import com.android.server.am.ActivityManagerService;
import com.android.server.retaildemo.UserInactivityCountdownDialog.OnCountDownExpiredListener;

import java.io.File;
import java.util.ArrayList;

public class RetailDemoModeService extends SystemService {
    private static final boolean DEBUG = false;

    private static final String TAG = RetailDemoModeService.class.getSimpleName();
    private static final String DEMO_USER_NAME = "Demo";
    private static final String ACTION_RESET_DEMO =
            "com.android.server.retaildemo.ACTION_RESET_DEMO";
    @VisibleForTesting
    static final String SYSTEM_PROPERTY_RETAIL_DEMO_ENABLED = "sys.retaildemo.enabled";

    private static final int MSG_TURN_SCREEN_ON = 0;
    private static final int MSG_INACTIVITY_TIME_OUT = 1;
    private static final int MSG_START_NEW_SESSION = 2;

    private static final long SCREEN_WAKEUP_DELAY = 2500;
    private static final long USER_INACTIVITY_TIMEOUT_MIN = 10000;
    private static final long USER_INACTIVITY_TIMEOUT_DEFAULT = 90000;
    private static final long WARNING_DIALOG_TIMEOUT_DEFAULT = 0;
    private static final long MILLIS_PER_SECOND = 1000;

    @VisibleForTesting
    static final int[] VOLUME_STREAMS_TO_MUTE = {
            AudioSystem.STREAM_RING,
            AudioSystem.STREAM_MUSIC
    };

    // Tron Vars
    private static final String DEMO_SESSION_COUNT = "retail_demo_session_count";
    private static final String DEMO_SESSION_DURATION = "retail_demo_session_duration";

    boolean mDeviceInDemoMode;
    boolean mIsCarrierDemoMode;
    int mCurrentUserId = UserHandle.USER_SYSTEM;
    long mUserInactivityTimeout;
    long mWarningDialogTimeout;
    private Injector mInjector;
    Handler mHandler;
    private ServiceThread mHandlerThread;
    private String[] mCameraIdsWithFlash;
    private PreloadAppsInstaller mPreloadAppsInstaller;

    final Object mActivityLock = new Object();
    // Whether the newly created demo user has interacted with the screen yet
    @GuardedBy("mActivityLock")
    boolean mUserUntouched;
    @GuardedBy("mActivityLock")
    long mFirstUserActivityTime;
    @GuardedBy("mActivityLock")
    long mLastUserActivityTime;

    private boolean mSafeBootRestrictionInitialState;
    private int mPackageVerifierEnableInitialState;

    private IntentReceiver mBroadcastReceiver = null;

    private final class IntentReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (!mDeviceInDemoMode) {
                return;
            }
            final String action = intent.getAction();
            switch (action) {
                case Intent.ACTION_SCREEN_OFF:
                    mHandler.removeMessages(MSG_TURN_SCREEN_ON);
                    mHandler.sendEmptyMessageDelayed(MSG_TURN_SCREEN_ON, SCREEN_WAKEUP_DELAY);
                    break;
                case ACTION_RESET_DEMO:
                    mHandler.sendEmptyMessage(MSG_START_NEW_SESSION);
                    break;
            }
        }
    };

    final class MainHandler extends Handler {

        MainHandler(Looper looper) {
            super(looper, null, true);
        }

        @Override
        public void handleMessage(Message msg) {
            if (!mDeviceInDemoMode) {
                return;
            }
            switch (msg.what) {
                case MSG_TURN_SCREEN_ON:
                    if (mInjector.isWakeLockHeld()) {
                        mInjector.releaseWakeLock();
                    }
                    mInjector.acquireWakeLock();
                    break;
                case MSG_INACTIVITY_TIME_OUT:
                    if (!mIsCarrierDemoMode && isDemoLauncherDisabled()) {
                        Slog.i(TAG, "User inactivity timeout reached");
                        showInactivityCountdownDialog();
                    }
                    break;
                case MSG_START_NEW_SESSION:
                    if (DEBUG) {
                        Slog.d(TAG, "Switching to a new demo user");
                    }
                    removeMessages(MSG_START_NEW_SESSION);
                    removeMessages(MSG_INACTIVITY_TIME_OUT);
                    if (!mIsCarrierDemoMode && mCurrentUserId != UserHandle.USER_SYSTEM) {
                        logSessionDuration();
                    }

                    final UserManager um = mInjector.getUserManager();
                    UserInfo demoUser = null;
                    if (mIsCarrierDemoMode) {
                        // Re-use the existing demo user in carrier demo mode.
                        for (UserInfo user : um.getUsers()) {
                            if (user.isDemo()) {
                                demoUser = user;
                                break;
                            }
                        }
                    }

                    if (demoUser == null) {
                        // User in carrier demo mode should survive reboots.
                        final int flags = UserInfo.FLAG_DEMO
                                | (mIsCarrierDemoMode ? 0 : UserInfo.FLAG_EPHEMERAL);
                        demoUser = um.createUser(DEMO_USER_NAME, flags);
                    }

                    if (demoUser != null && mCurrentUserId != demoUser.id) {
                        setupDemoUser(demoUser);
                        mInjector.switchUser(demoUser.id);
                    }
                    break;
            }
        }
    }

    @VisibleForTesting
    class SettingsObserver extends ContentObserver {

        private final static String KEY_USER_INACTIVITY_TIMEOUT = "user_inactivity_timeout_ms";
        private final static String KEY_WARNING_DIALOG_TIMEOUT = "warning_dialog_timeout_ms";

        private final Uri mDeviceDemoModeUri = Settings.Global
                .getUriFor(Settings.Global.DEVICE_DEMO_MODE);
        private final Uri mDeviceProvisionedUri = Settings.Global
                .getUriFor(Settings.Global.DEVICE_PROVISIONED);
        private final Uri mRetailDemoConstantsUri = Settings.Global
                .getUriFor(Settings.Global.RETAIL_DEMO_MODE_CONSTANTS);

        private final KeyValueListParser mParser = new KeyValueListParser(',');

        public SettingsObserver(Handler handler) {
            super(handler);
        }

        public void register() {
            final ContentResolver cr = mInjector.getContentResolver();
            cr.registerContentObserver(mDeviceDemoModeUri, false, this, UserHandle.USER_SYSTEM);
            cr.registerContentObserver(mDeviceProvisionedUri, false, this, UserHandle.USER_SYSTEM);
            cr.registerContentObserver(mRetailDemoConstantsUri, false, this,
                    UserHandle.USER_SYSTEM);
        }

        @Override
        public void onChange(boolean selfChange, Uri uri) {
            if (mRetailDemoConstantsUri.equals(uri)) {
                refreshTimeoutConstants();
                return;
            }

            // If device is provisioned and left demo mode - run the cleanup in demo folder
            if (isDeviceProvisioned()) {
                if (UserManager.isDeviceInDemoMode(getContext())) {
                    startDemoMode();
                } else {
                    mInjector.systemPropertiesSet(SYSTEM_PROPERTY_RETAIL_DEMO_ENABLED, "0");

                    // Run on the bg thread to not block the fg thread
                    BackgroundThread.getHandler().post(() -> {
                        if (!deletePreloadsFolderContents()) {
                            Slog.w(TAG, "Failed to delete preloads folder contents");
                        }
                        PreloadsFileCacheExpirationJobService.schedule(mInjector.getContext());
                    });

                    stopDemoMode();

                    if (mInjector.isWakeLockHeld()) {
                        mInjector.releaseWakeLock();
                    }
                }
            }
        }

        private void refreshTimeoutConstants() {
            try {
                mParser.setString(Settings.Global.getString(mInjector.getContentResolver(),
                        Settings.Global.RETAIL_DEMO_MODE_CONSTANTS));
            } catch (IllegalArgumentException exc) {
                Slog.e(TAG, "Invalid string passed to KeyValueListParser");
                // Consuming the exception to fall back to default values.
            }
            mWarningDialogTimeout = mParser.getLong(KEY_WARNING_DIALOG_TIMEOUT,
                    WARNING_DIALOG_TIMEOUT_DEFAULT);
            mUserInactivityTimeout = mParser.getLong(KEY_USER_INACTIVITY_TIMEOUT,
                    USER_INACTIVITY_TIMEOUT_DEFAULT);
            mUserInactivityTimeout = Math.max(mUserInactivityTimeout, USER_INACTIVITY_TIMEOUT_MIN);
        }
    }

    private void showInactivityCountdownDialog() {
        UserInactivityCountdownDialog dialog = new UserInactivityCountdownDialog(getContext(),
                mWarningDialogTimeout, MILLIS_PER_SECOND);
        dialog.setNegativeButtonClickListener(null);
        dialog.setPositiveButtonClickListener(new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mHandler.sendEmptyMessage(MSG_START_NEW_SESSION);
            }
        });
        dialog.setOnCountDownExpiredListener(new OnCountDownExpiredListener() {
            @Override
            public void onCountDownExpired() {
                mHandler.sendEmptyMessage(MSG_START_NEW_SESSION);
            }
        });
        dialog.show();
    }

    public RetailDemoModeService(Context context) {
        this(new Injector(context));
    }

    @VisibleForTesting
    RetailDemoModeService(Injector injector) {
        super(injector.getContext());

        mInjector = injector;
        synchronized (mActivityLock) {
            mFirstUserActivityTime = mLastUserActivityTime = SystemClock.uptimeMillis();
        }
    }

    boolean isDemoLauncherDisabled() {
        int enabledState = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
        try {
            final IPackageManager iPm = mInjector.getIPackageManager();
            final String demoLauncherComponent =
                    getContext().getString(R.string.config_demoModeLauncherComponent);
            enabledState = iPm.getComponentEnabledSetting(
                    ComponentName.unflattenFromString(demoLauncherComponent), mCurrentUserId);
        } catch (RemoteException re) {
            Slog.e(TAG, "Error retrieving demo launcher enabled setting", re);
        }
        return enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
    }

    private void setupDemoUser(UserInfo userInfo) {
        final UserManager um = mInjector.getUserManager();
        final UserHandle user = UserHandle.of(userInfo.id);
        um.setUserRestriction(UserManager.DISALLOW_CONFIG_WIFI, true, user);
        um.setUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES, true, user);
        um.setUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS, true, user);
        um.setUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER, true, user);
        um.setUserRestriction(UserManager.DISALLOW_MODIFY_ACCOUNTS, true, user);
        um.setUserRestriction(UserManager.DISALLOW_CONFIG_BLUETOOTH, true, user);
        // Set this to false because the default is true on user creation
        um.setUserRestriction(UserManager.DISALLOW_OUTGOING_CALLS, false, user);
        // Disallow rebooting in safe mode - controlled by user 0
        um.setUserRestriction(UserManager.DISALLOW_SAFE_BOOT, true, UserHandle.SYSTEM);
        if (mIsCarrierDemoMode) {
            // Enable SMS in carrier demo mode.
            um.setUserRestriction(UserManager.DISALLOW_SMS, false, user);
        }

        Settings.Secure.putIntForUser(mInjector.getContentResolver(),
                Settings.Secure.SKIP_FIRST_USE_HINTS, 1, userInfo.id);
        Settings.Global.putInt(mInjector.getContentResolver(),
                Settings.Global.PACKAGE_VERIFIER_ENABLE, 0);

        grantRuntimePermissionToCamera(user);
        clearPrimaryCallLog();

        if (!mIsCarrierDemoMode) {
            // Enable demo launcher.
            final String demoLauncher = getContext().getString(
                    R.string.config_demoModeLauncherComponent);
            if (!TextUtils.isEmpty(demoLauncher)) {
                final ComponentName componentToEnable =
                        ComponentName.unflattenFromString(demoLauncher);
                final String packageName = componentToEnable.getPackageName();
                try {
                    final IPackageManager iPm = AppGlobals.getPackageManager();
                    iPm.setComponentEnabledSetting(componentToEnable,
                            PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0, userInfo.id);
                    iPm.setApplicationEnabledSetting(packageName,
                            PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0, userInfo.id, null);
                } catch (RemoteException re) {
                    // Internal, shouldn't happen
                }
            }
        } else {
            // Set the carrier demo mode setting for the demo user.
            final String carrierDemoModeSetting = getContext().getString(
                    R.string.config_carrierDemoModeSetting);
            Settings.Secure.putIntForUser(getContext().getContentResolver(),
                    carrierDemoModeSetting, 1, userInfo.id);

            // Enable packages for carrier demo mode.
            final String packageList = getContext().getString(
                    R.string.config_carrierDemoModePackages);
            final String[] packageNames = packageList == null ? new String[0]
                    : TextUtils.split(packageList, ",");
            final IPackageManager iPm = AppGlobals.getPackageManager();
            for (String packageName : packageNames) {
                try {
                    iPm.setApplicationEnabledSetting(packageName,
                            PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0, userInfo.id, null);
                } catch (RemoteException re) {
                    Slog.e(TAG, "Error enabling application: " + packageName, re);
                }
            }
        }
    }

    private void grantRuntimePermissionToCamera(UserHandle user) {
        final Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        final PackageManager pm = mInjector.getPackageManager();
        final ResolveInfo handler = pm.resolveActivityAsUser(cameraIntent,
                PackageManager.MATCH_DIRECT_BOOT_AWARE | PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
                user.getIdentifier());
        if (handler == null || handler.activityInfo == null) {
            return;
        }
        try {
            pm.grantRuntimePermission(handler.activityInfo.packageName,
                    Manifest.permission.ACCESS_FINE_LOCATION, user);
        } catch (Exception e) {
            // Ignore
        }
    }

    private void clearPrimaryCallLog() {
        final ContentResolver resolver = mInjector.getContentResolver();

        // Deleting primary user call log so that it doesn't get copied to the new demo user
        final Uri uri = CallLog.Calls.CONTENT_URI;
        try {
            resolver.delete(uri, null, null);
        } catch (Exception e) {
            Slog.w(TAG, "Deleting call log failed: " + e);
        }
    }

    void logSessionDuration() {
        final int sessionDuration;
        synchronized (mActivityLock) {
            sessionDuration = (int) ((mLastUserActivityTime - mFirstUserActivityTime) / 1000);
        }
        mInjector.logSessionDuration(sessionDuration);
    }

    private boolean isDeviceProvisioned() {
        return Settings.Global.getInt(
                mInjector.getContentResolver(), Settings.Global.DEVICE_PROVISIONED, 0) != 0;
    }

    /**
     * Deletes contents of {@link Environment#getDataPreloadsDirectory()},
     * but leave {@link Environment#getDataPreloadsFileCacheDirectory()}
     * @return true if contents was sucessfully deleted
     */
    private boolean deletePreloadsFolderContents() {
        final File dir = mInjector.getDataPreloadsDirectory();
        final File[] files = FileUtils.listFilesOrEmpty(dir);
        final File fileCacheDirectory = mInjector.getDataPreloadsFileCacheDirectory();
        Slog.i(TAG, "Deleting contents of " + dir);
        boolean success = true;
        for (File file : files) {
            if (file.isFile()) {
                if (!file.delete()) {
                    success = false;
                    Slog.w(TAG, "Cannot delete file " + file);
                }
            } else {
                // Do not remove file_cache dir
                if (!file.equals(fileCacheDirectory)) {
                    if (!FileUtils.deleteContentsAndDir(file)) {
                        success = false;
                        Slog.w(TAG, "Cannot delete dir and its content " + file);
                    }
                } else {
                    Slog.i(TAG, "Skipping directory with file cache " + file);
                }
            }
        }
        return success;
    }

    private void registerBroadcastReceiver() {
        if (mBroadcastReceiver != null) {
            return;
        }

        final IntentFilter filter = new IntentFilter();
        if (!mIsCarrierDemoMode) {
            filter.addAction(Intent.ACTION_SCREEN_OFF);
        }
        filter.addAction(ACTION_RESET_DEMO);
        mBroadcastReceiver = new IntentReceiver();
        getContext().registerReceiver(mBroadcastReceiver, filter);
    }

    private void unregisterBroadcastReceiver() {
        if (mBroadcastReceiver != null) {
            getContext().unregisterReceiver(mBroadcastReceiver);
            mBroadcastReceiver = null;
        }
    }

    private String[] getCameraIdsWithFlash() {
        ArrayList<String> cameraIdsList = new ArrayList<String>();
        final CameraManager cm = mInjector.getCameraManager();
        if (cm != null) {
            try {
                for (String cameraId : cm.getCameraIdList()) {
                    CameraCharacteristics c = cm.getCameraCharacteristics(cameraId);
                    if (Boolean.TRUE.equals(c.get(CameraCharacteristics.FLASH_INFO_AVAILABLE))) {
                        cameraIdsList.add(cameraId);
                    }
                }
            } catch (CameraAccessException e) {
                Slog.e(TAG, "Unable to access camera while getting camera id list", e);
            }
        }
        return cameraIdsList.toArray(new String[cameraIdsList.size()]);
    }

    private void muteVolumeStreams() {
        for (int stream : VOLUME_STREAMS_TO_MUTE) {
            mInjector.getAudioManager().setStreamVolume(stream,
                    mInjector.getAudioManager().getStreamMinVolume(stream), 0);
        }
    }

    private void startDemoMode() {
        mDeviceInDemoMode = true;

        mPreloadAppsInstaller = mInjector.getPreloadAppsInstaller();
        mInjector.initializeWakeLock();
        if (mCameraIdsWithFlash == null) {
            mCameraIdsWithFlash = getCameraIdsWithFlash();
        }
        registerBroadcastReceiver();

        final String carrierDemoModeSetting =
                getContext().getString(R.string.config_carrierDemoModeSetting);
        mIsCarrierDemoMode = !TextUtils.isEmpty(carrierDemoModeSetting)
                && (Settings.Secure.getInt(getContext().getContentResolver(),
                        carrierDemoModeSetting, 0) == 1);

        mInjector.systemPropertiesSet(SYSTEM_PROPERTY_RETAIL_DEMO_ENABLED, "1");
        mHandler.sendEmptyMessage(MSG_START_NEW_SESSION);

        mSafeBootRestrictionInitialState = mInjector.getUserManager().hasUserRestriction(
                UserManager.DISALLOW_SAFE_BOOT, UserHandle.SYSTEM);
        mPackageVerifierEnableInitialState = Settings.Global.getInt(mInjector.getContentResolver(),
                Settings.Global.PACKAGE_VERIFIER_ENABLE, 1);
    }

    private void stopDemoMode() {
        mPreloadAppsInstaller = null;
        mCameraIdsWithFlash = null;
        mInjector.destroyWakeLock();
        unregisterBroadcastReceiver();

        if (mDeviceInDemoMode) {
            mInjector.getUserManager().setUserRestriction(UserManager.DISALLOW_SAFE_BOOT,
                    mSafeBootRestrictionInitialState, UserHandle.SYSTEM);
            Settings.Global.putInt(mInjector.getContentResolver(),
                        Settings.Global.PACKAGE_VERIFIER_ENABLE,
                        mPackageVerifierEnableInitialState);
        }

        mDeviceInDemoMode = false;
        mIsCarrierDemoMode = false;
    }

    @Override
    public void onStart() {
        if (DEBUG) {
            Slog.d(TAG, "Service starting up");
        }
        mHandlerThread = new ServiceThread(TAG, android.os.Process.THREAD_PRIORITY_FOREGROUND,
                false);
        mHandlerThread.start();
        mHandler = new MainHandler(mHandlerThread.getLooper());
        mInjector.publishLocalService(this, mLocalService);
    }

    @Override
    public void onBootPhase(int bootPhase) {
        switch (bootPhase) {
            case PHASE_THIRD_PARTY_APPS_CAN_START:
                final SettingsObserver settingsObserver = new SettingsObserver(mHandler);
                settingsObserver.register();
                settingsObserver.refreshTimeoutConstants();
                break;
            case PHASE_BOOT_COMPLETED:
                if (UserManager.isDeviceInDemoMode(getContext())) {
                    startDemoMode();
                }
                break;
        }
    }

    @Override
    public void onSwitchUser(int userId) {
        if (!mDeviceInDemoMode) {
            return;
        }
        if (DEBUG) {
            Slog.d(TAG, "onSwitchUser: " + userId);
        }
        final UserInfo ui = mInjector.getUserManager().getUserInfo(userId);
        if (!ui.isDemo()) {
            Slog.wtf(TAG, "Should not allow switch to non-demo user in demo mode");
            return;
        }
        if (!mIsCarrierDemoMode && !mInjector.isWakeLockHeld()) {
            mInjector.acquireWakeLock();
        }
        mCurrentUserId = userId;
        mInjector.getActivityManagerInternal().updatePersistentConfigurationForUser(
                mInjector.getSystemUsersConfiguration(), userId);

        mInjector.turnOffAllFlashLights(mCameraIdsWithFlash);
        muteVolumeStreams();
        if (!mInjector.getWifiManager().isWifiEnabled()) {
            mInjector.getWifiManager().setWifiEnabled(true);
        }

        // Disable lock screen for demo users.
        mInjector.getLockPatternUtils().setLockScreenDisabled(true, userId);

        if (!mIsCarrierDemoMode) {
            // Show reset notification (except in carrier demo mode).
            mInjector.getNotificationManager().notifyAsUser(TAG, SystemMessage.NOTE_RETAIL_RESET,
                    mInjector.createResetNotification(), UserHandle.of(userId));

            synchronized (mActivityLock) {
                mUserUntouched = true;
            }
            mInjector.logSessionCount(1);
            mHandler.removeMessages(MSG_INACTIVITY_TIME_OUT);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    mPreloadAppsInstaller.installApps(userId);
                }
            });
        }
    }

    private RetailDemoModeServiceInternal mLocalService = new RetailDemoModeServiceInternal() {
        private static final long USER_ACTIVITY_DEBOUNCE_TIME = 2000;

        @Override
        public void onUserActivity() {
            if (!mDeviceInDemoMode || mIsCarrierDemoMode) {
                return;
            }
            long timeOfActivity = SystemClock.uptimeMillis();
            synchronized (mActivityLock) {
                if (timeOfActivity < mLastUserActivityTime + USER_ACTIVITY_DEBOUNCE_TIME) {
                    return;
                }
                mLastUserActivityTime = timeOfActivity;
                if (mUserUntouched && isDemoLauncherDisabled()) {
                    Slog.d(TAG, "retail_demo first touch");
                    mUserUntouched = false;
                    mFirstUserActivityTime = timeOfActivity;
                }
            }
            mHandler.removeMessages(MSG_INACTIVITY_TIME_OUT);
            mHandler.sendEmptyMessageDelayed(MSG_INACTIVITY_TIME_OUT, mUserInactivityTimeout);
        }
    };

    static class Injector {
        private Context mContext;
        private UserManager mUm;
        private PackageManager mPm;
        private NotificationManager mNm;
        private ActivityManagerService mAms;
        private ActivityManagerInternal mAmi;
        private AudioManager mAudioManager;
        private PowerManager mPowerManager;
        private CameraManager mCameraManager;
        private PowerManager.WakeLock mWakeLock;
        private WifiManager mWifiManager;
        private Configuration mSystemUserConfiguration;
        private PendingIntent mResetDemoPendingIntent;
        private PreloadAppsInstaller mPreloadAppsInstaller;

        Injector(Context context) {
            mContext = context;
        }

        Context getContext() {
            return mContext;
        }

        WifiManager getWifiManager() {
            if (mWifiManager == null) {
                mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
            }
            return mWifiManager;
        }

        UserManager getUserManager() {
            if (mUm == null) {
                mUm = getContext().getSystemService(UserManager.class);
            }
            return mUm;
        }

        void switchUser(int userId) {
            if (mAms == null) {
                mAms = (ActivityManagerService) ActivityManager.getService();
            }
            mAms.switchUser(userId);
        }

        AudioManager getAudioManager() {
            if (mAudioManager == null) {
                mAudioManager = getContext().getSystemService(AudioManager.class);
            }
            return mAudioManager;
        }

        private PowerManager getPowerManager() {
            if (mPowerManager == null) {
                mPowerManager = (PowerManager) getContext().getSystemService(
                        Context.POWER_SERVICE);
            }
            return mPowerManager;
        }

        NotificationManager getNotificationManager() {
            if (mNm == null) {
                mNm = NotificationManager.from(getContext());
            }
            return mNm;
        }

        ActivityManagerInternal getActivityManagerInternal() {
            if (mAmi == null) {
                mAmi = LocalServices.getService(ActivityManagerInternal.class);
            }
            return mAmi;
        }

        CameraManager getCameraManager() {
            if (mCameraManager == null) {
                mCameraManager = (CameraManager) getContext().getSystemService(
                        Context.CAMERA_SERVICE);
            }
            return mCameraManager;
        }

        PackageManager getPackageManager() {
            if (mPm == null) {
                mPm = getContext().getPackageManager();
            }
            return mPm;
        }

        IPackageManager getIPackageManager() {
            return AppGlobals.getPackageManager();
        }

        ContentResolver getContentResolver() {
            return getContext().getContentResolver();
        }

        PreloadAppsInstaller getPreloadAppsInstaller() {
            if (mPreloadAppsInstaller == null) {
                mPreloadAppsInstaller = new PreloadAppsInstaller(getContext());
            }
            return mPreloadAppsInstaller;
        }

        void systemPropertiesSet(String key, String value) {
            SystemProperties.set(key, value);
        }

        void turnOffAllFlashLights(String[] cameraIdsWithFlash) {
            for (String cameraId : cameraIdsWithFlash) {
                try {
                    getCameraManager().setTorchMode(cameraId, false);
                } catch (CameraAccessException e) {
                    Slog.e(TAG, "Unable to access camera " + cameraId
                            + " while turning off flash", e);
                }
            }
        }

        void initializeWakeLock() {
            if (mWakeLock == null) {
                mWakeLock = getPowerManager().newWakeLock(
                        PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, TAG);
            }
        }

        void destroyWakeLock() {
            mWakeLock = null;
        }

        boolean isWakeLockHeld() {
            return mWakeLock != null && mWakeLock.isHeld();
        }

        void acquireWakeLock() {
            mWakeLock.acquire();
        }

        void releaseWakeLock() {
            mWakeLock.release();
        }

        void logSessionDuration(int duration) {
            MetricsLogger.histogram(getContext(), DEMO_SESSION_DURATION, duration);
        }

        void logSessionCount(int count) {
            MetricsLogger.count(getContext(), DEMO_SESSION_COUNT, count);
        }

        Configuration getSystemUsersConfiguration() {
            if (mSystemUserConfiguration == null) {
                Settings.System.getConfiguration(getContentResolver(),
                        mSystemUserConfiguration = new Configuration());
            }
            return mSystemUserConfiguration;
        }

        LockPatternUtils getLockPatternUtils() {
            return new LockPatternUtils(getContext());
        }

        Notification createResetNotification() {
            return new Notification.Builder(getContext(), SystemNotificationChannels.RETAIL_MODE)
                    .setContentTitle(getContext().getString(R.string.reset_retail_demo_mode_title))
                    .setContentText(getContext().getString(R.string.reset_retail_demo_mode_text))
                    .setOngoing(true)
                    .setSmallIcon(R.drawable.platlogo)
                    .setShowWhen(false)
                    .setVisibility(Notification.VISIBILITY_PUBLIC)
                    .setContentIntent(getResetDemoPendingIntent())
                    .setColor(getContext().getColor(R.color.system_notification_accent_color))
                    .build();
        }

        private PendingIntent getResetDemoPendingIntent() {
            if (mResetDemoPendingIntent == null) {
                Intent intent = new Intent(ACTION_RESET_DEMO);
                mResetDemoPendingIntent = PendingIntent.getBroadcast(getContext(), 0, intent, 0);
            }
            return mResetDemoPendingIntent;
        }

        File getDataPreloadsDirectory() {
            return Environment.getDataPreloadsDirectory();
        }

        File getDataPreloadsFileCacheDirectory() {
            return Environment.getDataPreloadsFileCacheDirectory();
        }

        void publishLocalService(RetailDemoModeService service,
                RetailDemoModeServiceInternal localService) {
            service.publishLocalService(RetailDemoModeServiceInternal.class, localService);
        }
    }
}