1 /*
2 * Copyright (C) 2017 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 #define DEBUG false
18 #include "Log.h"
19
20 #include <android/os/IStatsCompanionService.h>
21 #include <android/os/IStatsPullerCallback.h>
22 #include <cutils/log.h>
23 #include <math.h>
24 #include <stdint.h>
25 #include <algorithm>
26 #include "../StatsService.h"
27 #include "../logd/LogEvent.h"
28 #include "../stats_log_util.h"
29 #include "../statscompanion_util.h"
30 #include "GpuStatsPuller.h"
31 #include "PowerStatsPuller.h"
32 #include "ResourceHealthManagerPuller.h"
33 #include "StatsCallbackPuller.h"
34 #include "StatsCompanionServicePuller.h"
35 #include "StatsPullerManager.h"
36 #include "SubsystemSleepStatePuller.h"
37 #include "TrainInfoPuller.h"
38 #include "statslog.h"
39
40 #include <iostream>
41
42 using std::make_shared;
43 using std::map;
44 using std::shared_ptr;
45 using std::string;
46 using std::vector;
47 using std::list;
48
49 namespace android {
50 namespace os {
51 namespace statsd {
52
53 // Values smaller than this may require to update the alarm.
54 const int64_t NO_ALARM_UPDATE = INT64_MAX;
55
56 std::map<int, PullAtomInfo> StatsPullerManager::kAllPullAtomInfo = {
57 // wifi_bytes_transfer
58 {android::util::WIFI_BYTES_TRANSFER,
59 {.additiveFields = {2, 3, 4, 5},
60 .puller = new StatsCompanionServicePuller(android::util::WIFI_BYTES_TRANSFER)}},
61 // wifi_bytes_transfer_by_fg_bg
62 {android::util::WIFI_BYTES_TRANSFER_BY_FG_BG,
63 {.additiveFields = {3, 4, 5, 6},
64 .puller = new StatsCompanionServicePuller(android::util::WIFI_BYTES_TRANSFER_BY_FG_BG)}},
65 // mobile_bytes_transfer
66 {android::util::MOBILE_BYTES_TRANSFER,
67 {.additiveFields = {2, 3, 4, 5},
68 .puller = new StatsCompanionServicePuller(android::util::MOBILE_BYTES_TRANSFER)}},
69 // mobile_bytes_transfer_by_fg_bg
70 {android::util::MOBILE_BYTES_TRANSFER_BY_FG_BG,
71 {.additiveFields = {3, 4, 5, 6},
72 .puller =
73 new StatsCompanionServicePuller(android::util::MOBILE_BYTES_TRANSFER_BY_FG_BG)}},
74 // bluetooth_bytes_transfer
75 {android::util::BLUETOOTH_BYTES_TRANSFER,
76 {.additiveFields = {2, 3},
77 .puller = new StatsCompanionServicePuller(android::util::BLUETOOTH_BYTES_TRANSFER)}},
78 // kernel_wakelock
79 {android::util::KERNEL_WAKELOCK,
80 {.puller = new StatsCompanionServicePuller(android::util::KERNEL_WAKELOCK)}},
81 // subsystem_sleep_state
82 {android::util::SUBSYSTEM_SLEEP_STATE, {.puller = new SubsystemSleepStatePuller()}},
83 // on_device_power_measurement
84 {android::util::ON_DEVICE_POWER_MEASUREMENT, {.puller = new PowerStatsPuller()}},
85 // cpu_time_per_freq
86 {android::util::CPU_TIME_PER_FREQ,
87 {.additiveFields = {3},
88 .puller = new StatsCompanionServicePuller(android::util::CPU_TIME_PER_FREQ)}},
89 // cpu_time_per_uid
90 {android::util::CPU_TIME_PER_UID,
91 {.additiveFields = {2, 3},
92 .puller = new StatsCompanionServicePuller(android::util::CPU_TIME_PER_UID)}},
93 // cpu_time_per_uid_freq
94 // the throttling is 3sec, handled in
95 // frameworks/base/core/java/com/android/internal/os/KernelCpuProcReader
96 {android::util::CPU_TIME_PER_UID_FREQ,
97 {.additiveFields = {4},
98 .puller = new StatsCompanionServicePuller(android::util::CPU_TIME_PER_UID_FREQ)}},
99 // cpu_active_time
100 // the throttling is 3sec, handled in
101 // frameworks/base/core/java/com/android/internal/os/KernelCpuProcReader
102 {android::util::CPU_ACTIVE_TIME,
103 {.additiveFields = {2},
104 .puller = new StatsCompanionServicePuller(android::util::CPU_ACTIVE_TIME)}},
105 // cpu_cluster_time
106 // the throttling is 3sec, handled in
107 // frameworks/base/core/java/com/android/internal/os/KernelCpuProcReader
108 {android::util::CPU_CLUSTER_TIME,
109 {.additiveFields = {3},
110 .puller = new StatsCompanionServicePuller(android::util::CPU_CLUSTER_TIME)}},
111 // wifi_activity_energy_info
112 {android::util::WIFI_ACTIVITY_INFO,
113 {.puller = new StatsCompanionServicePuller(android::util::WIFI_ACTIVITY_INFO)}},
114 // modem_activity_info
115 {android::util::MODEM_ACTIVITY_INFO,
116 {.puller = new StatsCompanionServicePuller(android::util::MODEM_ACTIVITY_INFO)}},
117 // bluetooth_activity_info
118 {android::util::BLUETOOTH_ACTIVITY_INFO,
119 {.puller = new StatsCompanionServicePuller(android::util::BLUETOOTH_ACTIVITY_INFO)}},
120 // system_elapsed_realtime
121 {android::util::SYSTEM_ELAPSED_REALTIME,
122 {.pullTimeoutNs = NS_PER_SEC / 2,
123 .coolDownNs = NS_PER_SEC,
124 .puller = new StatsCompanionServicePuller(android::util::SYSTEM_ELAPSED_REALTIME)}},
125 // system_uptime
126 {android::util::SYSTEM_UPTIME,
127 {.puller = new StatsCompanionServicePuller(android::util::SYSTEM_UPTIME)}},
128 // remaining_battery_capacity
129 {android::util::REMAINING_BATTERY_CAPACITY,
130 {.puller = new ResourceHealthManagerPuller(android::util::REMAINING_BATTERY_CAPACITY)}},
131 // full_battery_capacity
132 {android::util::FULL_BATTERY_CAPACITY,
133 {.puller = new ResourceHealthManagerPuller(android::util::FULL_BATTERY_CAPACITY)}},
134 // battery_voltage
135 {android::util::BATTERY_VOLTAGE,
136 {.puller = new ResourceHealthManagerPuller(android::util::BATTERY_VOLTAGE)}},
137 // battery_level
138 {android::util::BATTERY_LEVEL,
139 {.puller = new ResourceHealthManagerPuller(android::util::BATTERY_LEVEL)}},
140 // battery_cycle_count
141 {android::util::BATTERY_CYCLE_COUNT,
142 {.puller = new ResourceHealthManagerPuller(android::util::BATTERY_CYCLE_COUNT)}},
143 // process_memory_state
144 {android::util::PROCESS_MEMORY_STATE,
145 {.additiveFields = {4, 5, 6, 7, 8, 9},
146 .puller = new StatsCompanionServicePuller(android::util::PROCESS_MEMORY_STATE)}},
147 // native_process_memory_state
148 {android::util::NATIVE_PROCESS_MEMORY_STATE,
149 {.additiveFields = {3, 4, 5, 6, 8},
150 .puller = new StatsCompanionServicePuller(android::util::NATIVE_PROCESS_MEMORY_STATE)}},
151 // process_memory_high_water_mark
152 {android::util::PROCESS_MEMORY_HIGH_WATER_MARK,
153 {.additiveFields = {3},
154 .puller =
155 new StatsCompanionServicePuller(android::util::PROCESS_MEMORY_HIGH_WATER_MARK)}},
156 // system_ion_heap_size
157 {android::util::SYSTEM_ION_HEAP_SIZE,
158 {.puller = new StatsCompanionServicePuller(android::util::SYSTEM_ION_HEAP_SIZE)}},
159 // process_system_ion_heap_size
160 {android::util::PROCESS_SYSTEM_ION_HEAP_SIZE,
161 {.puller = new StatsCompanionServicePuller(android::util::PROCESS_SYSTEM_ION_HEAP_SIZE)}},
162 // temperature
163 {android::util::TEMPERATURE,
164 {.puller = new StatsCompanionServicePuller(android::util::TEMPERATURE)}},
165 // cooling_device
166 {android::util::COOLING_DEVICE,
167 {.puller = new StatsCompanionServicePuller(android::util::COOLING_DEVICE)}},
168 // binder_calls
169 {android::util::BINDER_CALLS,
170 {.additiveFields = {4, 5, 6, 8, 12},
171 .puller = new StatsCompanionServicePuller(android::util::BINDER_CALLS)}},
172 // binder_calls_exceptions
173 {android::util::BINDER_CALLS_EXCEPTIONS,
174 {.puller = new StatsCompanionServicePuller(android::util::BINDER_CALLS_EXCEPTIONS)}},
175 // looper_stats
176 {android::util::LOOPER_STATS,
177 {.additiveFields = {5, 6, 7, 8, 9},
178 .puller = new StatsCompanionServicePuller(android::util::LOOPER_STATS)}},
179 // Disk Stats
180 {android::util::DISK_STATS,
181 {.puller = new StatsCompanionServicePuller(android::util::DISK_STATS)}},
182 // Directory usage
183 {android::util::DIRECTORY_USAGE,
184 {.puller = new StatsCompanionServicePuller(android::util::DIRECTORY_USAGE)}},
185 // Size of app's code, data, and cache
186 {android::util::APP_SIZE,
187 {.puller = new StatsCompanionServicePuller(android::util::APP_SIZE)}},
188 // Size of specific categories of files. Eg. Music.
189 {android::util::CATEGORY_SIZE,
190 {.puller = new StatsCompanionServicePuller(android::util::CATEGORY_SIZE)}},
191 // Number of fingerprints enrolled for each user.
192 {android::util::NUM_FINGERPRINTS_ENROLLED,
193 {.puller = new StatsCompanionServicePuller(android::util::NUM_FINGERPRINTS_ENROLLED)}},
194 // Number of faces enrolled for each user.
195 {android::util::NUM_FACES_ENROLLED,
196 {.puller = new StatsCompanionServicePuller(android::util::NUM_FACES_ENROLLED)}},
197 // ProcStats.
198 {android::util::PROC_STATS,
199 {.puller = new StatsCompanionServicePuller(android::util::PROC_STATS)}},
200 // ProcStatsPkgProc.
201 {android::util::PROC_STATS_PKG_PROC,
202 {.puller = new StatsCompanionServicePuller(android::util::PROC_STATS_PKG_PROC)}},
203 // Disk I/O stats per uid.
204 {android::util::DISK_IO,
205 {.additiveFields = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
206 .coolDownNs = 3 * NS_PER_SEC,
207 .puller = new StatsCompanionServicePuller(android::util::DISK_IO)}},
208 // PowerProfile constants for power model calculations.
209 {android::util::POWER_PROFILE,
210 {.puller = new StatsCompanionServicePuller(android::util::POWER_PROFILE)}},
211 // Process cpu stats. Min cool-down is 5 sec, inline with what AcitivityManagerService uses.
212 {android::util::PROCESS_CPU_TIME,
213 {.coolDownNs = 5 * NS_PER_SEC /* min cool-down in seconds*/,
214 .puller = new StatsCompanionServicePuller(android::util::PROCESS_CPU_TIME)}},
215 {android::util::CPU_TIME_PER_THREAD_FREQ,
216 {.additiveFields = {7, 9, 11, 13, 15, 17, 19, 21},
217 .puller = new StatsCompanionServicePuller(android::util::CPU_TIME_PER_THREAD_FREQ)}},
218 // DeviceCalculatedPowerUse.
219 {android::util::DEVICE_CALCULATED_POWER_USE,
220 {.puller = new StatsCompanionServicePuller(android::util::DEVICE_CALCULATED_POWER_USE)}},
221 // DeviceCalculatedPowerBlameUid.
222 {android::util::DEVICE_CALCULATED_POWER_BLAME_UID,
223 {.puller = new StatsCompanionServicePuller(
224 android::util::DEVICE_CALCULATED_POWER_BLAME_UID)}},
225 // DeviceCalculatedPowerBlameOther.
226 {android::util::DEVICE_CALCULATED_POWER_BLAME_OTHER,
227 {.puller = new StatsCompanionServicePuller(
228 android::util::DEVICE_CALCULATED_POWER_BLAME_OTHER)}},
229 // DebugElapsedClock.
230 {android::util::DEBUG_ELAPSED_CLOCK,
231 {.additiveFields = {1, 2, 3, 4},
232 .puller = new StatsCompanionServicePuller(android::util::DEBUG_ELAPSED_CLOCK)}},
233 // DebugFailingElapsedClock.
234 {android::util::DEBUG_FAILING_ELAPSED_CLOCK,
235 {.additiveFields = {1, 2, 3, 4},
236 .puller = new StatsCompanionServicePuller(android::util::DEBUG_FAILING_ELAPSED_CLOCK)}},
237 // BuildInformation.
238 {android::util::BUILD_INFORMATION,
239 {.puller = new StatsCompanionServicePuller(android::util::BUILD_INFORMATION)}},
240 // RoleHolder.
241 {android::util::ROLE_HOLDER,
242 {.puller = new StatsCompanionServicePuller(android::util::ROLE_HOLDER)}},
243 // PermissionState.
244 {android::util::DANGEROUS_PERMISSION_STATE,
245 {.puller = new StatsCompanionServicePuller(android::util::DANGEROUS_PERMISSION_STATE)}},
246 // TrainInfo.
247 {android::util::TRAIN_INFO, {.puller = new TrainInfoPuller()}},
248 // TimeZoneDataInfo.
249 {android::util::TIME_ZONE_DATA_INFO,
250 {.puller = new StatsCompanionServicePuller(android::util::TIME_ZONE_DATA_INFO)}},
251 // ExternalStorageInfo
252 {android::util::EXTERNAL_STORAGE_INFO,
253 {.puller = new StatsCompanionServicePuller(android::util::EXTERNAL_STORAGE_INFO)}},
254 // GpuStatsGlobalInfo
255 {android::util::GPU_STATS_GLOBAL_INFO,
256 {.puller = new GpuStatsPuller(android::util::GPU_STATS_GLOBAL_INFO)}},
257 // GpuStatsAppInfo
258 {android::util::GPU_STATS_APP_INFO,
259 {.puller = new GpuStatsPuller(android::util::GPU_STATS_APP_INFO)}},
260 // AppsOnExternalStorageInfo
261 {android::util::APPS_ON_EXTERNAL_STORAGE_INFO,
262 {.puller = new StatsCompanionServicePuller(android::util::APPS_ON_EXTERNAL_STORAGE_INFO)}},
263 // Face Settings
264 {android::util::FACE_SETTINGS,
265 {.puller = new StatsCompanionServicePuller(android::util::FACE_SETTINGS)}},
266 // App ops
267 {android::util::APP_OPS,
268 {.puller = new StatsCompanionServicePuller(android::util::APP_OPS)}},
269 };
270
StatsPullerManager()271 StatsPullerManager::StatsPullerManager() : mNextPullTimeNs(NO_ALARM_UPDATE) {
272 }
273
Pull(int tagId,vector<shared_ptr<LogEvent>> * data)274 bool StatsPullerManager::Pull(int tagId, vector<shared_ptr<LogEvent>>* data) {
275 VLOG("Initiating pulling %d", tagId);
276
277 if (kAllPullAtomInfo.find(tagId) != kAllPullAtomInfo.end()) {
278 bool ret = kAllPullAtomInfo.find(tagId)->second.puller->Pull(data);
279 VLOG("pulled %d items", (int)data->size());
280 if (!ret) {
281 StatsdStats::getInstance().notePullFailed(tagId);
282 }
283 return ret;
284 } else {
285 VLOG("Unknown tagId %d", tagId);
286 return false; // Return early since we don't know what to pull.
287 }
288 }
289
PullerForMatcherExists(int tagId) const290 bool StatsPullerManager::PullerForMatcherExists(int tagId) const {
291 // Vendor pulled atoms might be registered after we parse the config.
292 return isVendorPulledAtom(tagId) || kAllPullAtomInfo.find(tagId) != kAllPullAtomInfo.end();
293 }
294
updateAlarmLocked()295 void StatsPullerManager::updateAlarmLocked() {
296 if (mNextPullTimeNs == NO_ALARM_UPDATE) {
297 VLOG("No need to set alarms. Skipping");
298 return;
299 }
300
301 sp<IStatsCompanionService> statsCompanionServiceCopy = mStatsCompanionService;
302 if (statsCompanionServiceCopy != nullptr) {
303 statsCompanionServiceCopy->setPullingAlarm(mNextPullTimeNs / 1000000);
304 } else {
305 VLOG("StatsCompanionService not available. Alarm not set.");
306 }
307 return;
308 }
309
SetStatsCompanionService(sp<IStatsCompanionService> statsCompanionService)310 void StatsPullerManager::SetStatsCompanionService(
311 sp<IStatsCompanionService> statsCompanionService) {
312 AutoMutex _l(mLock);
313 sp<IStatsCompanionService> tmpForLock = mStatsCompanionService;
314 mStatsCompanionService = statsCompanionService;
315 for (const auto& pulledAtom : kAllPullAtomInfo) {
316 pulledAtom.second.puller->SetStatsCompanionService(statsCompanionService);
317 }
318 if (mStatsCompanionService != nullptr) {
319 updateAlarmLocked();
320 }
321 }
322
RegisterReceiver(int tagId,wp<PullDataReceiver> receiver,int64_t nextPullTimeNs,int64_t intervalNs)323 void StatsPullerManager::RegisterReceiver(int tagId, wp<PullDataReceiver> receiver,
324 int64_t nextPullTimeNs, int64_t intervalNs) {
325 AutoMutex _l(mLock);
326 auto& receivers = mReceivers[tagId];
327 for (auto it = receivers.begin(); it != receivers.end(); it++) {
328 if (it->receiver == receiver) {
329 VLOG("Receiver already registered of %d", (int)receivers.size());
330 return;
331 }
332 }
333 ReceiverInfo receiverInfo;
334 receiverInfo.receiver = receiver;
335
336 // Round it to the nearest minutes. This is the limit of alarm manager.
337 // In practice, we should always have larger buckets.
338 int64_t roundedIntervalNs = intervalNs / NS_PER_SEC / 60 * NS_PER_SEC * 60;
339 // Scheduled pulling should be at least 1 min apart.
340 // This can be lower in cts tests, in which case we round it to 1 min.
341 if (roundedIntervalNs < 60 * (int64_t)NS_PER_SEC) {
342 roundedIntervalNs = 60 * (int64_t)NS_PER_SEC;
343 }
344
345 receiverInfo.intervalNs = roundedIntervalNs;
346 receiverInfo.nextPullTimeNs = nextPullTimeNs;
347 receivers.push_back(receiverInfo);
348
349 // There is only one alarm for all pulled events. So only set it to the smallest denom.
350 if (nextPullTimeNs < mNextPullTimeNs) {
351 VLOG("Updating next pull time %lld", (long long)mNextPullTimeNs);
352 mNextPullTimeNs = nextPullTimeNs;
353 updateAlarmLocked();
354 }
355 VLOG("Puller for tagId %d registered of %d", tagId, (int)receivers.size());
356 }
357
UnRegisterReceiver(int tagId,wp<PullDataReceiver> receiver)358 void StatsPullerManager::UnRegisterReceiver(int tagId, wp<PullDataReceiver> receiver) {
359 AutoMutex _l(mLock);
360 if (mReceivers.find(tagId) == mReceivers.end()) {
361 VLOG("Unknown pull code or no receivers: %d", tagId);
362 return;
363 }
364 auto& receivers = mReceivers.find(tagId)->second;
365 for (auto it = receivers.begin(); it != receivers.end(); it++) {
366 if (receiver == it->receiver) {
367 receivers.erase(it);
368 VLOG("Puller for tagId %d unregistered of %d", tagId, (int)receivers.size());
369 return;
370 }
371 }
372 }
373
OnAlarmFired(int64_t elapsedTimeNs)374 void StatsPullerManager::OnAlarmFired(int64_t elapsedTimeNs) {
375 AutoMutex _l(mLock);
376 int64_t wallClockNs = getWallClockNs();
377
378 int64_t minNextPullTimeNs = NO_ALARM_UPDATE;
379
380 vector<pair<int, vector<ReceiverInfo*>>> needToPull =
381 vector<pair<int, vector<ReceiverInfo*>>>();
382 for (auto& pair : mReceivers) {
383 vector<ReceiverInfo*> receivers = vector<ReceiverInfo*>();
384 if (pair.second.size() != 0) {
385 for (ReceiverInfo& receiverInfo : pair.second) {
386 if (receiverInfo.nextPullTimeNs <= elapsedTimeNs) {
387 receivers.push_back(&receiverInfo);
388 } else {
389 if (receiverInfo.nextPullTimeNs < minNextPullTimeNs) {
390 minNextPullTimeNs = receiverInfo.nextPullTimeNs;
391 }
392 }
393 }
394 if (receivers.size() > 0) {
395 needToPull.push_back(make_pair(pair.first, receivers));
396 }
397 }
398 }
399
400 for (const auto& pullInfo : needToPull) {
401 vector<shared_ptr<LogEvent>> data;
402 bool pullSuccess = Pull(pullInfo.first, &data);
403 if (pullSuccess) {
404 StatsdStats::getInstance().notePullDelay(
405 pullInfo.first, getElapsedRealtimeNs() - elapsedTimeNs);
406 } else {
407 VLOG("pull failed at %lld, will try again later", (long long)elapsedTimeNs);
408 }
409
410 // Convention is to mark pull atom timestamp at request time.
411 // If we pull at t0, puller starts at t1, finishes at t2, and send back
412 // at t3, we mark t0 as its timestamp, which should correspond to its
413 // triggering event, such as condition change at t0.
414 // Here the triggering event is alarm fired from AlarmManager.
415 // In ValueMetricProducer and GaugeMetricProducer we do same thing
416 // when pull on condition change, etc.
417 for (auto& event : data) {
418 event->setElapsedTimestampNs(elapsedTimeNs);
419 event->setLogdWallClockTimestampNs(wallClockNs);
420 }
421
422 for (const auto& receiverInfo : pullInfo.second) {
423 sp<PullDataReceiver> receiverPtr = receiverInfo->receiver.promote();
424 if (receiverPtr != nullptr) {
425 receiverPtr->onDataPulled(data, pullSuccess, elapsedTimeNs);
426 // We may have just come out of a coma, compute next pull time.
427 int numBucketsAhead =
428 (elapsedTimeNs - receiverInfo->nextPullTimeNs) / receiverInfo->intervalNs;
429 receiverInfo->nextPullTimeNs += (numBucketsAhead + 1) * receiverInfo->intervalNs;
430 if (receiverInfo->nextPullTimeNs < minNextPullTimeNs) {
431 minNextPullTimeNs = receiverInfo->nextPullTimeNs;
432 }
433 } else {
434 VLOG("receiver already gone.");
435 }
436 }
437 }
438
439 VLOG("mNextPullTimeNs: %lld updated to %lld", (long long)mNextPullTimeNs,
440 (long long)minNextPullTimeNs);
441 mNextPullTimeNs = minNextPullTimeNs;
442 updateAlarmLocked();
443 }
444
ForceClearPullerCache()445 int StatsPullerManager::ForceClearPullerCache() {
446 int totalCleared = 0;
447 for (const auto& pulledAtom : kAllPullAtomInfo) {
448 totalCleared += pulledAtom.second.puller->ForceClearCache();
449 }
450 return totalCleared;
451 }
452
ClearPullerCacheIfNecessary(int64_t timestampNs)453 int StatsPullerManager::ClearPullerCacheIfNecessary(int64_t timestampNs) {
454 int totalCleared = 0;
455 for (const auto& pulledAtom : kAllPullAtomInfo) {
456 totalCleared += pulledAtom.second.puller->ClearCacheIfNecessary(timestampNs);
457 }
458 return totalCleared;
459 }
460
RegisterPullerCallback(int32_t atomTag,const sp<IStatsPullerCallback> & callback)461 void StatsPullerManager::RegisterPullerCallback(int32_t atomTag,
462 const sp<IStatsPullerCallback>& callback) {
463 AutoMutex _l(mLock);
464 // Platform pullers cannot be changed.
465 if (!isVendorPulledAtom(atomTag)) {
466 VLOG("RegisterPullerCallback: atom tag %d is not vendor pulled", atomTag);
467 return;
468 }
469 VLOG("RegisterPullerCallback: adding puller for tag %d", atomTag);
470 StatsdStats::getInstance().notePullerCallbackRegistrationChanged(atomTag, /*registered=*/true);
471 kAllPullAtomInfo[atomTag] = {.puller = new StatsCallbackPuller(atomTag, callback)};
472 }
473
UnregisterPullerCallback(int32_t atomTag)474 void StatsPullerManager::UnregisterPullerCallback(int32_t atomTag) {
475 AutoMutex _l(mLock);
476 // Platform pullers cannot be changed.
477 if (!isVendorPulledAtom(atomTag)) {
478 return;
479 }
480 StatsdStats::getInstance().notePullerCallbackRegistrationChanged(atomTag, /*registered=*/false);
481 kAllPullAtomInfo.erase(atomTag);
482 }
483
484 } // namespace statsd
485 } // namespace os
486 } // namespace android
487