| /* |
| * Copyright (C) 2018 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.infra; |
| |
| import android.annotation.CallSuper; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.UserIdInt; |
| import android.app.AppGlobals; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.pm.PackageItemInfo; |
| import android.content.pm.PackageManager.NameNotFoundException; |
| import android.content.pm.ServiceInfo; |
| import android.graphics.drawable.Drawable; |
| import android.os.Process; |
| import android.os.RemoteException; |
| import android.os.UserManager; |
| import android.provider.Settings; |
| import android.text.TextUtils; |
| import android.util.Slog; |
| |
| import com.android.internal.annotations.GuardedBy; |
| |
| import java.io.PrintWriter; |
| |
| /** |
| * Companion for {@link AbstractMasterSystemService}, it's the base class for the "real" service |
| * implementation. |
| * |
| * @param <M> "master" service class. |
| * @param <S> "real" service class. |
| * |
| * @hide |
| */ |
| public abstract class AbstractPerUserSystemService<S extends AbstractPerUserSystemService<S, M>, |
| M extends AbstractMasterSystemService<M, S>> { |
| |
| protected final @UserIdInt int mUserId; |
| protected final Object mLock; |
| protected final String mTag = getClass().getSimpleName(); |
| |
| protected final M mMaster; |
| |
| /** |
| * Whether service was disabled for user due to {@link UserManager} restrictions. |
| */ |
| @GuardedBy("mLock") |
| private boolean mDisabled; |
| |
| /** |
| * Caches whether the setup completed for the current user. |
| */ |
| @GuardedBy("mLock") |
| private boolean mSetupComplete; |
| |
| @GuardedBy("mLock") |
| private ServiceInfo mServiceInfo; |
| |
| protected AbstractPerUserSystemService(@NonNull M master, @NonNull Object lock, |
| @UserIdInt int userId) { |
| mMaster = master; |
| mLock = lock; |
| mUserId = userId; |
| } |
| |
| /** |
| * Creates a new {@link ServiceInfo} for the given service name. |
| * |
| * <p><b>MUST</b> be overridden by subclasses that bind to an |
| * {@link com.android.internal.infra.AbstractRemoteService}. |
| * |
| * @throws NameNotFoundException if the service does not exist. |
| * @throws SecurityException if the service does not have the proper permissions to be bound to. |
| * @throws UnsupportedOperationException if subclass binds to a remote service but does not |
| * overrides it. |
| * |
| * @return new {@link ServiceInfo}, |
| */ |
| protected @NonNull ServiceInfo newServiceInfoLocked( |
| @SuppressWarnings("unused") @NonNull ComponentName serviceComponent) |
| throws NameNotFoundException { |
| throw new UnsupportedOperationException("not overridden"); |
| } |
| |
| /** |
| * Callback called when an app has been updated. |
| * |
| * @param packageName package of the app being updated. |
| */ |
| protected void handlePackageUpdateLocked(@NonNull String packageName) { |
| } |
| |
| /** |
| * Gets whether the service is enabled and ready. |
| */ |
| @GuardedBy("mLock") |
| protected boolean isEnabledLocked() { |
| return mSetupComplete && mServiceInfo != null && !mDisabled; |
| } |
| |
| /** |
| * Gets whether the service is disabled by {@link UserManager} restrictions. |
| */ |
| protected final boolean isDisabledByUserRestrictionsLocked() { |
| return mDisabled; |
| } |
| |
| /** |
| * Updates the state of this service. |
| * |
| * <p>Typically called when the service {@link Settings} property or {@link UserManager} |
| * restriction changed, which includes the initial creation of the service. |
| * |
| * <p>Subclasses can extend this method to provide extra initialization, like clearing up |
| * previous state. |
| * |
| * @param disabled whether the service is disabled (due to {@link UserManager} restrictions). |
| * |
| * @return whether the disabled state changed. |
| */ |
| @GuardedBy("mLock") |
| @CallSuper |
| protected boolean updateLocked(boolean disabled) { |
| |
| final boolean wasEnabled = isEnabledLocked(); |
| if (mMaster.verbose) { |
| Slog.v(mTag, "updateLocked(u=" + mUserId + "): wasEnabled=" + wasEnabled |
| + ", mSetupComplete=" + mSetupComplete |
| + ", disabled=" + disabled + ", mDisabled=" + mDisabled); |
| } |
| |
| final String setupComplete = Settings.Secure.getStringForUser( |
| getContext().getContentResolver(), Settings.Secure.USER_SETUP_COMPLETE, mUserId); |
| mSetupComplete = "1".equals(setupComplete); |
| mDisabled = disabled; |
| |
| updateServiceInfoLocked(); |
| return wasEnabled != isEnabledLocked(); |
| } |
| |
| /** |
| * Updates the internal reference to the service info, and returns the service's component. |
| */ |
| protected final ComponentName updateServiceInfoLocked() { |
| ComponentName serviceComponent = null; |
| if (mMaster.mServiceNameResolver != null) { |
| ServiceInfo serviceInfo = null; |
| final String componentName = getComponentNameLocked(); |
| if (!TextUtils.isEmpty(componentName)) { |
| try { |
| serviceComponent = ComponentName.unflattenFromString(componentName); |
| serviceInfo = AppGlobals.getPackageManager().getServiceInfo(serviceComponent, |
| 0, mUserId); |
| if (serviceInfo == null) { |
| Slog.e(mTag, "Bad service name: " + componentName); |
| } |
| } catch (RuntimeException | RemoteException e) { |
| Slog.e(mTag, "Error getting service info for '" + componentName + "': " + e); |
| serviceInfo = null; |
| } |
| } |
| try { |
| if (serviceInfo != null) { |
| mServiceInfo = newServiceInfoLocked(serviceComponent); |
| if (mMaster.debug) { |
| Slog.d(mTag, "Set component for user " + mUserId + " as " |
| + serviceComponent + " and info as " + mServiceInfo); |
| } |
| } else { |
| mServiceInfo = null; |
| if (mMaster.debug) { |
| Slog.d(mTag, "Reset component for user " + mUserId + ":" + componentName); |
| } |
| } |
| } catch (Exception e) { |
| Slog.e(mTag, "Bad ServiceInfo for '" + componentName + "': " + e); |
| mServiceInfo = null; |
| } |
| } |
| return serviceComponent; |
| } |
| |
| /** |
| * Gets the user associated with this service. |
| */ |
| public final @UserIdInt int getUserId() { |
| return mUserId; |
| } |
| |
| /** |
| * Gets the master service. |
| */ |
| public final M getMaster() { |
| return mMaster; |
| } |
| |
| /** |
| * Gets this UID of the remote service this service binds to, or {@code -1} if the service is |
| * disabled. |
| */ |
| @GuardedBy("mLock") |
| protected final int getServiceUidLocked() { |
| if (mServiceInfo == null) { |
| if (mMaster.verbose) Slog.v(mTag, "getServiceUidLocked(): no mServiceInfo"); |
| return Process.INVALID_UID; |
| } |
| return mServiceInfo.applicationInfo.uid; |
| } |
| |
| /** |
| * Gets the current name of the service, which is either the default service or the |
| * {@link AbstractMasterSystemService#setTemporaryService(int, String, int) temporary one}. |
| */ |
| protected final @Nullable String getComponentNameLocked() { |
| return mMaster.mServiceNameResolver.getServiceName(mUserId); |
| } |
| |
| /** |
| * Checks whether the current service for the user was temporarily set. |
| */ |
| public final boolean isTemporaryServiceSetLocked() { |
| return mMaster.mServiceNameResolver.isTemporary(mUserId); |
| } |
| |
| /** |
| * Resets the temporary service implementation to the default component. |
| */ |
| protected final void resetTemporaryServiceLocked() { |
| mMaster.mServiceNameResolver.resetTemporaryService(mUserId); |
| } |
| |
| /** |
| * Gets the {@link ServiceInfo} of the remote service this service binds to, or {@code null} |
| * if the service is disabled. |
| */ |
| @Nullable |
| public final ServiceInfo getServiceInfo() { |
| return mServiceInfo; |
| } |
| |
| /** |
| * Gets the {@link ComponentName} of the remote service this service binds to, or {@code null} |
| * if the service is disabled. |
| */ |
| @Nullable |
| public final ComponentName getServiceComponentName() { |
| synchronized (mLock) { |
| return mServiceInfo == null ? null : mServiceInfo.getComponentName(); |
| } |
| } |
| /** |
| * Gets the name of the of the app this service binds to, or {@code null} if the service is |
| * disabled. |
| */ |
| @Nullable |
| public final String getServicePackageName() { |
| final ComponentName serviceComponent = getServiceComponentName(); |
| return serviceComponent == null ? null : serviceComponent.getPackageName(); |
| } |
| |
| /** |
| * Gets the user-visibile name of the service this service binds to, or {@code null} if the |
| * service is disabled. |
| */ |
| @Nullable |
| @GuardedBy("mLock") |
| public final CharSequence getServiceLabelLocked() { |
| return mServiceInfo == null ? null : mServiceInfo.loadSafeLabel( |
| getContext().getPackageManager(), 0 /* do not ellipsize */, |
| PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE | PackageItemInfo.SAFE_LABEL_FLAG_TRIM); |
| } |
| |
| /** |
| * Gets the icon the service this service binds to, or {@code null} if the service is disabled. |
| */ |
| @Nullable |
| @GuardedBy("mLock") |
| public final Drawable getServiceIconLocked() { |
| return mServiceInfo == null ? null |
| : mServiceInfo.loadIcon(getContext().getPackageManager()); |
| } |
| |
| /** |
| * Removes the service from the master's cache. |
| */ |
| protected final void removeSelfFromCacheLocked() { |
| mMaster.removeCachedServiceLocked(mUserId); |
| } |
| |
| /** |
| * Whether the service should log debug statements. |
| */ |
| //TODO(b/117779333): consider using constants for these guards |
| public final boolean isDebug() { |
| return mMaster.debug; |
| } |
| |
| /** |
| * Whether the service should log verbose statements. |
| */ |
| //TODO(b/117779333): consider using constants for these guards |
| public final boolean isVerbose() { |
| return mMaster.verbose; |
| } |
| |
| /** |
| * Gets the target SDK level of the service this service binds to, |
| * or {@code 0} if the service is disabled. |
| */ |
| public final int getTargedSdkLocked() { |
| return mServiceInfo == null ? 0 : mServiceInfo.applicationInfo.targetSdkVersion; |
| } |
| |
| /** |
| * Gets whether the device already finished setup. |
| */ |
| protected final boolean isSetupCompletedLocked() { |
| return mSetupComplete; |
| } |
| |
| /** |
| * Gets the context associated with this service. |
| */ |
| protected final Context getContext() { |
| return mMaster.getContext(); |
| } |
| |
| // TODO(b/117779333): support proto |
| @GuardedBy("mLock") |
| protected void dumpLocked(@NonNull String prefix, @NonNull PrintWriter pw) { |
| pw.print(prefix); pw.print("User: "); pw.println(mUserId); |
| if (mServiceInfo != null) { |
| pw.print(prefix); pw.print("Service Label: "); pw.println(getServiceLabelLocked()); |
| pw.print(prefix); pw.print("Target SDK: "); pw.println(getTargedSdkLocked()); |
| } |
| if (mMaster.mServiceNameResolver != null) { |
| pw.print(prefix); pw.print("Name resolver: "); |
| mMaster.mServiceNameResolver.dumpShort(pw, mUserId); pw.println(); |
| } |
| pw.print(prefix); pw.print("Disabled by UserManager: "); pw.println(mDisabled); |
| pw.print(prefix); pw.print("Setup complete: "); pw.println(mSetupComplete); |
| if (mServiceInfo != null) { |
| pw.print(prefix); pw.print("Service UID: "); |
| pw.println(mServiceInfo.applicationInfo.uid); |
| } |
| pw.println(); |
| } |
| } |