From 705442fa7dcbf1bf92595fdaca6cc888810931d8 Mon Sep 17 00:00:00 2001 From: Selim Cinek Date: Tue, 13 Sep 2016 16:02:33 -0700 Subject: [PATCH] Added Emergency affordance feature Added a service that listens whether emergency affordances are necessary. If the they are needed, it adds an option to the global actions dialog that directly launches the emergency call and also adds a long-press listener to the keyguard emergency button. Test: adb shell settings put global force_emergency_affordance 1 && adb shell settings put global emergency_affordance_number 111112 Fixes: 30404490 Change-Id: Ib96a15da2ef4b568a8d77140ebca6aa6f20f5ddb --- core/java/android/provider/Settings.java | 8 +- .../policy/EmergencyAffordanceManager.java | 101 ++++++ core/res/res/drawable/emergency_icon.xml | 40 +++ core/res/res/values/config.xml | 10 + core/res/res/values/strings.xml | 3 + core/res/res/values/symbols.xml | 6 + .../com/android/keyguard/EmergencyButton.java | 43 +++ .../emergency/EmergencyAffordanceService.java | 312 ++++++++++++++++++ .../android/server/policy/GlobalActions.java | 29 +- .../java/com/android/server/SystemServer.java | 9 +- 10 files changed, 557 insertions(+), 4 deletions(-) create mode 100644 core/java/com/android/internal/policy/EmergencyAffordanceManager.java create mode 100644 core/res/res/drawable/emergency_icon.xml create mode 100644 services/core/java/com/android/server/emergency/EmergencyAffordanceService.java diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java index 79f11513e7989..6b7ccac116fee 100755 --- a/core/java/android/provider/Settings.java +++ b/core/java/android/provider/Settings.java @@ -44,7 +44,6 @@ import android.net.ConnectivityManager; import android.net.Uri; import android.net.wifi.WifiManager; import android.os.BatteryManager; -import android.os.Binder; import android.os.Bundle; import android.os.DropBoxManager; import android.os.IBinder; @@ -8306,6 +8305,13 @@ public final class Settings { */ public static final String CALL_AUTO_RETRY = "call_auto_retry"; + /** + * A setting that can be read whether the emergency affordance is currently needed. + * The value is a boolean (1 or 0). + * @hide + */ + public static final String EMERGENCY_AFFORDANCE_NEEDED = "emergency_affordance_needed"; + /** * See RIL_PreferredNetworkType in ril.h * @hide diff --git a/core/java/com/android/internal/policy/EmergencyAffordanceManager.java b/core/java/com/android/internal/policy/EmergencyAffordanceManager.java new file mode 100644 index 0000000000000..bed7c1ba4ed3e --- /dev/null +++ b/core/java/com/android/internal/policy/EmergencyAffordanceManager.java @@ -0,0 +1,101 @@ +/* + * 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.internal.policy; + +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.Build; +import android.provider.Settings; + +/** + * A class that manages emergency affordances and enables immediate calling to emergency services + */ +public class EmergencyAffordanceManager { + + public static final boolean ENABLED = true; + + /** + * Global setting override with the number to call with the emergency affordance. + * @hide + */ + private static final String EMERGENCY_CALL_NUMBER_SETTING = "emergency_affordance_number"; + + /** + * Global setting, whether the emergency affordance should be shown regardless of device state. + * The value is a boolean (1 or 0). + * @hide + */ + private static final String FORCE_EMERGENCY_AFFORDANCE_SETTING = "force_emergency_affordance"; + + private final Context mContext; + + public EmergencyAffordanceManager(Context context) { + mContext = context; + } + + /** + * perform an emergency call. + */ + public final void performEmergencyCall() { + performEmergencyCall(mContext); + } + + private static Uri getPhoneUri(Context context) { + String number = context.getResources().getString( + com.android.internal.R.string.config_emergency_call_number); + if (Build.IS_DEBUGGABLE) { + String override = Settings.Global.getString( + context.getContentResolver(), EMERGENCY_CALL_NUMBER_SETTING); + if (override != null) { + number = override; + } + } + return Uri.fromParts("tel", number, null); + } + + private static void performEmergencyCall(Context context) { + Intent intent = new Intent(Intent.ACTION_CALL_EMERGENCY); + intent.setData(getPhoneUri(context)); + intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + context.startActivity(intent); + } + + /** + * @return whether emergency affordance should be active. + */ + public boolean needsEmergencyAffordance() { + if (!ENABLED) { + return false; + } + if (forceShowing()) { + return true; + } + return isEmergencyAffordanceNeeded(); + } + + private boolean isEmergencyAffordanceNeeded() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.EMERGENCY_AFFORDANCE_NEEDED, 0) != 0; + } + + + private boolean forceShowing() { + return Settings.Global.getInt(mContext.getContentResolver(), + FORCE_EMERGENCY_AFFORDANCE_SETTING, 0) != 0; + } +} diff --git a/core/res/res/drawable/emergency_icon.xml b/core/res/res/drawable/emergency_icon.xml new file mode 100644 index 0000000000000..b2ffa2b4481c7 --- /dev/null +++ b/core/res/res/drawable/emergency_icon.xml @@ -0,0 +1,40 @@ + + + + + + + + + diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml index 004b31f3a3ae7..c45452b493be1 100644 --- a/core/res/res/values/config.xml +++ b/core/res/res/values/config.xml @@ -2521,6 +2521,16 @@ false + + 112 + + + + 404 + 405 + + diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml index 39f20c2f5aa93..af21f9202edf2 100644 --- a/core/res/res/values/strings.xml +++ b/core/res/res/values/strings.xml @@ -486,6 +486,9 @@ @string/sim_restart_button + + Emergency + Bug report diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml index 39127a43f0a30..90f9396b0172a 100644 --- a/core/res/res/values/symbols.xml +++ b/core/res/res/values/symbols.xml @@ -2663,6 +2663,10 @@ + + + + @@ -2699,5 +2703,7 @@ + + diff --git a/packages/Keyguard/src/com/android/keyguard/EmergencyButton.java b/packages/Keyguard/src/com/android/keyguard/EmergencyButton.java index 8d411453b5ae1..0474df7bd89cb 100644 --- a/packages/Keyguard/src/com/android/keyguard/EmergencyButton.java +++ b/packages/Keyguard/src/com/android/keyguard/EmergencyButton.java @@ -28,13 +28,16 @@ import android.os.UserHandle; import android.telecom.TelecomManager; import android.util.AttributeSet; import android.util.Slog; +import android.view.MotionEvent; import android.view.View; +import android.view.ViewConfiguration; import android.widget.Button; import com.android.internal.logging.MetricsLogger; import com.android.internal.logging.MetricsProto.MetricsEvent; import com.android.internal.telephony.IccCardConstants.State; import com.android.internal.widget.LockPatternUtils; +import com.android.internal.policy.EmergencyAffordanceManager; /** * This class implements a smart emergency button that updates itself based @@ -51,7 +54,10 @@ public class EmergencyButton extends Button { | Intent.FLAG_ACTIVITY_CLEAR_TOP); private static final String LOG_TAG = "EmergencyButton"; + private final EmergencyAffordanceManager mEmergencyAffordanceManager; + private int mDownX; + private int mDownY; KeyguardUpdateMonitorCallback mInfoCallback = new KeyguardUpdateMonitorCallback() { @Override @@ -64,6 +70,7 @@ public class EmergencyButton extends Button { updateEmergencyCallButton(); } }; + private boolean mLongPressWasDragged; public interface EmergencyButtonCallback { public void onEmergencyButtonClickedWhenInCall(); @@ -86,6 +93,7 @@ public class EmergencyButton extends Button { com.android.internal.R.bool.config_voice_capable); mEnableEmergencyCallWhileSimLocked = mContext.getResources().getBoolean( com.android.internal.R.bool.config_enable_emergency_call_while_sim_locked); + mEmergencyAffordanceManager = new EmergencyAffordanceManager(context); } @Override @@ -110,9 +118,44 @@ public class EmergencyButton extends Button { takeEmergencyCallAction(); } }); + setOnLongClickListener(new OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + if (!mLongPressWasDragged + && mEmergencyAffordanceManager.needsEmergencyAffordance()) { + mEmergencyAffordanceManager.performEmergencyCall(); + return true; + } + return false; + } + }); updateEmergencyCallButton(); } + @Override + public boolean onTouchEvent(MotionEvent event) { + final int x = (int) event.getX(); + final int y = (int) event.getY(); + if (event.getActionMasked() == MotionEvent.ACTION_DOWN) { + mDownX = x; + mDownY = y; + mLongPressWasDragged = false; + } else { + final int xDiff = Math.abs(x - mDownX); + final int yDiff = Math.abs(y - mDownY); + int touchSlop = ViewConfiguration.get(mContext).getScaledTouchSlop(); + if (Math.abs(yDiff) > touchSlop || Math.abs(xDiff) > touchSlop) { + mLongPressWasDragged = true; + } + } + return super.onTouchEvent(event); + } + + @Override + public boolean performLongClick() { + return super.performLongClick(); + } + @Override protected void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); diff --git a/services/core/java/com/android/server/emergency/EmergencyAffordanceService.java b/services/core/java/com/android/server/emergency/EmergencyAffordanceService.java new file mode 100644 index 0000000000000..cca9f10c630bd --- /dev/null +++ b/services/core/java/com/android/server/emergency/EmergencyAffordanceService.java @@ -0,0 +1,312 @@ +/* + * 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.emergency; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings; +import android.telephony.CellInfo; +import android.telephony.CellInfoGsm; +import android.telephony.CellInfoLte; +import android.telephony.CellInfoWcdma; +import android.telephony.CellLocation; +import android.telephony.PhoneStateListener; +import android.telephony.SubscriptionInfo; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import com.android.server.SystemService; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * A service that listens to connectivity and SIM card changes and determines if the emergency mode + * should be enabled + */ +public class EmergencyAffordanceService extends SystemService { + + private static final String TAG = "EmergencyAffordanceService"; + + private static final int NUM_SCANS_UNTIL_ABORT = 4; + + private static final int INITIALIZE_STATE = 1; + private static final int CELL_INFO_STATE_CHANGED = 2; + private static final int SUBSCRIPTION_CHANGED = 3; + + /** + * Global setting, whether the last scan of the sim cards reveal that a sim was inserted that + * requires the emergency affordance. The value is a boolean (1 or 0). + * @hide + */ + private static final String EMERGENCY_SIM_INSERTED_SETTING = "emergency_sim_inserted_before"; + + private final Context mContext; + private final ArrayList mEmergencyCallMccNumbers; + + private final Object mLock = new Object(); + + private TelephonyManager mTelephonyManager; + private SubscriptionManager mSubscriptionManager; + private boolean mEmergencyAffordanceNeeded; + private MyHandler mHandler; + private int mScansCompleted; + private PhoneStateListener mPhoneStateListener = new PhoneStateListener() { + @Override + public void onCellInfoChanged(List cellInfo) { + if (!isEmergencyAffordanceNeeded()) { + requestCellScan(); + } + } + + @Override + public void onCellLocationChanged(CellLocation location) { + if (!isEmergencyAffordanceNeeded()) { + requestCellScan(); + } + } + }; + private BroadcastReceiver mAirplaneModeReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + if (Settings.Global.getInt(context.getContentResolver(), + Settings.Global.AIRPLANE_MODE_ON, 0) == 0) { + startScanning(); + requestCellScan(); + } + } + }; + private boolean mSimNeedsEmergencyAffordance; + private boolean mNetworkNeedsEmergencyAffordance; + + private void requestCellScan() { + mHandler.obtainMessage(CELL_INFO_STATE_CHANGED).sendToTarget(); + } + + private SubscriptionManager.OnSubscriptionsChangedListener mSubscriptionChangedListener + = new SubscriptionManager.OnSubscriptionsChangedListener() { + @Override + public void onSubscriptionsChanged() { + mHandler.obtainMessage(SUBSCRIPTION_CHANGED).sendToTarget(); + } + }; + + public EmergencyAffordanceService(Context context) { + super(context); + mContext = context; + int[] numbers = context.getResources().getIntArray( + com.android.internal.R.array.config_emergency_mcc_codes); + mEmergencyCallMccNumbers = new ArrayList<>(numbers.length); + for (int i = 0; i < numbers.length; i++) { + mEmergencyCallMccNumbers.add(numbers[i]); + } + } + + private void updateEmergencyAffordanceNeeded() { + synchronized (mLock) { + mEmergencyAffordanceNeeded = mSimNeedsEmergencyAffordance || + mNetworkNeedsEmergencyAffordance; + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.EMERGENCY_AFFORDANCE_NEEDED, + mEmergencyAffordanceNeeded ? 1 : 0); + if (mEmergencyAffordanceNeeded) { + stopScanning(); + } + } + } + + private void stopScanning() { + synchronized (mLock) { + mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); + mScansCompleted = 0; + } + } + + private boolean isEmergencyAffordanceNeeded() { + synchronized (mLock) { + return mEmergencyAffordanceNeeded; + } + } + + @Override + public void onStart() { + } + + @Override + public void onBootPhase(int phase) { + if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) { + mTelephonyManager = mContext.getSystemService(TelephonyManager.class); + mSubscriptionManager = SubscriptionManager.from(mContext); + HandlerThread thread = new HandlerThread(TAG); + thread.start(); + mHandler = new MyHandler(thread.getLooper()); + mHandler.obtainMessage(INITIALIZE_STATE).sendToTarget(); + startScanning(); + IntentFilter filter = new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED); + mContext.registerReceiver(mAirplaneModeReceiver, filter); + mSubscriptionManager.addOnSubscriptionsChangedListener(mSubscriptionChangedListener); + } + } + + private void startScanning() { + mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CELL_INFO + | PhoneStateListener.LISTEN_CELL_LOCATION); + } + + /** Handler to do the heavier work on */ + private class MyHandler extends Handler { + + public MyHandler(Looper l) { + super(l); + } + + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case INITIALIZE_STATE: + handleInitializeState(); + break; + case CELL_INFO_STATE_CHANGED: + handleUpdateCellInfo(); + break; + case SUBSCRIPTION_CHANGED: + handleUpdateSimSubscriptionInfo(); + break; + } + } + } + + private void handleInitializeState() { + if (handleUpdateSimSubscriptionInfo()) { + return; + } + if (handleUpdateCellInfo()) { + return; + } + updateEmergencyAffordanceNeeded(); + } + + private boolean handleUpdateSimSubscriptionInfo() { + boolean neededBefore = simNeededAffordanceBefore(); + boolean neededNow = neededBefore; + List activeSubscriptionInfoList = + mSubscriptionManager.getActiveSubscriptionInfoList(); + if (activeSubscriptionInfoList == null) { + return neededNow; + } + for (SubscriptionInfo info : activeSubscriptionInfoList) { + int mcc = info.getMcc(); + if (mccRequiresEmergencyAffordance(mcc)) { + neededNow = true; + break; + } else if (mcc != 0 && mcc != Integer.MAX_VALUE){ + // a Sim with a different mcc code was found + neededNow = false; + } + String simOperator = mTelephonyManager.getSimOperator(info.getSubscriptionId()); + mcc = 0; + if (simOperator != null && simOperator.length() >= 3) { + mcc = Integer.parseInt(simOperator.substring(0, 3)); + } + if (mcc != 0) { + if (mccRequiresEmergencyAffordance(mcc)) { + neededNow = true; + break; + } else { + // a Sim with a different mcc code was found + neededNow = false; + } + } + } + if (neededNow != neededBefore) { + setSimNeedsEmergencyAffordance(neededNow); + } + return neededNow; + } + + private void setSimNeedsEmergencyAffordance(boolean simNeedsEmergencyAffordance) { + mSimNeedsEmergencyAffordance = simNeedsEmergencyAffordance; + Settings.Global.putInt(mContext.getContentResolver(), + EMERGENCY_SIM_INSERTED_SETTING, + simNeedsEmergencyAffordance ? 1 : 0); + updateEmergencyAffordanceNeeded(); + } + + private boolean simNeededAffordanceBefore() { + return Settings.Global.getInt(mContext.getContentResolver(), + "emergency_sim_inserted_before", 0) != 0; + } + + private boolean handleUpdateCellInfo() { + List cellInfos = mTelephonyManager.getAllCellInfo(); + if (cellInfos == null) { + return false; + } + boolean stopScanningAfterScan = false; + for (CellInfo cellInfo : cellInfos) { + int mcc = 0; + if (cellInfo instanceof CellInfoGsm) { + mcc = ((CellInfoGsm) cellInfo).getCellIdentity().getMcc(); + } else if (cellInfo instanceof CellInfoLte) { + mcc = ((CellInfoLte) cellInfo).getCellIdentity().getMcc(); + } else if (cellInfo instanceof CellInfoWcdma) { + mcc = ((CellInfoWcdma) cellInfo).getCellIdentity().getMcc(); + } + if (mccRequiresEmergencyAffordance(mcc)) { + setNetworkNeedsEmergencyAffordance(true); + return true; + } else if (mcc != 0 && mcc != Integer.MAX_VALUE) { + // we found an mcc that isn't in the list, abort + stopScanningAfterScan = true; + } + } + if (stopScanningAfterScan) { + stopScanning(); + } else { + onCellScanFinishedUnsuccessful(); + } + setNetworkNeedsEmergencyAffordance(false); + return false; + } + + private void setNetworkNeedsEmergencyAffordance(boolean needsAffordance) { + synchronized (mLock) { + mNetworkNeedsEmergencyAffordance = needsAffordance; + updateEmergencyAffordanceNeeded(); + } + } + + private void onCellScanFinishedUnsuccessful() { + synchronized (mLock) { + mScansCompleted++; + if (mScansCompleted >= NUM_SCANS_UNTIL_ABORT) { + stopScanning(); + } + } + } + + private boolean mccRequiresEmergencyAffordance(int mcc) { + return mEmergencyCallMccNumbers.contains(mcc); + } +} diff --git a/services/core/java/com/android/server/policy/GlobalActions.java b/services/core/java/com/android/server/policy/GlobalActions.java index bb91f76ecf30a..a8bd4d289616d 100644 --- a/services/core/java/com/android/server/policy/GlobalActions.java +++ b/services/core/java/com/android/server/policy/GlobalActions.java @@ -20,6 +20,7 @@ import com.android.internal.app.AlertController; import com.android.internal.app.AlertController.AlertParams; import com.android.internal.logging.MetricsLogger; import com.android.internal.logging.MetricsProto.MetricsEvent; +import com.android.internal.policy.EmergencyAffordanceManager; import com.android.internal.telephony.TelephonyIntents; import com.android.internal.telephony.TelephonyProperties; import com.android.internal.R; @@ -27,7 +28,6 @@ import com.android.internal.widget.LockPatternUtils; import android.app.ActivityManager; import android.app.ActivityManagerNative; -import android.app.AlertDialog; import android.app.Dialog; import android.content.BroadcastReceiver; import android.content.Context; @@ -125,6 +125,7 @@ class GlobalActions implements DialogInterface.OnDismissListener, DialogInterfac private boolean mHasTelephony; private boolean mHasVibrator; private final boolean mShowSilentToggle; + private final EmergencyAffordanceManager mEmergencyAffordanceManager; /** * @param context everything needs a context :( @@ -159,6 +160,8 @@ class GlobalActions implements DialogInterface.OnDismissListener, DialogInterfac mShowSilentToggle = SHOW_SILENT_TOGGLE && !mContext.getResources().getBoolean( com.android.internal.R.bool.config_useFixedVolume); + + mEmergencyAffordanceManager = new EmergencyAffordanceManager(context); } /** @@ -308,6 +311,10 @@ class GlobalActions implements DialogInterface.OnDismissListener, DialogInterfac addedKeys.add(actionKey); } + if (mEmergencyAffordanceManager.needsEmergencyAffordance()) { + mItems.add(getEmergencyAction()); + } + mAdapter = new MyAdapter(); AlertParams params = new AlertParams(mContext); @@ -493,6 +500,26 @@ class GlobalActions implements DialogInterface.OnDismissListener, DialogInterfac }; } + private Action getEmergencyAction() { + return new SinglePressAction(com.android.internal.R.drawable.emergency_icon, + R.string.global_action_emergency) { + @Override + public void onPress() { + mEmergencyAffordanceManager.performEmergencyCall(); + } + + @Override + public boolean showDuringKeyguard() { + return true; + } + + @Override + public boolean showBeforeProvisioning() { + return true; + } + }; + } + private Action getAssistAction() { return new SinglePressAction(com.android.internal.R.drawable.ic_action_assist_focused, R.string.global_action_assist) { diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java index 97a829ecac462..a18d5e9c569f5 100644 --- a/services/java/com/android/server/SystemServer.java +++ b/services/java/com/android/server/SystemServer.java @@ -16,7 +16,6 @@ package com.android.server; -import android.app.ActivityManagerNative; import android.app.ActivityThread; import android.app.INotificationManager; import android.app.usage.UsageStatsManagerInternal; @@ -32,7 +31,6 @@ import android.os.Build; import android.os.Environment; import android.os.FactoryTest; import android.os.FileUtils; -import android.os.IPowerManager; import android.os.Looper; import android.os.PowerManager; import android.os.RemoteException; @@ -55,6 +53,7 @@ import com.android.internal.app.NightDisplayController; import com.android.internal.os.BinderInternal; import com.android.internal.os.SamplingProfilerIntegration; import com.android.internal.os.ZygoteInit; +import com.android.internal.policy.EmergencyAffordanceManager; import com.android.internal.widget.ILockSettings; import com.android.server.accessibility.AccessibilityManagerService; import com.android.server.am.ActivityManagerService; @@ -66,6 +65,7 @@ import com.android.server.devicepolicy.DevicePolicyManagerService; import com.android.server.display.DisplayManagerService; import com.android.server.display.NightDisplayService; import com.android.server.dreams.DreamManagerService; +import com.android.server.emergency.EmergencyAffordanceService; import com.android.server.fingerprint.FingerprintService; import com.android.server.hdmi.HdmiControlService; import com.android.server.input.InputManagerService; @@ -1080,6 +1080,11 @@ public final class SystemServer { Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER); } + if (!disableNetwork && !disableNonCoreServices && EmergencyAffordanceManager.ENABLED) { + // EmergencyMode sevice + mSystemServiceManager.startService(EmergencyAffordanceService.class); + } + if (!disableNonCoreServices) { // Dreams (interactive idle-time views, a/k/a screen savers, and doze mode) mSystemServiceManager.startService(DreamManagerService.class);