1 /*
2  * Copyright (C) 2015 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.car;
18 
19 import static android.car.Car.CAR_DISPLAY_COMPAT_SERVICE;
20 import static android.car.builtin.content.pm.PackageManagerHelper.PROPERTY_CAR_SERVICE_PACKAGE_NAME;
21 
22 import static com.android.car.CarServiceImpl.CAR_SERVICE_INIT_TIMING_MIN_DURATION_MS;
23 import static com.android.car.CarServiceImpl.CAR_SERVICE_INIT_TIMING_TAG;
24 import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DEPRECATED_CODE;
25 import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DUMP_INFO;
26 import static com.android.car.internal.SystemConstants.ICAR_SYSTEM_SERVER_CLIENT;
27 
28 import android.annotation.MainThread;
29 import android.annotation.NonNull;
30 import android.annotation.Nullable;
31 import android.app.ActivityManager;
32 import android.car.Car;
33 import android.car.CarFeatures;
34 import android.car.ICar;
35 import android.car.ICarResultReceiver;
36 import android.car.builtin.CarBuiltin;
37 import android.car.builtin.os.BinderHelper;
38 import android.car.builtin.os.BuildHelper;
39 import android.car.builtin.os.TraceHelper;
40 import android.car.builtin.os.UserManagerHelper;
41 import android.car.builtin.util.EventLogHelper;
42 import android.car.builtin.util.Slogf;
43 import android.car.builtin.util.TimingsTraceLog;
44 import android.car.feature.FeatureFlags;
45 import android.car.feature.FeatureFlagsImpl;
46 import android.car.user.CarUserManager;
47 import android.content.Context;
48 import android.content.om.OverlayInfo;
49 import android.content.om.OverlayManager;
50 import android.content.pm.PackageManager;
51 import android.os.Build;
52 import android.os.Bundle;
53 import android.os.IBinder;
54 import android.os.IInterface;
55 import android.os.Parcel;
56 import android.os.ParcelFileDescriptor;
57 import android.os.Process;
58 import android.os.RemoteException;
59 import android.os.SystemProperties;
60 import android.os.UserHandle;
61 import android.os.UserManager;
62 import android.util.ArrayMap;
63 import android.util.Log;
64 import android.util.proto.ProtoOutputStream;
65 
66 import com.android.car.admin.CarDevicePolicyService;
67 import com.android.car.am.CarActivityService;
68 import com.android.car.am.FixedActivityService;
69 import com.android.car.audio.CarAudioService;
70 import com.android.car.bluetooth.CarBluetoothService;
71 import com.android.car.cluster.ClusterHomeService;
72 import com.android.car.cluster.ClusterNavigationService;
73 import com.android.car.cluster.InstrumentClusterService;
74 import com.android.car.evs.CarEvsService;
75 import com.android.car.garagemode.GarageModeService;
76 import com.android.car.hal.PowerHalService;
77 import com.android.car.hal.VehicleHal;
78 import com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport;
79 import com.android.car.internal.ICarServiceHelper;
80 import com.android.car.internal.ICarSystemServerClient;
81 import com.android.car.internal.StaticBinderInterface;
82 import com.android.car.internal.SystemStaticBinder;
83 import com.android.car.internal.util.IndentingPrintWriter;
84 import com.android.car.occupantconnection.CarOccupantConnectionService;
85 import com.android.car.occupantconnection.CarRemoteDeviceService;
86 import com.android.car.oem.CarOemProxyService;
87 import com.android.car.os.CarPerformanceService;
88 import com.android.car.pm.CarPackageManagerService;
89 import com.android.car.power.CarPowerManagementService;
90 import com.android.car.remoteaccess.CarRemoteAccessService;
91 import com.android.car.stats.CarStatsService;
92 import com.android.car.systeminterface.SystemInterface;
93 import com.android.car.systemui.keyguard.ExperimentalCarKeyguardService;
94 import com.android.car.telemetry.CarTelemetryService;
95 import com.android.car.user.CarUserNoticeService;
96 import com.android.car.user.CarUserService;
97 import com.android.car.vms.VmsBrokerService;
98 import com.android.car.watchdog.CarWatchdogService;
99 import com.android.car.wifi.CarWifiService;
100 import com.android.internal.annotations.GuardedBy;
101 import com.android.internal.annotations.VisibleForTesting;
102 
103 import java.io.File;
104 import java.io.FileDescriptor;
105 import java.io.FileOutputStream;
106 import java.io.PrintWriter;
107 import java.util.ArrayList;
108 import java.util.Arrays;
109 import java.util.List;
110 import java.util.Map;
111 import java.util.Objects;
112 import java.util.concurrent.Callable;
113 
114 public class ICarImpl extends ICar.Stub {
115 
116     public static final String INTERNAL_INPUT_SERVICE = "internal_input";
117     public static final String INTERNAL_SYSTEM_ACTIVITY_MONITORING_SERVICE =
118             "system_activity_monitoring";
119 
120     @VisibleForTesting
121     static final String TAG = CarLog.tagFor(ICarImpl.class);
122 
123     private static final int CAR_AUDIO_SERVICE_INIT_TIMEOUT_MS = 10_000;
124 
125     private final Context mContext;
126     private final Context mCarServiceBuiltinPackageContext;
127     private final VehicleHal mHal;
128 
129     private final CarServiceHelperWrapper mCarServiceHelperWrapper;
130 
131     private final CarFeatureController mFeatureController;
132 
133     private final SystemInterface mSystemInterface;
134 
135     private final FeatureFlags mFeatureFlags;
136 
137     private final CarOemProxyService mCarOemService;
138     private final SystemActivityMonitoringService mSystemActivityMonitoringService;
139     private final CarPowerManagementService mCarPowerManagementService;
140     private final CarPackageManagerService mCarPackageManagerService;
141     private final CarInputService mCarInputService;
142     private final CarDrivingStateService mCarDrivingStateService;
143     private final CarUxRestrictionsManagerService mCarUXRestrictionsService;
144     private final OccupantAwarenessService mOccupantAwarenessService;
145     private final CarAudioService mCarAudioService;
146     private final CarProjectionService mCarProjectionService;
147     private final CarPropertyService mCarPropertyService;
148     private final CarNightService mCarNightService;
149     private final AppFocusService mAppFocusService;
150     private final FixedActivityService mFixedActivityService;
151     private final GarageModeService mGarageModeService;
152     private final ClusterNavigationService mClusterNavigationService;
153     private final InstrumentClusterService mInstrumentClusterService;
154     private final CarLocationService mCarLocationService;
155     private final CarBluetoothService mCarBluetoothService;
156     private final CarPerUserServiceHelper mCarPerUserServiceHelper;
157     private final CarDiagnosticService mCarDiagnosticService;
158     private final CarStorageMonitoringService mCarStorageMonitoringService;
159     private final CarMediaService mCarMediaService;
160     private final CarUserService mCarUserService;
161     @Nullable
162     private final ExperimentalCarKeyguardService mExperimentalCarKeyguardService;
163     private final CarOccupantZoneService mCarOccupantZoneService;
164     private final CarUserNoticeService mCarUserNoticeService;
165     private final VmsBrokerService mVmsBrokerService;
166     private final CarBugreportManagerService mCarBugreportManagerService;
167     private final CarStatsService mCarStatsService;
168     private final CarExperimentalFeatureServiceController mCarExperimentalFeatureServiceController;
169     private final CarWatchdogService mCarWatchdogService;
170     private final CarPerformanceService mCarPerformanceService;
171     private final CarDevicePolicyService mCarDevicePolicyService;
172     private final ClusterHomeService mClusterHomeService;
173     private final CarEvsService mCarEvsService;
174     private final CarTelemetryService mCarTelemetryService;
175     private final CarActivityService mCarActivityService;
176     private final CarOccupantConnectionService mCarOccupantConnectionService;
177     private final CarRemoteDeviceService mCarRemoteDeviceService;
178     private final CarWifiService mCarWifiService;
179     @Nullable
180     private final CarRemoteAccessService mCarRemoteAccessService;
181 
182     // Storing all the car services in the order of their init.
183     private final CarSystemService[] mAllServicesInInitOrder;
184 
185     private static final boolean DBG = Slogf.isLoggable(TAG, Log.DEBUG);
186 
187     private final Object mLock = new Object();
188 
189     // This flag indicates whether priorityInit() should be called in the constructor or
190     // will be deferred to CarImpl.init(). With the new boot user code flow, the boot user is set
191     // in initialUserSetter as early as possible. The earliest it can be done is in the ICarImpl
192     // constructor. In priorityInit() HAL and UserService are initialized which sets boot user.
193     private final boolean mDoPriorityInitInConstruction;
194 
195     /** Test only service. Populate it only when necessary. */
196     @GuardedBy("mLock")
197     private CarTestService mCarTestService;
198 
199     private final String mVehicleInterfaceName;
200 
201     private final ICarSystemServerClientImpl mICarSystemServerClientImpl;
202 
203     private final BinderHelper.ShellCommandListener mCmdListener =
204             (FileDescriptor in, FileDescriptor out, FileDescriptor err, String[] args) ->
205                     newCarShellCommand().exec(ICarImpl.this, in, out, err, args);
206 
207     // A static Binder class implementation. Faked during unit tests.
208     private final StaticBinderInterface mStaticBinder;
209 
ICarImpl(Builder builder)210     private ICarImpl(Builder builder) {
211         TimingsTraceLog t = new TimingsTraceLog(
212                 CAR_SERVICE_INIT_TIMING_TAG, TraceHelper.TRACE_TAG_CAR_SERVICE,
213                 CAR_SERVICE_INIT_TIMING_MIN_DURATION_MS);
214         t.traceBegin("ICarImpl.constructor");
215 
216         mStaticBinder = Objects.requireNonNullElseGet(builder.mStaticBinder,
217                 () -> new SystemStaticBinder());
218         mFeatureFlags = Objects.requireNonNullElseGet(builder.mFeatureFlags,
219                 () -> new FeatureFlagsImpl());
220         mDoPriorityInitInConstruction = builder.mDoPriorityInitInConstruction;
221 
222         mContext = builder.mContext;
223         if (builder.mCarServiceBuiltinPackageContext == null) {
224             mCarServiceBuiltinPackageContext = mContext;
225         } else {
226             mCarServiceBuiltinPackageContext = builder.mCarServiceBuiltinPackageContext;
227         }
228 
229         mCarServiceHelperWrapper = CarServiceHelperWrapper.create();
230 
231         // Currently there are ~36 services, hence using 40 as the initial capacity.
232         List<CarSystemService> allServices = new ArrayList<>(40);
233         mCarOemService = constructWithTrace(t, CarOemProxyService.class,
234                 () -> new CarOemProxyService(mContext), allServices);
235 
236         mSystemInterface = builder.mSystemInterface;
237         CarLocalServices.addService(SystemInterface.class, mSystemInterface);
238 
239         mHal = constructWithTrace(t, VehicleHal.class,
240                 () -> new VehicleHal(mContext, builder.mVehicle), allServices);
241 
242         mFeatureController = constructWithTrace(t, CarFeatureController.class,
243                 () -> new CarFeatureController(
244                         mContext, mSystemInterface.getSystemCarDir(), mHal), allServices);
245         mVehicleInterfaceName = builder.mVehicleInterfaceName;
246         mCarPropertyService = constructWithTrace(
247                 t, CarPropertyService.class,
248                 () -> new CarPropertyService.Builder()
249                         .setContext(mContext)
250                         .setPropertyHalService(mHal.getPropertyHal())
251                         .build(), allServices);
252         mCarDrivingStateService = constructWithTrace(
253                 t, CarDrivingStateService.class,
254                 () -> new CarDrivingStateService(mContext, mCarPropertyService), allServices);
255         mCarOccupantZoneService = constructWithTrace(t, CarOccupantZoneService.class,
256                 () -> new CarOccupantZoneService(mContext), allServices);
257         mCarUXRestrictionsService = constructWithTrace(t, CarUxRestrictionsManagerService.class,
258                 () -> new CarUxRestrictionsManagerService(mContext, mCarDrivingStateService,
259                         mCarPropertyService, mCarOccupantZoneService), allServices);
260         mCarActivityService = constructWithTrace(t, CarActivityService.class,
261                 () -> new CarActivityService(mContext), allServices);
262         mCarPackageManagerService = constructWithTrace(t, CarPackageManagerService.class,
263                 () -> new CarPackageManagerService(mContext, mCarUXRestrictionsService,
264                         mCarActivityService, mCarOccupantZoneService), allServices);
265         UserManager userManager = mContext.getSystemService(UserManager.class);
266         mCarUserService = getFromBuilderOrConstruct(t, CarUserService.class, builder,
267                 () -> {
268                     int maxRunningUsers = UserManagerHelper.getMaxRunningUsers(mContext);
269                     return new CarUserService(mContext, mHal.getUserHal(), userManager,
270                         maxRunningUsers, mCarUXRestrictionsService, mCarPackageManagerService,
271                         mCarOccupantZoneService);
272                 },
273                 allServices);
274         if (mDoPriorityInitInConstruction) {
275             Slogf.i(TAG, "VHAL Priority Init Enabled");
276             Slogf.i(TAG, "Car User Service Priority Init Enabled");
277             priorityInit();
278         }
279 
280         if (mFeatureController.isFeatureEnabled(Car.EXPERIMENTAL_CAR_KEYGUARD_SERVICE)) {
281             mExperimentalCarKeyguardService = constructWithTrace(t,
282                         ExperimentalCarKeyguardService.class,
283                     () -> new ExperimentalCarKeyguardService(mContext, mCarUserService,
284                             mCarOccupantZoneService), allServices);
285         } else {
286             mExperimentalCarKeyguardService = null;
287         }
288         mSystemActivityMonitoringService = constructWithTrace(
289                 t, SystemActivityMonitoringService.class,
290                 () -> new SystemActivityMonitoringService(mContext), allServices);
291 
292         mCarPowerManagementService = constructWithTrace(
293                 t, CarPowerManagementService.class,
294                 () -> new CarPowerManagementService.Builder()
295                         .setContext(mContext)
296                         .setPowerHalService(mHal.getPowerHal())
297                         .setSystemInterface(mSystemInterface)
298                         .setCarUserService(mCarUserService)
299                         .setPowerPolicyDaemon(builder.mPowerPolicyDaemon)
300                         .setFeatureFlags(mFeatureFlags)
301                         .build(),
302                 allServices);
303         if (mFeatureController.isFeatureEnabled(CarFeatures.FEATURE_CAR_USER_NOTICE_SERVICE)) {
304             mCarUserNoticeService = constructWithTrace(
305                     t, CarUserNoticeService.class, () -> new CarUserNoticeService(mContext),
306                     allServices);
307         } else {
308             mCarUserNoticeService = null;
309         }
310         if (mFeatureController.isFeatureEnabled(Car.OCCUPANT_AWARENESS_SERVICE)) {
311             mOccupantAwarenessService = constructWithTrace(t, OccupantAwarenessService.class,
312                     () -> new OccupantAwarenessService(mContext), allServices);
313         } else {
314             mOccupantAwarenessService = null;
315         }
316         mCarPerUserServiceHelper = constructWithTrace(
317                 t, CarPerUserServiceHelper.class,
318                 () -> new CarPerUserServiceHelper(mContext, mCarUserService), allServices);
319         mCarBluetoothService = constructWithTrace(t, CarBluetoothService.class,
320                 () -> new CarBluetoothService(mContext, mCarPerUserServiceHelper),
321                 allServices);
322         mCarInputService = constructWithTrace(t, CarInputService.class,
323                 () -> new CarInputService(mContext, mHal.getInputHal(), mCarUserService,
324                         mCarOccupantZoneService, mCarBluetoothService, mCarPowerManagementService,
325                         mSystemInterface), allServices);
326         mCarProjectionService = constructWithTrace(t, CarProjectionService.class,
327                 () -> new CarProjectionService(mContext, null /* handler */, mCarInputService,
328                         mCarBluetoothService), allServices);
329         mGarageModeService = getFromBuilderOrConstruct(t, GarageModeService.class, builder,
330                 () -> new GarageModeService(mContext), allServices);
331         mAppFocusService = getFromBuilderOrConstruct(t, AppFocusService.class, builder,
332                 () -> new AppFocusService(mContext, mSystemActivityMonitoringService),
333                 allServices);
334         mCarAudioService = getFromBuilderOrConstruct(t, CarAudioService.class, builder,
335                 () -> new CarAudioService(mContext), allServices);
336         mCarNightService = constructWithTrace(t, CarNightService.class,
337                 () -> new CarNightService(mContext, mCarPropertyService), allServices);
338         mFixedActivityService = constructWithTrace(t, FixedActivityService.class,
339                 () -> new FixedActivityService(mContext, mCarActivityService), allServices);
340         mClusterNavigationService = constructWithTrace(
341                 t, ClusterNavigationService.class,
342                 () -> new ClusterNavigationService(mContext, mAppFocusService), allServices);
343         if (mFeatureController.isFeatureEnabled(Car.CAR_INSTRUMENT_CLUSTER_SERVICE)) {
344             mInstrumentClusterService = constructWithTrace(t, InstrumentClusterService.class,
345                     () -> new InstrumentClusterService(mContext, mClusterNavigationService,
346                             mCarInputService), allServices);
347         } else {
348             mInstrumentClusterService = null;
349         }
350 
351         mCarStatsService = constructWithTrace(t, CarStatsService.class,
352                 () -> new CarStatsService(mContext), allServices);
353 
354         if (mFeatureController.isFeatureEnabled(Car.VEHICLE_MAP_SERVICE)) {
355             mVmsBrokerService = constructWithTrace(t, VmsBrokerService.class,
356                     () -> new VmsBrokerService(mContext, mCarStatsService), allServices);
357         } else {
358             mVmsBrokerService = null;
359         }
360         if (mFeatureController.isFeatureEnabled(Car.DIAGNOSTIC_SERVICE)) {
361             mCarDiagnosticService = constructWithTrace(t, CarDiagnosticService.class,
362                     () -> new CarDiagnosticService(mContext, mHal.getDiagnosticHal()), allServices);
363         } else {
364             mCarDiagnosticService = null;
365         }
366         if (mFeatureController.isFeatureEnabled(Car.STORAGE_MONITORING_SERVICE)) {
367             mCarStorageMonitoringService = constructWithTrace(
368                     t, CarStorageMonitoringService.class,
369                     () -> new CarStorageMonitoringService(mContext, mSystemInterface), allServices);
370         } else {
371             mCarStorageMonitoringService = null;
372         }
373         mCarLocationService = constructWithTrace(t, CarLocationService.class,
374                 () -> new CarLocationService(mContext), allServices);
375         mCarMediaService = constructWithTrace(t, CarMediaService.class,
376                 () -> new CarMediaService(mContext, mCarOccupantZoneService, mCarUserService,
377                         mCarPowerManagementService),
378                 allServices);
379         mCarBugreportManagerService = constructWithTrace(t, CarBugreportManagerService.class,
380                 () -> new CarBugreportManagerService(mContext), allServices);
381         mCarWatchdogService = getFromBuilderOrConstruct(t, CarWatchdogService.class, builder,
382                 () -> new CarWatchdogService(mContext, mCarServiceBuiltinPackageContext),
383                 allServices);
384         mCarPerformanceService = getFromBuilderOrConstruct(t, CarPerformanceService.class, builder,
385                 () -> new CarPerformanceService(mContext), allServices);
386         mCarDevicePolicyService = constructWithTrace(
387                 t, CarDevicePolicyService.class, () -> new CarDevicePolicyService(mContext,
388                         mCarServiceBuiltinPackageContext, mCarUserService), allServices);
389         if (mFeatureController.isFeatureEnabled(Car.CLUSTER_HOME_SERVICE)) {
390             if (!mFeatureController.isFeatureEnabled(Car.CAR_INSTRUMENT_CLUSTER_SERVICE)) {
391                 mClusterHomeService = constructWithTrace(
392                         t, ClusterHomeService.class,
393                         () -> new ClusterHomeService(mContext, mHal.getClusterHal(),
394                                 mClusterNavigationService, mCarOccupantZoneService,
395                                 mFixedActivityService), allServices);
396             } else {
397                 Slogf.w(TAG, "Can't init ClusterHomeService, since Old cluster service is running");
398                 mClusterHomeService = null;
399             }
400         } else {
401             mClusterHomeService = null;
402         }
403 
404         if (mFeatureController.isFeatureEnabled(Car.CAR_EVS_SERVICE)) {
405             mCarEvsService = constructWithTrace(t, CarEvsService.class,
406                     () -> new CarEvsService(mContext, mCarServiceBuiltinPackageContext,
407                             mHal.getEvsHal(), mCarPropertyService), allServices);
408         } else {
409             mCarEvsService = null;
410         }
411 
412         if (mFeatureController.isFeatureEnabled(Car.CAR_TELEMETRY_SERVICE)) {
413             mCarTelemetryService = getFromBuilderOrConstruct(t, CarTelemetryService.class,
414                     builder,
415                     () -> new CarTelemetryService(mContext, mCarPowerManagementService,
416                             mCarPropertyService),
417                     allServices);
418         } else {
419             mCarTelemetryService = null;
420         }
421 
422         if (mFeatureController.isFeatureEnabled((Car.CAR_REMOTE_ACCESS_SERVICE))) {
423             if (builder.mCarRemoteAccessServiceConstructor == null) {
424                 mCarRemoteAccessService = constructWithTrace(t, CarRemoteAccessService.class,
425                         () -> new CarRemoteAccessService(
426                                 mContext, mSystemInterface, mHal.getPowerHal()), allServices);
427             } else {
428                 mCarRemoteAccessService = builder.mCarRemoteAccessServiceConstructor.construct(
429                         mContext, mSystemInterface, mHal.getPowerHal());
430                 allServices.add(mCarRemoteAccessService);
431             }
432         } else {
433             mCarRemoteAccessService = null;
434         }
435 
436         mCarWifiService = constructWithTrace(t, CarWifiService.class,
437                 () -> new CarWifiService(mContext), allServices);
438 
439         // Always put mCarExperimentalFeatureServiceController in last.
440         if (!BuildHelper.isUserBuild()) {
441             mCarExperimentalFeatureServiceController = constructWithTrace(
442                     t, CarExperimentalFeatureServiceController.class,
443                     () -> new CarExperimentalFeatureServiceController(mContext),
444                     allServices);
445         } else {
446             mCarExperimentalFeatureServiceController = null;
447         }
448 
449         if (mFeatureController.isFeatureEnabled(Car.CAR_OCCUPANT_CONNECTION_SERVICE)
450                 || mFeatureController.isFeatureEnabled(Car.CAR_REMOTE_DEVICE_SERVICE)) {
451             mCarRemoteDeviceService = constructWithTrace(
452                     t, CarRemoteDeviceService.class,
453                     () -> new CarRemoteDeviceService(mContext, mCarOccupantZoneService,
454                             mCarPowerManagementService, mSystemActivityMonitoringService),
455                     allServices);
456             mCarOccupantConnectionService = constructWithTrace(
457                     t, CarOccupantConnectionService.class,
458                     () -> new CarOccupantConnectionService(mContext, mCarOccupantZoneService,
459                             mCarRemoteDeviceService),
460                     allServices);
461 
462         } else {
463             mCarOccupantConnectionService = null;
464             mCarRemoteDeviceService = null;
465         }
466 
467         mAllServicesInInitOrder = allServices.toArray(new CarSystemService[allServices.size()]);
468         mICarSystemServerClientImpl = new ICarSystemServerClientImpl();
469 
470         t.traceEnd(); // "ICarImpl.constructor"
471     }
472 
473     @MainThread
init()474     void init() {
475         TimingsTraceLog t = new TimingsTraceLog(CAR_SERVICE_INIT_TIMING_TAG,
476                 TraceHelper.TRACE_TAG_CAR_SERVICE, CAR_SERVICE_INIT_TIMING_MIN_DURATION_MS);
477 
478         t.traceBegin("ICarImpl.init");
479         if (!mDoPriorityInitInConstruction) {
480             priorityInit();
481         }
482 
483         t.traceBegin("CarService.initAllServices");
484         for (CarSystemService service : mAllServicesInInitOrder) {
485             t.traceBegin(service.getClass().getSimpleName());
486             service.init();
487             t.traceEnd();
488         }
489         t.traceEnd(); // "CarService.initAllServices"
490 
491         t.traceBegin("CarService.onInitComplete");
492         for (CarSystemService service : mAllServicesInInitOrder) {
493             if (service == mCarPowerManagementService) {
494                 // Must make sure mCarPowerManagementService.onInitComplete runs at last since
495                 // it might shutdown the device.
496                 continue;
497             }
498             t.traceBegin("onInitComplete:" + service.getClass().getSimpleName());
499             service.onInitComplete();
500             t.traceEnd();
501         }
502         mCarPowerManagementService.onInitComplete();
503         t.traceEnd(); // "CarService.onInitComplete"
504 
505         t.traceEnd(); // "ICarImpl.init"
506     }
507 
release()508     void release() {
509         // release done in opposite order from init
510         for (int i = mAllServicesInInitOrder.length - 1; i >= 0; i--) {
511             mAllServicesInInitOrder[i].release();
512         }
513     }
514 
515     @Override
setSystemServerConnections(ICarServiceHelper carServiceHelper, ICarResultReceiver resultReceiver)516     public void setSystemServerConnections(ICarServiceHelper carServiceHelper,
517             ICarResultReceiver resultReceiver) {
518         Bundle bundle;
519         try {
520             EventLogHelper.writeCarServiceSetCarServiceHelper(mStaticBinder.getCallingPid());
521             assertCallingFromSystemProcess();
522 
523             mCarServiceHelperWrapper.setCarServiceHelper(carServiceHelper);
524 
525             bundle = new Bundle();
526             bundle.putBinder(ICAR_SYSTEM_SERVER_CLIENT, mICarSystemServerClientImpl.asBinder());
527         } catch (Exception e) {
528             // send back a null response
529             Slogf.w(TAG, "Exception in setSystemServerConnections", e);
530             bundle = null;
531         }
532 
533         try {
534             resultReceiver.send(/* unused */ 0, bundle);
535         } catch (RemoteException e) {
536             Slogf.w(TAG, "RemoteException from CarServiceHelperService", e);
537         }
538     }
539 
540     @Override
isFeatureEnabled(String featureName)541     public boolean isFeatureEnabled(String featureName) {
542         return mFeatureController.isFeatureEnabled(featureName);
543     }
544 
545     @Override
enableFeature(String featureName)546     public int enableFeature(String featureName) {
547         // permission check inside the controller
548         return mFeatureController.enableFeature(featureName);
549     }
550 
551     @Override
disableFeature(String featureName)552     public int disableFeature(String featureName) {
553         // permission check inside the controller
554         return mFeatureController.disableFeature(featureName);
555     }
556 
557     @Override
getAllEnabledFeatures()558     public List<String> getAllEnabledFeatures() {
559         // permission check inside the controller
560         return mFeatureController.getAllEnabledFeatures();
561     }
562 
563     @Override
getAllPendingDisabledFeatures()564     public List<String> getAllPendingDisabledFeatures() {
565         // permission check inside the controller
566         return mFeatureController.getAllPendingDisabledFeatures();
567     }
568 
569     @Override
getAllPendingEnabledFeatures()570     public List<String> getAllPendingEnabledFeatures() {
571         // permission check inside the controller
572         return mFeatureController.getAllPendingEnabledFeatures();
573     }
574 
575     @Override
576     @Nullable
getCarManagerClassForFeature(String featureName)577     public String getCarManagerClassForFeature(String featureName) {
578         if (mCarExperimentalFeatureServiceController == null) {
579             return null;
580         }
581         return mCarExperimentalFeatureServiceController.getCarManagerClassForFeature(featureName);
582     }
583 
584 
assertCallingFromSystemProcess()585     private void assertCallingFromSystemProcess() {
586         int uid = mStaticBinder.getCallingUid();
587         if (uid != Process.SYSTEM_UID) {
588             throw new SecurityException("Only allowed from system");
589         }
590     }
591 
592     @Override
593     @Nullable
getCarService(String serviceName)594     public IBinder getCarService(String serviceName) {
595         if (!mFeatureController.isFeatureEnabled(serviceName)) {
596             Slogf.w(CarLog.TAG_SERVICE, "getCarService for disabled service:" + serviceName);
597             return null;
598         }
599         switch (serviceName) {
600             case Car.AUDIO_SERVICE:
601                 // Car audio service init is async. Need to wait for init to complete before
602                 // returning the service.
603                 try {
604                     boolean ready = mCarAudioService.waitForInitComplete(
605                             CAR_AUDIO_SERVICE_INIT_TIMEOUT_MS);
606                     if (!ready) {
607                         Slogf.e(CarLog.TAG_SERVICE,
608                                 "CarAudioService not ready within 10s, return null");
609                         return null;
610                     }
611                 } catch (InterruptedException e) {
612                     Slogf.e(CarLog.TAG_SERVICE,
613                             "Interrupted while waiting for car audio service init to complete", e);
614                     Thread.currentThread().interrupt();
615                     return null;
616                 }
617                 return mCarAudioService;
618             case Car.APP_FOCUS_SERVICE:
619                 return mAppFocusService;
620             case Car.PACKAGE_SERVICE:
621                 return mCarPackageManagerService;
622             case Car.DIAGNOSTIC_SERVICE:
623                 CarServiceUtils.assertAnyDiagnosticPermission(mContext);
624                 return mCarDiagnosticService;
625             case Car.POWER_SERVICE:
626                 return mCarPowerManagementService;
627             case Car.CABIN_SERVICE:
628             case Car.HVAC_SERVICE:
629             case Car.INFO_SERVICE:
630             case Car.PROPERTY_SERVICE:
631             case Car.SENSOR_SERVICE:
632             case Car.VENDOR_EXTENSION_SERVICE:
633                 return mCarPropertyService;
634             case Car.CAR_NAVIGATION_SERVICE:
635                 CarServiceUtils.assertNavigationManagerPermission(mContext);
636                 return mClusterNavigationService;
637             case Car.CAR_INSTRUMENT_CLUSTER_SERVICE:
638                 CarServiceUtils.assertClusterManagerPermission(mContext);
639                 return mInstrumentClusterService.getManagerService();
640             case Car.PROJECTION_SERVICE:
641                 return mCarProjectionService;
642             case Car.VEHICLE_MAP_SERVICE:
643                 CarServiceUtils.assertAnyVmsPermission(mContext);
644                 return mVmsBrokerService;
645             case Car.VMS_SUBSCRIBER_SERVICE:
646                 CarServiceUtils.assertVmsSubscriberPermission(mContext);
647                 return mVmsBrokerService;
648             case Car.TEST_SERVICE: {
649                 CarServiceUtils.assertPermission(mContext, Car.PERMISSION_CAR_TEST_SERVICE);
650                 synchronized (mLock) {
651                     if (mCarTestService == null) {
652                         mCarTestService = new CarTestService(mContext, this);
653                     }
654                     return mCarTestService;
655                 }
656             }
657             case Car.STORAGE_MONITORING_SERVICE:
658                 CarServiceUtils.assertPermission(mContext, Car.PERMISSION_STORAGE_MONITORING);
659                 return mCarStorageMonitoringService;
660             case Car.CAR_DRIVING_STATE_SERVICE:
661                 CarServiceUtils.assertDrivingStatePermission(mContext);
662                 return mCarDrivingStateService;
663             case Car.CAR_UX_RESTRICTION_SERVICE:
664                 return mCarUXRestrictionsService;
665             case Car.OCCUPANT_AWARENESS_SERVICE:
666                 return mOccupantAwarenessService;
667             case Car.CAR_MEDIA_SERVICE:
668                 return mCarMediaService;
669             case Car.CAR_OCCUPANT_ZONE_SERVICE:
670                 return mCarOccupantZoneService;
671             case Car.CAR_BUGREPORT_SERVICE:
672                 return mCarBugreportManagerService;
673             case Car.CAR_USER_SERVICE:
674                 return mCarUserService;
675             case Car.EXPERIMENTAL_CAR_KEYGUARD_SERVICE:
676                 return mExperimentalCarKeyguardService;
677             case Car.CAR_WATCHDOG_SERVICE:
678                 return mCarWatchdogService;
679             case Car.CAR_PERFORMANCE_SERVICE:
680                 return mCarPerformanceService;
681             case Car.CAR_INPUT_SERVICE:
682                 return mCarInputService;
683             case Car.CAR_DEVICE_POLICY_SERVICE:
684                 return mCarDevicePolicyService;
685             case Car.CLUSTER_HOME_SERVICE:
686                 return mClusterHomeService;
687             case Car.CAR_EVS_SERVICE:
688                 return mCarEvsService;
689             case Car.CAR_TELEMETRY_SERVICE:
690                 return mCarTelemetryService;
691             case Car.CAR_ACTIVITY_SERVICE:
692                 return mCarActivityService;
693             case Car.CAR_OCCUPANT_CONNECTION_SERVICE:
694                 return mCarOccupantConnectionService;
695             case Car.CAR_REMOTE_DEVICE_SERVICE:
696                 return mCarRemoteDeviceService;
697             case Car.CAR_REMOTE_ACCESS_SERVICE:
698                 return mCarRemoteAccessService;
699             default:
700                 // CarDisplayCompatManager does not need a new service but the Car class
701                 // doesn't allow a new Manager class without a service.
702                 if (mFeatureFlags.displayCompatibility()) {
703                     if (serviceName.equals(CAR_DISPLAY_COMPAT_SERVICE)) {
704                         return mCarActivityService;
705                     }
706                 }
707                 if (mFeatureFlags.persistApSettings()) {
708                     if (serviceName.equals(Car.CAR_WIFI_SERVICE)) {
709                         return mCarWifiService;
710                     }
711                 }
712                 IBinder service = null;
713                 if (mCarExperimentalFeatureServiceController != null) {
714                     service = mCarExperimentalFeatureServiceController.getCarService(serviceName);
715                 }
716                 if (service == null) {
717                     Slogf.w(CarLog.TAG_SERVICE, "getCarService for unknown service:"
718                             + serviceName);
719                 }
720                 return service;
721         }
722     }
723 
724     @Override
725     @ExcludeFromCodeCoverageGeneratedReport(reason = DEPRECATED_CODE)
getCarConnectionType()726     public int getCarConnectionType() {
727         return Car.CONNECTION_TYPE_EMBEDDED;
728     }
729 
730     @Override
731     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dump(FileDescriptor fd, PrintWriter writer, String[] args)732     protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
733         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
734                 != PackageManager.PERMISSION_GRANTED) {
735             writer.println("Permission Denial: can't dump CarService from from pid="
736                     + mStaticBinder.getCallingPid() + ", uid=" + mStaticBinder.getCallingUid()
737                     + " without permission " + android.Manifest.permission.DUMP);
738             return;
739         }
740 
741         try (IndentingPrintWriter pw = new IndentingPrintWriter(writer)) {
742             dumpIndenting(fd, pw, args);
743         }
744     }
745 
746     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpIndenting(FileDescriptor fd, IndentingPrintWriter writer, String[] args)747     private void dumpIndenting(FileDescriptor fd, IndentingPrintWriter writer, String[] args) {
748         if (args == null || args.length == 0) {
749             dumpAll(writer);
750             return;
751         }
752         switch (args[0]) {
753             case "-a":
754                 dumpAll(writer);
755                 return;
756             case "--list":
757                 dumpListOfServices(writer);
758                 return;
759             case "--version":
760                 dumpVersions(writer);
761                 return;
762             case "--services": {
763                 int length = args.length;
764                 boolean dumpToProto = false;
765                 if (length < 2) {
766                     writer.println("Must pass services to dump when using --services");
767                     return;
768                 }
769                 if (Objects.equals(args[length - 1], "--proto")) {
770                     length -= 2;
771                     dumpToProto = true;
772                     if (length > 1) {
773                         writer.println("Cannot dump multiple services to proto");
774                         return;
775                     }
776                 } else {
777                     length -= 1;
778                 }
779                 String[] services = new String[length];
780                 System.arraycopy(args, 1, services, 0, length);
781                 if (dumpToProto) {
782                     if (!mFeatureFlags.carDumpToProto()) {
783                         writer.println("Cannot dump " + services[0]
784                                 + " to proto since FLAG_CAR_DUMP_TO_PROTO is disabled");
785                         return;
786                     }
787                     dumpServiceProto(writer, fd, services[0]);
788                 } else {
789                     dumpIndividualServices(writer, services);
790                 }
791                 return;
792             }
793             case "--metrics":
794                 // Strip the --metrics flag when passing dumpsys arguments to CarStatsService
795                 // allowing for nested flag selection.
796                 if (args.length == 1 || Arrays.asList(args).contains("--vms-client")) {
797                     mCarStatsService.dump(writer);
798                 }
799                 return;
800             case "--vms-hal":
801                 mHal.getVmsHal().dumpMetrics(fd);
802                 return;
803             case "--hal": {
804                 if (args.length == 1) {
805                     dumpAllHals(writer);
806                     return;
807                 }
808                 int length = args.length - 1;
809                 String[] halNames = new String[length];
810                 System.arraycopy(args, 1, halNames, 0, length);
811                 mHal.dumpSpecificHals(writer, halNames);
812                 return;
813             }
814             case "--list-hals":
815                 mHal.dumpListHals(writer);
816                 return;
817             case "--data-dir":
818                 dumpDataDir(writer);
819                 return;
820             case "--help":
821                 showDumpHelp(writer);
822                 return;
823             case "--rro":
824                 dumpRROs(writer);
825                 return;
826             case "--oem-service":
827                 if (args.length > 1 && args[1].equalsIgnoreCase("--name-only")) {
828                     writer.println(getOemServiceName());
829                 } else {
830                     dumpOemService(writer);
831                 }
832                 return;
833             default:
834                 execShellCmd(args, writer);
835         }
836     }
837 
dumpOemService(IndentingPrintWriter writer)838     private void dumpOemService(IndentingPrintWriter writer) {
839         mCarOemService.dump(writer);
840     }
841 
getOemServiceName()842     public String getOemServiceName() {
843         return mCarOemService.getOemServiceName();
844     }
845 
dumpAll(IndentingPrintWriter writer)846     private void dumpAll(IndentingPrintWriter writer) {
847         writer.println("*Dump car service*");
848         dumpVersions(writer);
849         dumpAllServices(writer);
850         dumpAllHals(writer);
851         dumpRROs(writer);
852     }
853 
dumpRROs(IndentingPrintWriter writer)854     private void dumpRROs(IndentingPrintWriter writer) {
855         writer.println("*Dump Car Service RROs*");
856 
857         String packageName = SystemProperties.get(
858                 PROPERTY_CAR_SERVICE_PACKAGE_NAME, /*def= */null);
859         if (packageName == null) {
860             writer.println("Car Service updatable package name is null.");
861             return;
862         }
863 
864         OverlayManager manager = mContext.getSystemService(OverlayManager.class);
865 
866         List<OverlayInfo> installedOverlaysForSystem = manager.getOverlayInfosForTarget(packageName,
867                 UserHandle.SYSTEM);
868         writer.println("RROs for System User");
869         for (int i = 0; i < installedOverlaysForSystem.size(); i++) {
870             OverlayInfo overlayInfo = installedOverlaysForSystem.get(i);
871             writer.printf("Overlay: %s, Enabled: %b \n", overlayInfo.getPackageName(),
872                     overlayInfo.isEnabled());
873         }
874 
875         int currentUser = ActivityManager.getCurrentUser();
876         writer.printf("RROs for Current User: %d\n", currentUser);
877         List<OverlayInfo> installedOverlaysForCurrentUser = manager.getOverlayInfosForTarget(
878                 packageName, UserHandle.of(currentUser));
879         for (int i = 0; i < installedOverlaysForCurrentUser.size(); i++) {
880             OverlayInfo overlayInfo = installedOverlaysForCurrentUser.get(i);
881             writer.printf("Overlay: %s, Enabled: %b \n", overlayInfo.getPackageName(),
882                     overlayInfo.isEnabled());
883         }
884     }
885 
886     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpVersions(IndentingPrintWriter writer)887     private void dumpVersions(IndentingPrintWriter writer) {
888         writer.println("*Dump versions*");
889         writer.println("Android SDK_INT: " + Build.VERSION.SDK_INT);
890         writer.println("Car Version: " + Car.getCarVersion());
891         writer.println("Platform Version: " + Car.getPlatformVersion());
892         writer.println("CarBuiltin Platform minor: " + CarBuiltin.PLATFORM_VERSION_MINOR_INT);
893         writer.println("Legacy versions (might differ from above as they can't be emulated)");
894         writer.increaseIndent();
895         writer.println("Car API major: " + Car.getCarVersion().getMajorVersion());
896         writer.println("Car API minor: " + Car.getCarVersion().getMinorVersion());
897         writer.println("Car Platform minor: " + Car.PLATFORM_VERSION_MINOR_INT);
898         writer.println("VHAL and Car User Service Priority Init: " + mDoPriorityInitInConstruction);
899         writer.decreaseIndent();
900     }
901 
902     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpAllHals(IndentingPrintWriter writer)903     private void dumpAllHals(IndentingPrintWriter writer) {
904         writer.println("*Dump Vehicle HAL*");
905         writer.println("Vehicle HAL Interface: " + mVehicleInterfaceName);
906         try {
907             // TODO dump all feature flags by creating a dumpable interface
908             mHal.dump(writer);
909         } catch (Exception e) {
910             writer.println("Failed dumping: " + mHal.getClass().getName());
911             e.printStackTrace(writer);
912         }
913     }
914 
915     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
showDumpHelp(IndentingPrintWriter writer)916     private void showDumpHelp(IndentingPrintWriter writer) {
917         writer.println("Car service dump usage:");
918         writer.println("[NO ARG]");
919         writer.println("\t  dumps everything (all services and HALs)");
920         writer.println("--help");
921         writer.println("\t  shows this help");
922         writer.println("--version");
923         writer.println("\t  shows the version of all car components");
924         writer.println("--list");
925         writer.println("\t  lists the name of all services");
926         writer.println("--list-hals");
927         writer.println("\t  lists the name of all HALs");
928         writer.println("--services <SVC1> [SVC2] [SVCN]");
929         writer.println("\t  dumps just the specific services, where SVC is just the service class");
930         writer.println("\t  name (like CarUserService)");
931         writer.println("--vms-hal");
932         writer.println("\t  dumps the VMS HAL metrics");
933         writer.println("--hal [HAL1] [HAL2] [HALN]");
934         writer.println("\t  dumps just the specified HALs (or all of them if none specified),");
935         writer.println("\t  where HAL is just the class name (like UserHalService)");
936         writer.println("--user-metrics");
937         writer.println("\t  dumps user switching and stopping metrics");
938         writer.println("--first-user-metrics");
939         writer.println("\t  dumps how long it took to unlock first user since Android started\n");
940         writer.println("\t  (or -1 if not unlocked)");
941         writer.println("--data-dir");
942         writer.println("\t  dumps CarService data dir (and whether it exists)");
943         writer.println("--rro");
944         writer.println("\t  dumps only the RROs");
945         writer.println("-h");
946         writer.println("\t  shows commands usage (NOTE: commands are not available on USER builds");
947         writer.println("[ANYTHING ELSE]");
948         writer.println("\t  runs the given command (use --h to see the available commands)");
949     }
950 
951     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpDataDir(IndentingPrintWriter writer)952     private void dumpDataDir(IndentingPrintWriter writer) {
953         File dataDir = mContext.getDataDir();
954         writer.printf("Data dir: %s Exists: %b\n", dataDir.getAbsolutePath(), dataDir.exists());
955     }
956 
957     @Override
onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags)958     public boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply,
959             int flags) throws RemoteException {
960         // Shell cmd is handled specially.
961         if (BinderHelper.onTransactForCmd(code, data, reply, flags, mCmdListener)) {
962             return true;
963         }
964         return super.onTransact(code, data, reply, flags);
965     }
966 
newCarShellCommand()967     private CarShellCommand newCarShellCommand() {
968         Map<Class, CarSystemService> allServicesByClazz = new ArrayMap<>();
969         for (CarSystemService service : mAllServicesInInitOrder) {
970             allServicesByClazz.put(service.getClass(), service);
971         }
972 
973         return new CarShellCommand(mContext, mHal, mFeatureController, mSystemInterface,
974                 allServicesByClazz);
975     }
976 
977     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpListOfServices(IndentingPrintWriter writer)978     private void dumpListOfServices(IndentingPrintWriter writer) {
979         for (CarSystemService service : mAllServicesInInitOrder) {
980             writer.println(service.getClass().getName());
981         }
982     }
983 
984     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpAllServices(IndentingPrintWriter writer)985     private void dumpAllServices(IndentingPrintWriter writer) {
986         writer.println("*Dump all services*");
987         for (CarSystemService service : mAllServicesInInitOrder) {
988             if (service instanceof CarServiceBase) {
989                 dumpService(service, writer);
990             }
991         }
992         synchronized (mLock) {
993             if (mCarTestService != null) {
994                 dumpService(mCarTestService, writer);
995             }
996         }
997     }
998 
999     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpIndividualServices(IndentingPrintWriter writer, String... serviceNames)1000     private void dumpIndividualServices(IndentingPrintWriter writer, String... serviceNames) {
1001         for (String serviceName : serviceNames) {
1002             writer.printf("** Dumping %s\n\n", serviceName);
1003             CarSystemService service = getCarServiceBySubstring(serviceName);
1004             if (service == null) {
1005                 writer.println("No such service!");
1006             } else {
1007                 dumpService(service, writer);
1008             }
1009             writer.println();
1010         }
1011     }
1012 
1013     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpServiceProto(IndentingPrintWriter writer, FileDescriptor fd, String serviceName)1014     private void dumpServiceProto(IndentingPrintWriter writer, FileDescriptor fd,
1015             String serviceName) {
1016         CarSystemService service = getCarServiceBySubstring(serviceName);
1017         if (service == null) {
1018             writer.println("No such service!");
1019         } else {
1020             if (service instanceof CarServiceBase) {
1021                 CarServiceBase carService = (CarServiceBase) service;
1022                 try (FileOutputStream fileStream = new FileOutputStream(fd)) {
1023                     ProtoOutputStream proto = new ProtoOutputStream(fileStream);
1024                     carService.dumpProto(proto);
1025                     proto.flush();
1026                 } catch (Exception e) {
1027                     writer.println("Failed dumping: " + carService.getClass().getName());
1028                     e.printStackTrace(writer);
1029                 }
1030             } else {
1031                 writer.println("Only services that extend CarServiceBase can dump to proto");
1032             }
1033         }
1034     }
1035 
1036     @Nullable
getCarServiceBySubstring(String className)1037     private CarSystemService getCarServiceBySubstring(String className) {
1038         for (int i = 0; i < mAllServicesInInitOrder.length; i++) {
1039             if (Objects.equals(mAllServicesInInitOrder[i].getClass().getSimpleName(), className)) {
1040                 return mAllServicesInInitOrder[i];
1041             }
1042         }
1043         return null;
1044     }
1045 
1046     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
dumpService(CarSystemService service, IndentingPrintWriter writer)1047     private void dumpService(CarSystemService service, IndentingPrintWriter writer) {
1048         try {
1049             service.dump(writer);
1050         } catch (Exception e) {
1051             writer.println("Failed dumping: " + service.getClass().getName());
1052             e.printStackTrace(writer);
1053         }
1054     }
1055 
execShellCmd(String[] args, IndentingPrintWriter writer)1056     void execShellCmd(String[] args, IndentingPrintWriter writer) {
1057         newCarShellCommand().exec(args, writer);
1058     }
1059 
getFromBuilderOrConstruct(TimingsTraceLog t, Class<T> cls, Builder builder, Callable<T> callable, List<CarSystemService> allServices)1060     private static <T extends CarSystemService> T getFromBuilderOrConstruct(TimingsTraceLog t,
1061             Class<T> cls, Builder builder, Callable<T> callable,
1062             List<CarSystemService> allServices) {
1063         T serviceFromBuilder = (T) builder.mInjectedServices.get(cls);
1064         if (serviceFromBuilder != null) {
1065             allServices.add(serviceFromBuilder);
1066             CarLocalServices.addService(cls, serviceFromBuilder);
1067             return serviceFromBuilder;
1068         }
1069         return constructWithTrace(t, cls, callable, allServices);
1070     }
1071 
constructWithTrace(TimingsTraceLog t, Class<T> cls, Callable<T> callable, List<CarSystemService> allServices)1072     private static <T extends CarSystemService> T constructWithTrace(TimingsTraceLog t,
1073             Class<T> cls, Callable<T> callable, List<CarSystemService> allServices) {
1074         t.traceBegin(cls.getSimpleName());
1075         T constructed;
1076         try {
1077             constructed = callable.call();
1078             CarLocalServices.addService(cls, constructed);
1079         } catch (Exception e) {
1080             throw new RuntimeException("Crash while constructing:" + cls.getSimpleName(), e);
1081         } finally {
1082             t.traceEnd();
1083         }
1084         allServices.add(constructed);
1085         return constructed;
1086     }
1087 
1088     private final class ICarSystemServerClientImpl extends ICarSystemServerClient.Stub {
1089         @Override
onUserLifecycleEvent(int eventType, int fromUserId, int toUserId)1090         public void onUserLifecycleEvent(int eventType, int fromUserId, int toUserId)
1091                 throws RemoteException {
1092             assertCallingFromSystemProcess();
1093             EventLogHelper.writeCarServiceOnUserLifecycle(eventType, fromUserId, toUserId);
1094             if (DBG) {
1095                 Slogf.d(TAG,
1096                         "onUserLifecycleEvent("
1097                                 + CarUserManager.lifecycleEventTypeToString(eventType) + ", "
1098                                 + toUserId + ")");
1099             }
1100             mCarUserService.onUserLifecycleEvent(eventType, fromUserId, toUserId);
1101         }
1102 
1103         @Override
onFactoryReset(ICarResultReceiver callback)1104         public void onFactoryReset(ICarResultReceiver callback) {
1105             assertCallingFromSystemProcess();
1106 
1107             mCarPowerManagementService.setFactoryResetCallback(callback);
1108             BuiltinPackageDependency.createNotificationHelper(mCarServiceBuiltinPackageContext)
1109                     .showFactoryResetNotification(callback);
1110         }
1111 
1112         @Override
setInitialUser(UserHandle user)1113         public void setInitialUser(UserHandle user) {
1114             assertCallingFromSystemProcess();
1115             mCarUserService.setInitialUserFromSystemServer(user);
1116         }
1117 
1118         @Override
notifyFocusChanged(int pid, int uid)1119         public void notifyFocusChanged(int pid, int uid) {
1120             assertCallingFromSystemProcess();
1121             mSystemActivityMonitoringService.handleFocusChanged(pid, uid);
1122         }
1123     }
1124 
dumpVhal(ParcelFileDescriptor fd, List<String> options)1125     /* package */ void dumpVhal(ParcelFileDescriptor fd, List<String> options)
1126             throws RemoteException {
1127         mHal.dumpVhal(fd, options);
1128     }
1129 
hasAidlVhal()1130     /* package */ boolean hasAidlVhal() {
1131         return mHal.isAidlVhal();
1132     }
1133 
priorityInit()1134     /* package */ void priorityInit() {
1135         mHal.priorityInit();
1136         mCarUserService.priorityInit();
1137     }
1138 
1139     public static final class Builder {
1140         Context mContext;
1141         Context mCarServiceBuiltinPackageContext;
1142         VehicleStub mVehicle;
1143         SystemInterface mSystemInterface;
1144         String mVehicleInterfaceName;
1145         IInterface mPowerPolicyDaemon;
1146         CarRemoteAccessServiceConstructor mCarRemoteAccessServiceConstructor;
1147         StaticBinderInterface mStaticBinder;
1148         FeatureFlags mFeatureFlags;
1149         boolean mDoPriorityInitInConstruction = true;
1150 
1151         // Services injected to replace the real service.
1152         final Map<Class<?>, Object> mInjectedServices = new ArrayMap<>();
1153 
1154         /**
1155          * Builds the ICarImpl object represented by this builder object
1156          * @return ICarImpl object
1157          */
build()1158         public ICarImpl build() {
1159             return new ICarImpl(this);
1160         }
1161 
1162         /**
1163          * Sets ICarImpl builder service context
1164          * @param serviceContext The service context
1165          * @return Current builder object
1166          */
setServiceContext(Context serviceContext)1167         public Builder setServiceContext(Context serviceContext) {
1168             mContext = serviceContext;
1169             return this;
1170         }
1171 
1172         /**
1173          * Sets ICarImpl builder built in context
1174          * @param builtInContext The car service built in package context
1175          * @return Current builder object
1176          */
setBuiltInContext(Context builtInContext)1177         public Builder setBuiltInContext(Context builtInContext) {
1178             mCarServiceBuiltinPackageContext = builtInContext;
1179             return this;
1180         }
1181 
1182         /**
1183          * Sets ICarImpl builder vehicle
1184          * @param vehicle The vehicle stub object to use
1185          * @return Current builder object
1186          */
setVehicle(VehicleStub vehicle)1187         public Builder setVehicle(VehicleStub vehicle) {
1188             mVehicle = vehicle;
1189             return this;
1190         }
1191 
1192         /**
1193          * Sets ICarImpl builder system interface
1194          * @param systemInterface The system interface object
1195          * @return Current builder object
1196          */
setSystemInterface(SystemInterface systemInterface)1197         public Builder setSystemInterface(SystemInterface systemInterface) {
1198             mSystemInterface = systemInterface;
1199             return this;
1200         }
1201 
1202         /**
1203          * Sets ICarImpl builder vehicle interface name
1204          * @param vehicleInterfaceName The vehicle interface name
1205          * @return Current builder object
1206          */
setVehicleInterfaceName(String vehicleInterfaceName)1207         public Builder setVehicleInterfaceName(String vehicleInterfaceName) {
1208             mVehicleInterfaceName = vehicleInterfaceName;
1209             return this;
1210         }
1211 
1212         /**
1213          * Sets ICarImpl builder car user service
1214          * @param carUserService The car user service
1215          * @return Current builder object
1216          */
setCarUserService(CarUserService carUserService)1217         public Builder setCarUserService(CarUserService carUserService) {
1218             mInjectedServices.put(CarUserService.class, carUserService);
1219             return this;
1220         }
1221 
1222         /**
1223          * Sets ICarImpl builder car watchdog service
1224          * @param carWatchdogService The car watchdog service
1225          * @return Current builder object
1226          */
setCarWatchdogService(CarWatchdogService carWatchdogService)1227         public Builder setCarWatchdogService(CarWatchdogService carWatchdogService) {
1228             mInjectedServices.put(CarWatchdogService.class, carWatchdogService);
1229             return this;
1230         }
1231 
1232         /**
1233          * Sets ICarImpl builder car performance service
1234          * @param carPerformanceService The car performance service
1235          * @return Current builder object
1236          */
setCarPerformanceService(CarPerformanceService carPerformanceService)1237         public Builder setCarPerformanceService(CarPerformanceService carPerformanceService) {
1238             mInjectedServices.put(CarPerformanceService.class, carPerformanceService);
1239             return this;
1240         }
1241 
1242         /**
1243          * Sets ICarImpl builder garage mode service
1244          * @param garageModeService The garage mode service
1245          * @return Current builder object
1246          */
setGarageModeService(GarageModeService garageModeService)1247         public Builder setGarageModeService(GarageModeService garageModeService) {
1248             mInjectedServices.put(GarageModeService.class, garageModeService);
1249             return this;
1250         }
1251 
1252         /**
1253          * Sets ICarImpl builder app focus service
1254          * @param appFocusService The app focus service
1255          * @return Current builder object
1256          */
setAppFocusService(AppFocusService appFocusService)1257         public Builder setAppFocusService(AppFocusService appFocusService) {
1258             mInjectedServices.put(AppFocusService.class, appFocusService);
1259             return this;
1260         }
1261 
1262         /**
1263          * Sets the car audio service to be used in ICarImpl.
1264          *
1265          * @param carAudioService The car audio service to be used for ICarImpl.
1266          * @return Current builder object
1267          */
setCarAudioService(CarAudioService carAudioService)1268         public Builder setCarAudioService(CarAudioService carAudioService) {
1269             mInjectedServices.put(CarAudioService.class, carAudioService);
1270             return this;
1271         }
1272 
1273         /**
1274          * Sets ICarImpl power policy daemon
1275          * @param powerPolicyDaemon The power policy daemon interface
1276          * @return Current builder object
1277          */
setPowerPolicyDaemon(IInterface powerPolicyDaemon)1278         public Builder setPowerPolicyDaemon(IInterface powerPolicyDaemon) {
1279             mPowerPolicyDaemon = powerPolicyDaemon;
1280             return this;
1281         }
1282 
1283         /**
1284          * Sets ICarImpl car telemetry service
1285          * @param carTelemetryService The car telemetry service
1286          * @return Current builder object
1287          */
setCarTelemetryService(CarTelemetryService carTelemetryService)1288         public Builder setCarTelemetryService(CarTelemetryService carTelemetryService) {
1289             mInjectedServices.put(CarTelemetryService.class, carTelemetryService);
1290             return this;
1291         }
1292 
1293         /**
1294          * The constructor interface to create a CarRemoteAccessService.
1295          *
1296          * Used for creating a fake CarRemoteAccessService during car service test.
1297          */
1298         @VisibleForTesting
1299         public interface CarRemoteAccessServiceConstructor {
1300             /**
1301              * Creates the {@link CarRemoteAccessService} object.
1302              */
construct(Context context, SystemInterface systemInterface, PowerHalService powerHalService)1303             CarRemoteAccessService construct(Context context, SystemInterface systemInterface,
1304                     PowerHalService powerHalService);
1305         }
1306 
1307         /**
1308          * Set a fake car remote access service constructor to be used for ICarImpl.
1309          * @param constructor The car remote access service constructor.
1310          * @return Current builder object
1311          */
1312         @VisibleForTesting
setCarRemoteAccessServiceConstructor( CarRemoteAccessServiceConstructor constructor)1313         public Builder setCarRemoteAccessServiceConstructor(
1314                 CarRemoteAccessServiceConstructor constructor) {
1315             mCarRemoteAccessServiceConstructor = constructor;
1316             return this;
1317         }
1318 
1319         /**
1320          * Sets whether ICarImpl builder will make an ICarImpl object that does priority
1321          * initialization in construction
1322          * @param doPriorityInitInConstruction Whether to do priority initialization in construction
1323          *                                     of the ICarImpl object this builder represents
1324          * @return Current builder object
1325          */
setDoPriorityInitInConstruction(boolean doPriorityInitInConstruction)1326         public Builder setDoPriorityInitInConstruction(boolean doPriorityInitInConstruction) {
1327             mDoPriorityInitInConstruction = doPriorityInitInConstruction;
1328             return this;
1329         }
1330 
1331         /**
1332          * Sets the calling Uid, only used for testing.
1333          */
1334         @VisibleForTesting
setTestStaticBinder(StaticBinderInterface testStaticBinder)1335         public Builder setTestStaticBinder(StaticBinderInterface testStaticBinder) {
1336             mStaticBinder = testStaticBinder;
1337             return this;
1338         }
1339 
1340         /**
1341          * Sets the feature flags.
1342          */
setFeatureFlags(FeatureFlags featureFlags)1343         public Builder setFeatureFlags(FeatureFlags featureFlags) {
1344             mFeatureFlags = featureFlags;
1345             return this;
1346         }
1347     }
1348 }
1349