giteadmin/script-astra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
script-astra/Android/Sdk/sources/android-35/android/app/StatsManager.java

1006 lines
43 KiB
Java
Raw Permalink Normal View History

init
2025-01-20 15:15:20 +00:00
/*
* 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 static android.Manifest.permission.READ_RESTRICTED_STATS;
import static android.provider.DeviceConfig.NAMESPACE_STATSD_JAVA;
import android.annotation.CallbackExecutor;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SystemApi;
import android.content.Context;
import android.os.Binder;
import android.os.Build;
import android.os.IPullAtomCallback;
import android.os.IPullAtomResultReceiver;
import android.os.IStatsManagerService;
import android.os.IStatsQueryCallback;
import android.os.OutcomeReceiver;
import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
import android.os.StatsFrameworkInitializer;
import android.provider.DeviceConfig;
import android.util.AndroidException;
import android.util.Log;
import android.util.StatsEvent;
import android.util.StatsEventParcel;
import androidx.annotation.RequiresApi;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.modules.utils.build.SdkLevel;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.BufferOverflowException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;
/**
* 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 static final Object sLock = new Object();
private final Context mContext;
@GuardedBy("sLock")
private IStatsManagerService mStatsManagerService;
/**
* 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";
/**
* Long array extra of the restricted metric ids present for the client.
*/
public static final String EXTRA_STATS_RESTRICTED_METRIC_IDS =
"android.app.extra.STATS_RESTRICTED_METRIC_IDS";
/**
* 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";
// Pull atom callback return codes.
/**
* Value indicating that this pull was successful and that the result should be used.
*
**/
public static final int PULL_SUCCESS = 0;
/**
* Value indicating that this pull was unsuccessful and that the result should not be used.
**/
public static final int PULL_SKIP = 1;
/**
* @hide
**/
@VisibleForTesting public static final long DEFAULT_COOL_DOWN_MILLIS = 1_000L; // 1 second.
/**
* @hide
**/
@VisibleForTesting public static final long DEFAULT_TIMEOUT_MILLIS = 1_500L; // 1.5 seconds.
/**
* 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.
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
// can throw IllegalArgumentException
service.addConfiguration(configKey, config, mContext.getOpPackageName());
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager when adding configuration");
throw new StatsUnavailableException("could not connect", e);
} catch (SecurityException e) {
throw new StatsUnavailableException(e.getMessage(), e);
} catch (IllegalStateException e) {
Log.e(TAG, "Failed to addConfig in statsmanager");
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.
*
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
service.removeConfiguration(configKey, mContext.getOpPackageName());
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager when removing configuration");
throw new StatsUnavailableException("could not connect", e);
} catch (SecurityException e) {
throw new StatsUnavailableException(e.getMessage(), e);
} catch (IllegalStateException e) {
Log.e(TAG, "Failed to removeConfig in statsmanager");
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}).
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
if (pendingIntent != null) {
service.setBroadcastSubscriber(configKey, subscriberId, pendingIntent,
mContext.getOpPackageName());
} else {
service.unsetBroadcastSubscriber(configKey, subscriberId,
mContext.getOpPackageName());
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager 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.
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
if (pendingIntent == null) {
service.removeDataFetchOperation(configKey, mContext.getOpPackageName());
} else {
service.setDataFetchOperation(configKey, pendingIntent,
mContext.getOpPackageName());
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager 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.
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
if (pendingIntent == null) {
service.removeActiveConfigsChangedOperation(mContext.getOpPackageName());
return new long[0];
} else {
return service.setActiveConfigsChangedOperation(pendingIntent,
mContext.getOpPackageName());
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager "
+ "when registering active configs 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 the restricted metrics
* for a specified config that are present for this client. This operation allows statsd to
* inform the client about the current restricted metric ids available to be queried for the
* specified config. This call can block on statsd.
*
* If there is no config in statsd that matches the provided config package and key, an empty
* list is returned. The pending intent will be tracked, and the operation will be called
* whenever a matching config is added.
*
* @param configKey The configKey passed by the package that added the config in
* StatsManager#addConfig
* @param configPackage The package that added the config in StatsManager#addConfig
* @param pendingIntent the PendingIntent to use when broadcasting info to caller.
* May be null, in which case it removes any associated pending intent
* for this client.
* @return A list of metric ids identifying the restricted metrics that are currently available
* to be queried for the specified config.
* If the pendingIntent is null, this will be an empty list.
* @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service
*/
@RequiresPermission(READ_RESTRICTED_STATS)
@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
public @NonNull long[] setRestrictedMetricsChangedOperation(long configKey,
@NonNull String configPackage,
@Nullable PendingIntent pendingIntent)
throws StatsUnavailableException {
synchronized (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
if (pendingIntent == null) {
service.removeRestrictedMetricsChangedOperation(configKey, configPackage);
return new long[0];
} else {
return service.setRestrictedMetricsChangedOperation(pendingIntent,
configKey, configPackage);
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager "
+ "when registering restricted metrics listener.");
throw new StatsUnavailableException("could not connect", e);
} catch (SecurityException e) {
throw new StatsUnavailableException(e.getMessage(), e);
}
}
}
/**
* Queries the underlying service based on query received and populates the OutcomeReceiver via
* callback. This call is blocking on statsd being available, but is otherwise nonblocking.
* i.e. the call can return before the query processing is done.
* <p>
* Two types of tables are supported: Metric tables and the device information table.
* </p>
* <p>
* The device information table is named device_info and contains the following columns:
* sdkVersion, model, product, hardware, device, osBuild, fingerprint, brand, manufacturer, and
* board. These columns correspond to {@link Build.VERSION.SDK_INT}, {@link Build.MODEL},
* {@link Build.PRODUCT}, {@link Build.HARDWARE}, {@link Build.DEVICE}, {@link Build.ID},
* {@link Build.FINGERPRINT}, {@link Build.BRAND}, {@link Build.MANUFACTURER},
* {@link Build.BOARD} respectively.
* </p>
* <p>
* The metric tables are named metric_METRIC_ID where METRIC_ID is the metric id that is part
* of the wire encoded config passed to {@link #addConfig(long, byte[])}. If the metric id is
* negative, then the '-' character is replaced with 'n' in the table name. Each metric table
* contains the 3 columns followed by n columns of the following form: atomId,
* elapsedTimestampNs, wallTimestampNs, field_1, field_2, field_3 ... field_n. These
* columns correspond to to the id of the atom from frameworks/proto_logging/stats/atoms.proto,
* time when the atom is recorded, and the data fields within each atom.
* </p>
* @param configKey The configKey passed by the package that added
* the config being queried in StatsManager#addConfig
* @param configPackage The package that added the config being queried in
* StatsManager#addConfig
* @param query the query object encapsulating a sql-string and necessary config to query
* underlying sql-based data store.
* @param executor the executor on which outcomeReceiver will be invoked.
* @param outcomeReceiver the receiver to be populated with cursor pointing to result data.
*/
@RequiresPermission(READ_RESTRICTED_STATS)
@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
public void query(long configKey, @NonNull String configPackage, @NonNull StatsQuery query,
@NonNull @CallbackExecutor Executor executor,
@NonNull OutcomeReceiver<StatsCursor, StatsQueryException> outcomeReceiver)
throws StatsUnavailableException {
if(query.getSqlDialect() != StatsQuery.DIALECT_SQLITE) {
executor.execute(() -> {
outcomeReceiver.onError(new StatsQueryException("Unsupported Sql Dialect"));
});
return;
}
StatsQueryCallbackInternal callbackInternal =
new StatsQueryCallbackInternal(outcomeReceiver, executor);
synchronized (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
service.querySql(query.getRawSql(), query.getMinSqlClientVersion(),
query.getPolicyConfig(), callbackInternal, configKey,
configPackage);
} catch (RemoteException | IllegalStateException e) {
throw new StatsUnavailableException("could not connect", 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.
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
if (getUseFileDescriptor()) {
return getDataWithFd(service, configKey, mContext.getOpPackageName());
} else {
return service.getData(configKey, mContext.getOpPackageName());
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager when getting data");
throw new StatsUnavailableException("could not connect", e);
} catch (SecurityException e) {
throw new StatsUnavailableException(e.getMessage(), e);
} catch (IllegalStateException e) {
Log.e(TAG, "Failed to getReports in statsmanager");
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.
* This call can block on statsd.
*
* @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 (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
return service.getMetadata(mContext.getOpPackageName());
} catch (RemoteException e) {
Log.e(TAG, "Failed to connect to statsmanager when getting metadata");
throw new StatsUnavailableException("could not connect", e);
} catch (SecurityException e) {
throw new StatsUnavailableException(e.getMessage(), e);
} catch (IllegalStateException e) {
Log.e(TAG, "Failed to getStatsMetadata in statsmanager");
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.
*
* This call can block on statsd.
*
* @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service
*/
@RequiresPermission(allOf = {DUMP, PACKAGE_USAGE_STATS})
public long[] getRegisteredExperimentIds()
throws StatsUnavailableException {
synchronized (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
return service.getRegisteredExperimentIds();
} catch (RemoteException e) {
if (DEBUG) {
Log.d(TAG,
"Failed to connect to StatsManagerService when getting "
+ "registered experiment IDs");
}
throw new StatsUnavailableException("could not connect", e);
} catch (SecurityException e) {
throw new StatsUnavailableException(e.getMessage(), e);
} catch (IllegalStateException e) {
Log.e(TAG, "Failed to getRegisteredExperimentIds in statsmanager");
throw new StatsUnavailableException(e.getMessage(), e);
}
}
}
/**
* Sets 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. This method should not be called by third-party apps.
*
* @param atomTag The tag of the atom for this puller callback.
* @param metadata Optional metadata specifying the timeout, cool down time, and
* additive fields for mapping isolated to host uids.
* @param executor The executor in which to run the callback.
* @param callback The callback to be invoked when the stats service pulls the atom.
*
*/
@RequiresPermission(android.Manifest.permission.REGISTER_STATS_PULL_ATOM)
public void setPullAtomCallback(int atomTag, @Nullable PullAtomMetadata metadata,
@NonNull @CallbackExecutor Executor executor,
@NonNull StatsPullAtomCallback callback) {
long coolDownMillis =
metadata == null ? DEFAULT_COOL_DOWN_MILLIS : metadata.mCoolDownMillis;
long timeoutMillis = metadata == null ? DEFAULT_TIMEOUT_MILLIS : metadata.mTimeoutMillis;
int[] additiveFields = metadata == null ? new int[0] : metadata.mAdditiveFields;
if (additiveFields == null) {
additiveFields = new int[0];
}
synchronized (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
PullAtomCallbackInternal rec =
new PullAtomCallbackInternal(atomTag, callback, executor);
service.registerPullAtomCallback(
atomTag, coolDownMillis, timeoutMillis, additiveFields, rec);
} catch (RemoteException e) {
throw new RuntimeException("Unable to register pull callback", e);
}
}
}
/**
* Clears a callback for an atom when that atom is to be pulled. Note that any ongoing
* pulls will still occur. This method should not be called by third-party apps.
*
* @param atomTag The tag of the atom of which to unregister
*
*/
@RequiresPermission(android.Manifest.permission.REGISTER_STATS_PULL_ATOM)
public void clearPullAtomCallback(int atomTag) {
synchronized (sLock) {
try {
IStatsManagerService service = getIStatsManagerServiceLocked();
service.unregisterPullAtomCallback(atomTag);
} catch (RemoteException e) {
throw new RuntimeException("Unable to unregister pull atom callback");
}
}
}
private static class PullAtomCallbackInternal extends IPullAtomCallback.Stub {
public final int mAtomId;
public final StatsPullAtomCallback mCallback;
public final Executor mExecutor;
PullAtomCallbackInternal(int atomId, StatsPullAtomCallback callback, Executor executor) {
mAtomId = atomId;
mCallback = callback;
mExecutor = executor;
}
@Override
public void onPullAtom(int atomTag, IPullAtomResultReceiver resultReceiver) {
final long token = Binder.clearCallingIdentity();
try {
mExecutor.execute(() -> {
List<StatsEvent> data = new ArrayList<>();
int successInt = mCallback.onPullAtom(atomTag, data);
boolean success = successInt == PULL_SUCCESS;
StatsEventParcel[] parcels = new StatsEventParcel[data.size()];
for (int i = 0; i < data.size(); i++) {
parcels[i] = new StatsEventParcel();
parcels[i].buffer = data.get(i).getBytes();
}
try {
resultReceiver.pullFinished(atomTag, success, parcels);
} catch (RemoteException e) {
Log.w(TAG, "StatsPullResultReceiver failed for tag " + mAtomId
+ " due to TransactionTooLarge. Calling pullFinish with no data");
StatsEventParcel[] emptyData = new StatsEventParcel[0];
try {
resultReceiver.pullFinished(atomTag, /*success=*/false, emptyData);
} catch (RemoteException nestedException) {
Log.w(TAG, "StatsPullResultReceiver failed for tag " + mAtomId
+ " with empty payload");
}
}
});
} finally {
Binder.restoreCallingIdentity(token);
}
}
}
/**
* Metadata required for registering a StatsPullAtomCallback.
* All fields are optional, and defaults will be used for fields that are unspecified.
*
*/
public static class PullAtomMetadata {
private final long mCoolDownMillis;
private final long mTimeoutMillis;
private final int[] mAdditiveFields;
// Private Constructor for builder
private PullAtomMetadata(long coolDownMillis, long timeoutMillis, int[] additiveFields) {
mCoolDownMillis = coolDownMillis;
mTimeoutMillis = timeoutMillis;
mAdditiveFields = additiveFields;
}
/**
* Builder for PullAtomMetadata.
*/
public static class Builder {
private long mCoolDownMillis;
private long mTimeoutMillis;
private int[] mAdditiveFields;
/**
* Returns a new PullAtomMetadata.Builder object for constructing PullAtomMetadata for
* StatsManager#registerPullAtomCallback
*/
public Builder() {
mCoolDownMillis = DEFAULT_COOL_DOWN_MILLIS;
mTimeoutMillis = DEFAULT_TIMEOUT_MILLIS;
mAdditiveFields = null;
}
/**
* Set the cool down time of the pull in milliseconds. If two successive pulls are
* issued within the cool down, a cached version of the first pull will be used for the
* second pull. The minimum allowed cool down is 1 second.
*/
@NonNull
public Builder setCoolDownMillis(long coolDownMillis) {
mCoolDownMillis = coolDownMillis;
return this;
}
/**
* Set the maximum time the pull can take in milliseconds. The maximum allowed timeout
* is 10 seconds.
*/
@NonNull
public Builder setTimeoutMillis(long timeoutMillis) {
mTimeoutMillis = timeoutMillis;
return this;
}
/**
* Set the additive fields of this pulled atom.
*
* This is only applicable for atoms which have a uid field. When tasks are run in
* isolated processes, the data will be attributed to the host uid. Additive fields
* will be combined when the non-additive fields are the same.
*/
@NonNull
public Builder setAdditiveFields(@NonNull int[] additiveFields) {
mAdditiveFields = additiveFields;
return this;
}
/**
* Builds and returns a PullAtomMetadata object with the values set in the builder and
* defaults for unset fields.
*/
@NonNull
public PullAtomMetadata build() {
return new PullAtomMetadata(mCoolDownMillis, mTimeoutMillis, mAdditiveFields);
}
}
/**
* Return the cool down time of this pull in milliseconds.
*/
public long getCoolDownMillis() {
return mCoolDownMillis;
}
/**
* Return the maximum amount of time this pull can take in milliseconds.
*/
public long getTimeoutMillis() {
return mTimeoutMillis;
}
/**
* Return the additive fields of this pulled atom.
*
* This is only applicable for atoms that have a uid field. When tasks are run in
* isolated processes, the data will be attributed to the host uid. Additive fields
* will be combined when the non-additive fields are the same.
*/
@Nullable
public int[] getAdditiveFields() {
return mAdditiveFields;
}
}
/**
* Callback interface for pulling atoms requested by the stats service.
*
*/
public interface StatsPullAtomCallback {
/**
* Pull data for the specified atom tag, filling in the provided list of StatsEvent data.
* @return {@link #PULL_SUCCESS} if the pull was successful, or {@link #PULL_SKIP} if not.
*/
int onPullAtom(int atomTag, @NonNull List<StatsEvent> data);
}
@GuardedBy("sLock")
private IStatsManagerService getIStatsManagerServiceLocked() {
if (mStatsManagerService != null) {
return mStatsManagerService;
}
mStatsManagerService = IStatsManagerService.Stub.asInterface(
StatsFrameworkInitializer
.getStatsServiceManager()
.getStatsManagerServiceRegisterer()
.get());
return mStatsManagerService;
}
private static class StatsQueryCallbackInternal extends IStatsQueryCallback.Stub {
OutcomeReceiver<StatsCursor, StatsQueryException> queryCallback;
Executor mExecutor;
StatsQueryCallbackInternal(OutcomeReceiver<StatsCursor, StatsQueryException> queryCallback,
@NonNull @CallbackExecutor Executor executor) {
this.queryCallback = queryCallback;
this.mExecutor = executor;
}
@Override
public void sendResults(String[] queryData, String[] columnNames, int[] columnTypes,
int rowCount) {
if (!SdkLevel.isAtLeastU()) {
throw new IllegalStateException(
"StatsManager#query is not available before Android U");
}
final long token = Binder.clearCallingIdentity();
try {
mExecutor.execute(() -> {
StatsCursor cursor = new StatsCursor(queryData, columnNames, columnTypes,
rowCount);
queryCallback.onResult(cursor);
});
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void sendFailure(String error) {
if (!SdkLevel.isAtLeastU()) {
throw new IllegalStateException(
"StatsManager#query is not available before Android U");
}
final long token = Binder.clearCallingIdentity();
try {
mExecutor.execute(() -> {
queryCallback.onError(new StatsQueryException(error));
});
} finally {
Binder.restoreCallingIdentity(token);
}
}
}
/**
* 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);
}
}
/**
* Exception thrown when executing a query in statsd fails for any reason. This might be thrown
* if the query is malformed or if there is a database error when executing the query.
*/
public static class StatsQueryException extends AndroidException {
public StatsQueryException(@NonNull String reason) {
super("Failed to query statsd: " + reason);
}
public StatsQueryException(@NonNull String reason, @NonNull Throwable e) {
super("Failed to query statsd: " + reason, e);
}
}
private static boolean getUseFileDescriptor() {
return SdkLevel.isAtLeastT();
}
private static final int MAX_BUFFER_SIZE = 1024 * 1024 * 20; // 20MB
private static final int CHUNK_SIZE = 1024 * 64; // 64kB
/**
* Executes a binder transaction with file descriptors.
*/
private static byte[] getDataWithFd(IStatsManagerService service, long configKey,
String packageName) throws IllegalStateException, RemoteException {
ParcelFileDescriptor[] pipe;
try {
pipe = ParcelFileDescriptor.createPipe();
} catch (IOException e) {
Log.e(TAG, "Failed to create a pipe to receive reports.", e);
throw new IllegalStateException("Failed to create a pipe to receive reports.", e);
}
ParcelFileDescriptor readFd = pipe[0];
ParcelFileDescriptor writeFd = pipe[1];
// StatsManagerService write/flush will block until read() will start to consume data.
// OTOH read cannot start until binder sync operation is over.
// To decouple this dependency call to StatsManagerService should be async
service.getDataFd(configKey, packageName, writeFd);
try {
writeFd.close();
} catch (IOException e) {
Log.e(TAG, "Failed to pass FD to StatsManagerService", e);
throw new IllegalStateException("Failed to pass FD to StatsManagerService.", e);
}
try (FileInputStream inputStream = new ParcelFileDescriptor.AutoCloseInputStream(readFd);
DataInputStream dataInputStream = new DataInputStream(inputStream)) {
byte[] chunk = new byte[CHUNK_SIZE];
// read 4 bytes determining size of the reports
final int expectedReportSize = dataInputStream.readInt();
if (expectedReportSize > MAX_BUFFER_SIZE || expectedReportSize <= 0) {
Log.e(TAG, "expectedReportSize must be in a range (0, MAX_BUFFER_SIZE]: "
+ expectedReportSize);
throw new IllegalStateException("expectedReportSize > MAX_BUFFER_SIZE.");
}
ByteBuffer resultBuffer = ByteBuffer.allocate(expectedReportSize);
// read chunk-by-chunk, it will block until next chunk is ready or until EOF symbol
// is read. EOF symbol is written by FD close(), which happens when async binder
// transaction is over.
int chunkLen = 0;
int readBytes = 0;
// -1 denotes EOF
while ((chunkLen = dataInputStream.read(chunk, 0, CHUNK_SIZE)) != -1) {
try {
resultBuffer.put(chunk, 0, chunkLen);
} catch (BufferOverflowException e) {
Log.e(TAG, "Failed to store report chunk", e);
throw new IllegalStateException("Failed to store report chunk.", e);
}
readBytes += chunkLen;
}
if (readBytes != expectedReportSize) {
throw new IllegalStateException("Incomplete data read from StatsManagerService.");
}
return resultBuffer.array();
} catch (IOException e) {
Log.e(TAG, "Failed to read report data from StatsManagerService", e);
throw new IllegalStateException("Failed to read report data from StatsManagerService.",
e);
}
}
}
Reference in New Issue Copy Permalink