src.com.android.internal.car.CarServiceHelperService Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2017 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.car;
import android.app.ActivityManager;
import android.app.IActivityManager;
import android.app.admin.DevicePolicyManager;
import android.car.userlib.CarUserManagerHelper;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.UserInfo;
import android.hidl.manager.V1_0.IServiceManager;
import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.Process;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemProperties;
import android.os.Trace;
import android.os.UserHandle;
import android.util.Slog;
import android.util.TimingsTraceLog;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.server.SystemService;
import com.android.server.Watchdog;
import com.android.server.am.ActivityManagerService;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* System service side companion service for CarService.
* Starts car service and provide necessary API for CarService. Only for car product.
*/
public class CarServiceHelperService extends SystemService {
// Place holder for user name of the first user created.
private static final String TAG = "CarServiceHelper";
private static final boolean DBG = true;
private static final String CAR_SERVICE_INTERFACE = "android.car.ICar";
// These numbers should match with binder call order of
// packages/services/Car/car-lib/src/android/car/ICar.aidl
private static final int ICAR_CALL_SET_CAR_SERVICE_HELPER = 0;
private static final int ICAR_CALL_SET_USER_UNLOCK_STATUS = 1;
private static final int ICAR_CALL_SET_SWITCH_USER = 2;
private static final String PROP_RESTART_RUNTIME = "ro.car.recovery.restart_runtime.enabled";
private static final List CAR_HAL_INTERFACES_OF_INTEREST = Arrays.asList(
"[email protected]::IVehicle",
"[email protected]::IAudioControl"
);
@GuardedBy("mLock")
private int mLastSwitchedUser = UserHandle.USER_NULL;
private final ICarServiceHelperImpl mHelper = new ICarServiceHelperImpl();
private final Context mContext;
private final Object mLock = new Object();
@GuardedBy("mLock")
private IBinder mCarService;
@GuardedBy("mLock")
private boolean mSystemBootCompleted;
@GuardedBy("mLock")
private final HashMap mUserUnlockedStatus = new HashMap<>();
private final CarUserManagerHelper mCarUserManagerHelper;
private final ServiceConnection mCarServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
if (DBG) {
Slog.d(TAG, "onServiceConnected:" + iBinder);
}
handleCarServiceConnection(iBinder);
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
handleCarServiceCrash();
}
};
public CarServiceHelperService(Context context) {
this(context, new CarUserManagerHelper(context));
}
@VisibleForTesting
CarServiceHelperService(Context context, CarUserManagerHelper carUserManagerHelper) {
super(context);
mContext = context;
mCarUserManagerHelper = carUserManagerHelper;
}
@Override
public void onBootPhase(int phase) {
if (DBG) {
Slog.d(TAG, "onBootPhase:" + phase);
}
if (phase == SystemService.PHASE_THIRD_PARTY_APPS_CAN_START) {
checkForCarServiceConnection();
// TODO(b/126199560) Consider doing this earlier in onStart().
// Other than onStart, PHASE_THIRD_PARTY_APPS_CAN_START is the earliest timing.
setupAndStartUsers();
checkForCarServiceConnection();
} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
boolean shouldNotify = false;
synchronized (mLock) {
mSystemBootCompleted = true;
if (mCarService != null) {
shouldNotify = true;
}
}
if (shouldNotify) {
notifyAllUnlockedUsers();
}
}
}
@Override
public void onStart() {
Intent intent = new Intent();
intent.setPackage("com.android.car");
intent.setAction(CAR_SERVICE_INTERFACE);
if (!getContext().bindServiceAsUser(intent, mCarServiceConnection, Context.BIND_AUTO_CREATE,
UserHandle.SYSTEM)) {
Slog.wtf(TAG, "cannot start car service");
}
System.loadLibrary("car-framework-service-jni");
}
@Override
public void onUnlockUser(int userHandle) {
handleUserLockStatusChange(userHandle, true);
if (DBG) {
Slog.d(TAG, "User" + userHandle + " unlocked");
}
}
@Override
public void onStopUser(int userHandle) {
handleUserLockStatusChange(userHandle, false);
}
@Override
public void onCleanupUser(int userHandle) {
handleUserLockStatusChange(userHandle, false);
}
@Override
public void onSwitchUser(int userHandle) {
synchronized (mLock) {
mLastSwitchedUser = userHandle;
if (mCarService == null) {
return; // The event will be delivered upon CarService connection.
}
}
sendSwitchUserBindercall(userHandle);
}
// Sometimes car service onConnected call is delayed a lot. car service binder can be
// found from ServiceManager directly. So do some polling during boot-up to connect to
// car service ASAP.
private void checkForCarServiceConnection() {
synchronized (mLock) {
if (mCarService != null) {
return;
}
}
IBinder iBinder = ServiceManager.checkService("car_service");
if (iBinder != null) {
if (DBG) {
Slog.d(TAG, "Car service found through ServiceManager:" + iBinder);
}
handleCarServiceConnection(iBinder);
}
}
private void handleCarServiceConnection(IBinder iBinder) {
int lastSwitchedUser;
boolean systemBootCompleted;
synchronized (mLock) {
if (mCarService == iBinder) {
return; // already connected.
}
if (mCarService != null) {
Slog.i(TAG, "car service binder changed, was:" + mCarService
+ " new:" + iBinder);
}
mCarService = iBinder;
lastSwitchedUser = mLastSwitchedUser;
systemBootCompleted = mSystemBootCompleted;
}
Slog.i(TAG, "**CarService connected**");
sendSetCarServiceHelperBinderCall();
if (systemBootCompleted) {
notifyAllUnlockedUsers();
}
if (lastSwitchedUser != UserHandle.USER_NULL) {
sendSwitchUserBindercall(lastSwitchedUser);
}
}
private void handleUserLockStatusChange(int userHandle, boolean unlocked) {
boolean shouldNotify = false;
synchronized (mLock) {
Boolean oldStatus = mUserUnlockedStatus.get(userHandle);
if (oldStatus == null || oldStatus != unlocked) {
mUserUnlockedStatus.put(userHandle, unlocked);
if (mCarService != null && mSystemBootCompleted) {
shouldNotify = true;
}
}
}
if (shouldNotify) {
sendSetUserLockStatusBinderCall(userHandle, unlocked);
}
}
private void setupAndStartUsers() {
DevicePolicyManager devicePolicyManager =
mContext.getSystemService(DevicePolicyManager.class);
if (devicePolicyManager != null && devicePolicyManager.getUserProvisioningState()
!= DevicePolicyManager.STATE_USER_UNMANAGED) {
Slog.i(TAG, "DevicePolicyManager active, skip user unlock/switch");
return;
}
// Offloading the whole unlock into separate thread did not help due to single locks
// used in AMS / PMS ended up stopping the world with lots of lock contention.
// To run these in background, there should be some improvements there.
int targetUserId = UserHandle.USER_SYSTEM;
if (mCarUserManagerHelper.getAllUsers().size() == 0) {
Slog.i(TAG, "Create new admin user and switch");
// On very first boot, create an admin user and switch to that user.
UserInfo admin = mCarUserManagerHelper.createNewAdminUser();
if (admin == null) {
Slog.e(TAG, "cannot create admin user");
return;
}
targetUserId = admin.id;
} else {
Slog.i(TAG, "Switch to default user");
targetUserId = mCarUserManagerHelper.getInitialUser();
}
// If system user is the only user to unlock, handle it when system completes the boot.
if (targetUserId == UserHandle.USER_SYSTEM) {
return;
}
IActivityManager am = ActivityManager.getService();
if (am == null) {
Slog.wtf(TAG, "cannot get ActivityManagerService");
return;
}
TimingsTraceLog traceLog = new TimingsTraceLog("SystemServerTiming",
Trace.TRACE_TAG_SYSTEM_SERVER);
traceLog.traceBegin("User0Unlock");
try {
// This is for force changing state into RUNNING_LOCKED. Otherwise unlock does not
// update the state and user 0 unlock happens twice.
if (!am.startUserInBackground(UserHandle.USER_SYSTEM)) {
// cannot start user
Slog.w(TAG, "cannot start system user");
} else if (!am.unlockUser(UserHandle.USER_SYSTEM, null, null, null)) {
// unlocking system user failed. But still continue for other setup.
Slog.w(TAG, "cannot unlock system user");
} else {
// user 0 started and unlocked
handleUserLockStatusChange(UserHandle.USER_SYSTEM, true);
}
} catch (RemoteException e) {
// should not happen for local call.
Slog.wtf("RemoteException from AMS", e);
}
traceLog.traceEnd();
// Do not unlock here to allow other stuffs done. Unlock will happen
// when system completes the boot.
// TODO(b/124460424) Unlock earlier?
traceLog.traceBegin("ForegroundUserStart");
try {
if (!am.startUserInForegroundWithListener(targetUserId, null)) {
Slog.e(TAG, "cannot start foreground user:" + targetUserId);
} else {
mCarUserManagerHelper.setLastActiveUser(targetUserId);
}
} catch (RemoteException e) {
// should not happen for local call.
Slog.wtf("RemoteException from AMS", e);
}
traceLog.traceEnd();
}
private void notifyAllUnlockedUsers() {
// only care about unlocked users
LinkedList users = new LinkedList<>();
synchronized (mLock) {
for (Map.Entry entry : mUserUnlockedStatus.entrySet()) {
if (entry.getValue()) {
users.add(entry.getKey());
}
}
}
if (DBG) {
Slog.d(TAG, "notifyAllUnlockedUsers:" + users);
}
for (Integer i : users) {
sendSetUserLockStatusBinderCall(i, true);
}
}
private void sendSetCarServiceHelperBinderCall() {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(CAR_SERVICE_INTERFACE);
data.writeStrongBinder(mHelper.asBinder());
// void setCarServiceHelper(in IBinder helper)
sendBinderCallToCarService(data, ICAR_CALL_SET_CAR_SERVICE_HELPER);
}
private void sendSetUserLockStatusBinderCall(int userHandle, boolean unlocked) {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(CAR_SERVICE_INTERFACE);
data.writeInt(userHandle);
data.writeInt(unlocked ? 1 : 0);
// void setUserLockStatus(in int userHandle, in int unlocked)
sendBinderCallToCarService(data, ICAR_CALL_SET_USER_UNLOCK_STATUS);
}
private void sendSwitchUserBindercall(int userHandle) {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(CAR_SERVICE_INTERFACE);
data.writeInt(userHandle);
// void onSwitchUser(in int userHandle)
sendBinderCallToCarService(data, ICAR_CALL_SET_SWITCH_USER);
}
private void sendBinderCallToCarService(Parcel data, int callNumber) {
// Cannot depend on ICar which is defined in CarService, so handle binder call directly
// instead.
IBinder carService;
synchronized (mLock) {
carService = mCarService;
}
try {
carService.transact(IBinder.FIRST_CALL_TRANSACTION + callNumber,
data, null, Binder.FLAG_ONEWAY);
} catch (RemoteException e) {
Slog.w(TAG, "RemoteException from car service", e);
handleCarServiceCrash();
} finally {
data.recycle();
}
}
// Adapted from frameworks/base/services/core/java/com/android/server/Watchdog.java
// TODO(b/131861630) use implementation common with Watchdog.java
//
private static ArrayList getInterestingHalPids() {
try {
IServiceManager serviceManager = IServiceManager.getService();
ArrayList dump =
serviceManager.debugDump();
HashSet pids = new HashSet<>();
for (IServiceManager.InstanceDebugInfo info : dump) {
if (info.pid == IServiceManager.PidConstant.NO_PID) {
continue;
}
if (Watchdog.HAL_INTERFACES_OF_INTEREST.contains(info.interfaceName) ||
CAR_HAL_INTERFACES_OF_INTEREST.contains(info.interfaceName)) {
pids.add(info.pid);
}
}
return new ArrayList(pids);
} catch (RemoteException e) {
return new ArrayList();
}
}
// Adapted from frameworks/base/services/core/java/com/android/server/Watchdog.java
// TODO(b/131861630) use implementation common with Watchdog.java
//
private static ArrayList getInterestingNativePids() {
ArrayList pids = getInterestingHalPids();
int[] nativePids = Process.getPidsForCommands(Watchdog.NATIVE_STACKS_OF_INTEREST);
if (nativePids != null) {
pids.ensureCapacity(pids.size() + nativePids.length);
for (int i : nativePids) {
pids.add(i);
}
}
return pids;
}
// Borrowed from Watchdog.java. Create an ANR file from the call stacks.
//
private static void dumpServiceStacks() {
ArrayList pids = new ArrayList<>();
pids.add(Process.myPid());
ActivityManagerService.dumpStackTraces(
pids, null, null, getInterestingNativePids());
}
private void handleCarServiceCrash() {
// Recovery behavior. Kill the system server and reset
// everything if enabled by the property.
boolean restartOnServiceCrash = SystemProperties.getBoolean(PROP_RESTART_RUNTIME, false);
dumpServiceStacks();
if (restartOnServiceCrash) {
Slog.w(TAG, "*** CARHELPER KILLING SYSTEM PROCESS: " + "CarService crash");
Slog.w(TAG, "*** GOODBYE!");
Process.killProcess(Process.myPid());
System.exit(10);
} else {
Slog.w(TAG, "*** CARHELPER ignoring: " + "CarService crash");
}
}
private static native int nativeForceSuspend(int timeoutMs);
private class ICarServiceHelperImpl extends ICarServiceHelper.Stub {
/**
* Force device to suspend
*/
@Override // Binder call
public int forceSuspend(int timeoutMs) {
int retVal;
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
final long ident = Binder.clearCallingIdentity();
try {
retVal = nativeForceSuspend(timeoutMs);
} finally {
Binder.restoreCallingIdentity(ident);
}
return retVal;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy