| /* |
| * Copyright 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 android.app; |
| |
| import static android.Manifest.permission.DUMP; |
| import static android.Manifest.permission.PACKAGE_USAGE_STATS; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.RequiresPermission; |
| import android.annotation.SystemApi; |
| import android.content.Context; |
| import android.os.IBinder; |
| import android.os.IStatsManager; |
| import android.os.IStatsPullerCallback; |
| import android.os.RemoteException; |
| import android.os.ServiceManager; |
| import android.util.AndroidException; |
| import android.util.Slog; |
| |
| /** |
| * API for statsd clients to send configurations and retrieve data. |
| * |
| * @hide |
| */ |
| @SystemApi |
| public final class StatsManager { |
| private static final String TAG = "StatsManager"; |
| private static final boolean DEBUG = false; |
| |
| private final Context mContext; |
| |
| private IStatsManager mService; |
| |
| /** |
| * Long extra of uid that added the relevant stats config. |
| */ |
| public static final String EXTRA_STATS_CONFIG_UID = "android.app.extra.STATS_CONFIG_UID"; |
| /** |
| * Long extra of the relevant stats config's configKey. |
| */ |
| public static final String EXTRA_STATS_CONFIG_KEY = "android.app.extra.STATS_CONFIG_KEY"; |
| /** |
| * Long extra of the relevant statsd_config.proto's Subscription.id. |
| */ |
| public static final String EXTRA_STATS_SUBSCRIPTION_ID = |
| "android.app.extra.STATS_SUBSCRIPTION_ID"; |
| /** |
| * Long extra of the relevant statsd_config.proto's Subscription.rule_id. |
| */ |
| public static final String EXTRA_STATS_SUBSCRIPTION_RULE_ID = |
| "android.app.extra.STATS_SUBSCRIPTION_RULE_ID"; |
| /** |
| * List<String> of the relevant statsd_config.proto's BroadcastSubscriberDetails.cookie. |
| * Obtain using {@link android.content.Intent#getStringArrayListExtra(String)}. |
| */ |
| public static final String EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES = |
| "android.app.extra.STATS_BROADCAST_SUBSCRIBER_COOKIES"; |
| /** |
| * Extra of a {@link android.os.StatsDimensionsValue} representing sliced dimension value |
| * information. |
| */ |
| public static final String EXTRA_STATS_DIMENSIONS_VALUE = |
| "android.app.extra.STATS_DIMENSIONS_VALUE"; |
| /** |
| * Long array extra of the active configs for the uid that added those configs. |
| */ |
| public static final String EXTRA_STATS_ACTIVE_CONFIG_KEYS = |
| "android.app.extra.STATS_ACTIVE_CONFIG_KEYS"; |
| |
| /** |
| * Broadcast Action: Statsd has started. |
| * Configurations and PendingIntents can now be sent to it. |
| */ |
| public static final String ACTION_STATSD_STARTED = "android.app.action.STATSD_STARTED"; |
| |
| /** |
| * Constructor for StatsManagerClient. |
| * |
| * @hide |
| */ |
| public StatsManager(Context context) { |
| mContext = context; |
| } |
| |
| /** |
| * Adds the given configuration and associates it with the given configKey. If a config with the |
| * given configKey already exists for the caller's uid, it is replaced with the new one. |
| * |
| * @param configKey An arbitrary integer that allows clients to track the configuration. |
| * @param config Wire-encoded StatsdConfig proto that specifies metrics (and all |
| * dependencies eg, conditions and matchers). |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| * @throws IllegalArgumentException if config is not a wire-encoded StatsdConfig proto |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public void addConfig(long configKey, byte[] config) throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| // can throw IllegalArgumentException |
| service.addConfiguration(configKey, config, mContext.getOpPackageName()); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when adding configuration"); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| // TODO: Temporary for backwards compatibility. Remove. |
| /** |
| * @deprecated Use {@link #addConfig(long, byte[])} |
| */ |
| @Deprecated |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public boolean addConfiguration(long configKey, byte[] config) { |
| try { |
| addConfig(configKey, config); |
| return true; |
| } catch (StatsUnavailableException | IllegalArgumentException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Remove a configuration from logging. |
| * |
| * @param configKey Configuration key to remove. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public void removeConfig(long configKey) throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| service.removeConfiguration(configKey, mContext.getOpPackageName()); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when removing configuration"); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| // TODO: Temporary for backwards compatibility. Remove. |
| /** |
| * @deprecated Use {@link #removeConfig(long)} |
| */ |
| @Deprecated |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public boolean removeConfiguration(long configKey) { |
| try { |
| removeConfig(configKey); |
| return true; |
| } catch (StatsUnavailableException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Set the PendingIntent to be used when broadcasting subscriber information to the given |
| * subscriberId within the given config. |
| * <p> |
| * Suppose that the calling uid has added a config with key configKey, and that in this config |
| * it is specified that when a particular anomaly is detected, a broadcast should be sent to |
| * a BroadcastSubscriber with id subscriberId. This function links the given pendingIntent with |
| * that subscriberId (for that config), so that this pendingIntent is used to send the broadcast |
| * when the anomaly is detected. |
| * <p> |
| * When statsd sends the broadcast, the PendingIntent will used to send an intent with |
| * information of |
| * {@link #EXTRA_STATS_CONFIG_UID}, |
| * {@link #EXTRA_STATS_CONFIG_KEY}, |
| * {@link #EXTRA_STATS_SUBSCRIPTION_ID}, |
| * {@link #EXTRA_STATS_SUBSCRIPTION_RULE_ID}, |
| * {@link #EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES}, and |
| * {@link #EXTRA_STATS_DIMENSIONS_VALUE}. |
| * <p> |
| * This function can only be called by the owner (uid) of the config. It must be called each |
| * time statsd starts. The config must have been added first (via {@link #addConfig}). |
| * |
| * @param pendingIntent the PendingIntent to use when broadcasting info to the subscriber |
| * associated with the given subscriberId. May be null, in which case |
| * it undoes any previous setting of this subscriberId. |
| * @param configKey The integer naming the config to which this subscriber is attached. |
| * @param subscriberId ID of the subscriber, as used in the config. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public void setBroadcastSubscriber( |
| PendingIntent pendingIntent, long configKey, long subscriberId) |
| throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| if (pendingIntent != null) { |
| // Extracts IIntentSender from the PendingIntent and turns it into an IBinder. |
| IBinder intentSender = pendingIntent.getTarget().asBinder(); |
| service.setBroadcastSubscriber(configKey, subscriberId, intentSender, |
| mContext.getOpPackageName()); |
| } else { |
| service.unsetBroadcastSubscriber(configKey, subscriberId, |
| mContext.getOpPackageName()); |
| } |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when adding broadcast subscriber", e); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| // TODO: Temporary for backwards compatibility. Remove. |
| /** |
| * @deprecated Use {@link #setBroadcastSubscriber(PendingIntent, long, long)} |
| */ |
| @Deprecated |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public boolean setBroadcastSubscriber( |
| long configKey, long subscriberId, PendingIntent pendingIntent) { |
| try { |
| setBroadcastSubscriber(pendingIntent, configKey, subscriberId); |
| return true; |
| } catch (StatsUnavailableException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Registers the operation that is called to retrieve the metrics data. This must be called |
| * each time statsd starts. The config must have been added first (via {@link #addConfig}, |
| * although addConfig could have been called on a previous boot). This operation allows |
| * statsd to send metrics data whenever statsd determines that the metrics in memory are |
| * approaching the memory limits. The fetch operation should call {@link #getReports} to fetch |
| * the data, which also deletes the retrieved metrics from statsd's memory. |
| * |
| * @param pendingIntent the PendingIntent to use when broadcasting info to the subscriber |
| * associated with the given subscriberId. May be null, in which case |
| * it removes any associated pending intent with this configKey. |
| * @param configKey The integer naming the config to which this operation is attached. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public void setFetchReportsOperation(PendingIntent pendingIntent, long configKey) |
| throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| if (pendingIntent == null) { |
| service.removeDataFetchOperation(configKey, mContext.getOpPackageName()); |
| } else { |
| // Extracts IIntentSender from the PendingIntent and turns it into an IBinder. |
| IBinder intentSender = pendingIntent.getTarget().asBinder(); |
| service.setDataFetchOperation(configKey, intentSender, |
| mContext.getOpPackageName()); |
| } |
| |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when registering data listener."); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| /** |
| * Registers the operation that is called whenever there is a change in which configs are |
| * active. This must be called each time statsd starts. This operation allows |
| * statsd to inform clients that they should pull data of the configs that are currently |
| * active. The activeConfigsChangedOperation should set periodic alarms to pull data of configs |
| * that are active and stop pulling data of configs that are no longer active. |
| * |
| * @param pendingIntent the PendingIntent to use when broadcasting info to the subscriber |
| * associated with the given subscriberId. May be null, in which case |
| * it removes any associated pending intent for this client. |
| * @return A list of configs that are currently active for this client. If the pendingIntent is |
| * null, this will be an empty list. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public @NonNull long[] setActiveConfigsChangedOperation(@Nullable PendingIntent pendingIntent) |
| throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| if (pendingIntent == null) { |
| service.removeActiveConfigsChangedOperation(mContext.getOpPackageName()); |
| return new long[0]; |
| } else { |
| // Extracts IIntentSender from the PendingIntent and turns it into an IBinder. |
| IBinder intentSender = pendingIntent.getTarget().asBinder(); |
| return service.setActiveConfigsChangedOperation(intentSender, |
| mContext.getOpPackageName()); |
| } |
| |
| } catch (RemoteException e) { |
| Slog.e(TAG, |
| "Failed to connect to statsd when registering active configs listener."); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| // TODO: Temporary for backwards compatibility. Remove. |
| /** |
| * @deprecated Use {@link #setFetchReportsOperation(PendingIntent, long)} |
| */ |
| @Deprecated |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public boolean setDataFetchOperation(long configKey, PendingIntent pendingIntent) { |
| try { |
| setFetchReportsOperation(pendingIntent, configKey); |
| return true; |
| } catch (StatsUnavailableException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Request the data collected for the given configKey. |
| * This getter is destructive - it also clears the retrieved metrics from statsd's memory. |
| * |
| * @param configKey Configuration key to retrieve data from. |
| * @return Serialized ConfigMetricsReportList proto. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public byte[] getReports(long configKey) throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| return service.getData(configKey, mContext.getOpPackageName()); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when getting data"); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| // TODO: Temporary for backwards compatibility. Remove. |
| /** |
| * @deprecated Use {@link #getReports(long)} |
| */ |
| @Deprecated |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public @Nullable byte[] getData(long configKey) { |
| try { |
| return getReports(configKey); |
| } catch (StatsUnavailableException e) { |
| return null; |
| } |
| } |
| |
| /** |
| * Clients can request metadata for statsd. Will contain stats across all configurations but not |
| * the actual metrics themselves (metrics must be collected via {@link #getReports(long)}. |
| * This getter is not destructive and will not reset any metrics/counters. |
| * |
| * @return Serialized StatsdStatsReport proto. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public byte[] getStatsMetadata() throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| return service.getMetadata(mContext.getOpPackageName()); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when getting metadata"); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| // TODO: Temporary for backwards compatibility. Remove. |
| /** |
| * @deprecated Use {@link #getStatsMetadata()} |
| */ |
| @Deprecated |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public @Nullable byte[] getMetadata() { |
| try { |
| return getStatsMetadata(); |
| } catch (StatsUnavailableException e) { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the experiments IDs registered with statsd, or an empty array if there aren't any. |
| * |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| */ |
| @RequiresPermission(allOf = {DUMP, PACKAGE_USAGE_STATS}) |
| public long[] getRegisteredExperimentIds() |
| throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| if (service == null) { |
| if (DEBUG) { |
| Slog.d(TAG, "Failed to find statsd when getting experiment IDs"); |
| } |
| return new long[0]; |
| } |
| return service.getRegisteredExperimentIds(); |
| } catch (RemoteException e) { |
| if (DEBUG) { |
| Slog.d(TAG, |
| "Failed to connect to StatsCompanionService when getting " |
| + "registered experiment IDs"); |
| } |
| return new long[0]; |
| } |
| } |
| } |
| |
| /** |
| * Registers a callback for an atom when that atom is to be pulled. The stats service will |
| * invoke pullData in the callback when the stats service determines that this atom needs to be |
| * pulled. Currently, this only works for atoms with tags above 100,000 that do not have a uid. |
| * |
| * @param atomTag The tag of the atom for this puller callback. Must be at least 100000. |
| * @param callback The callback to be invoked when the stats service pulls the atom. |
| * @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service |
| * |
| * @hide |
| */ |
| @RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS }) |
| public void setPullerCallback(int atomTag, IStatsPullerCallback callback) |
| throws StatsUnavailableException { |
| synchronized (this) { |
| try { |
| IStatsManager service = getIStatsManagerLocked(); |
| if (callback == null) { |
| service.unregisterPullerCallback(atomTag, mContext.getOpPackageName()); |
| } else { |
| service.registerPullerCallback(atomTag, callback, |
| mContext.getOpPackageName()); |
| } |
| |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Failed to connect to statsd when registering data listener."); |
| throw new StatsUnavailableException("could not connect", e); |
| } catch (SecurityException e) { |
| throw new StatsUnavailableException(e.getMessage(), e); |
| } |
| } |
| } |
| |
| private class StatsdDeathRecipient implements IBinder.DeathRecipient { |
| @Override |
| public void binderDied() { |
| synchronized (this) { |
| mService = null; |
| } |
| } |
| } |
| |
| private IStatsManager getIStatsManagerLocked() throws StatsUnavailableException { |
| if (mService != null) { |
| return mService; |
| } |
| mService = IStatsManager.Stub.asInterface(ServiceManager.getService("stats")); |
| if (mService == null) { |
| throw new StatsUnavailableException("could not be found"); |
| } |
| try { |
| mService.asBinder().linkToDeath(new StatsdDeathRecipient(), 0); |
| } catch (RemoteException e) { |
| throw new StatsUnavailableException("could not connect when linkToDeath", e); |
| } |
| return mService; |
| } |
| |
| /** |
| * Exception thrown when communication with the stats service fails (eg if it is not available). |
| * This might be thrown early during boot before the stats service has started or if it crashed. |
| */ |
| public static class StatsUnavailableException extends AndroidException { |
| public StatsUnavailableException(String reason) { |
| super("Failed to connect to statsd: " + reason); |
| } |
| |
| public StatsUnavailableException(String reason, Throwable e) { |
| super("Failed to connect to statsd: " + reason, e); |
| } |
| } |
| } |
