tp/ui: Add support for aflags

Trace Processor:
- Added android_aflags table in android_tables.py.
- Implemented parsing for AndroidAflags packets in AndroidProbesParser.
- Added aflags.sql standard library module with android_aflags view.
- Added diff tests in tests_aflags.py.

UI:
- Updated TraceInfoPage Android tab to display aflags data.
- Added a new 'Android Aflags' section with a detailed grid.

Test: diff_test_trace_processor.py --name-filter='AndroidAflags'
Test: Manually verified UI with a trace containing aflags
Change-Id: I1314b3017e23f94a66748b4e3e908c70beda715f

Author: sashwinbalaji

Android.bp

@@ -16522,6 +16522,7 @@ filegroup {
 genrule {
     name: "perfetto_src_trace_processor_perfetto_sql_stdlib_stdlib",
     srcs: [
+        "src/trace_processor/perfetto_sql/stdlib/android/aflags.sql",
         "src/trace_processor/perfetto_sql/stdlib/android/anrs.sql",
         "src/trace_processor/perfetto_sql/stdlib/android/app_process_starts.sql",
         "src/trace_processor/perfetto_sql/stdlib/android/auto/multiuser.sql",

BUILD

@@ -3627,6 +3627,7 @@ perfetto_filegroup(
 perfetto_filegroup(
     name = "src_trace_processor_perfetto_sql_stdlib_android_android",
     srcs = [
+        "src/trace_processor/perfetto_sql/stdlib/android/aflags.sql",
         "src/trace_processor/perfetto_sql/stdlib/android/anrs.sql",
         "src/trace_processor/perfetto_sql/stdlib/android/app_process_starts.sql",
         "src/trace_processor/perfetto_sql/stdlib/android/battery.sql",

src/trace_processor/importers/proto/android_probes_module.cc

@@ -68,6 +68,7 @@ AndroidProbesModule::AndroidProbesModule(
   RegisterForField(TracePacket::kPowerRailsFieldNumber);
   RegisterForField(TracePacket::kAndroidEnergyEstimationBreakdownFieldNumber);
   RegisterForField(TracePacket::kEntityStateResidencyFieldNumber);
+  RegisterForField(TracePacket::kAndroidAflagsFieldNumber);
   RegisterForField(TracePacket::kAndroidLogFieldNumber);
   RegisterForField(TracePacket::kPackagesListFieldNumber);
   RegisterForField(TracePacket::kUserListFieldNumber);
@@ -230,6 +231,9 @@ void AndroidProbesModule::ParseTracePacketData(
     const TracePacketData&,
     uint32_t field_id) {
   switch (field_id) {
+    case TracePacket::kAndroidAflagsFieldNumber:
+      parser_.ParseAndroidAflags(ts, decoder.android_aflags());
+      return;
     case TracePacket::kAndroidLogFieldNumber:
       parser_.ParseAndroidLogPacket(ts, decoder.android_log());
       return;

src/trace_processor/importers/proto/android_probes_parser.cc

@@ -48,6 +48,7 @@
 #include "protos/perfetto/common/android_log_constants.pbzero.h"
 #include "protos/perfetto/common/builtin_clock.pbzero.h"
 #include "protos/perfetto/config/trace_config.pbzero.h"
+#include "protos/perfetto/trace/android/android_aflags.pbzero.h"
 #include "protos/perfetto/trace/android/android_game_intervention_list.pbzero.h"
 #include "protos/perfetto/trace/android/android_log.pbzero.h"
 #include "protos/perfetto/trace/android/android_system_property.pbzero.h"
@@ -151,7 +152,16 @@ AndroidProbesParser::AndroidProbesParser(TraceProcessorContext* context,
       power_rail_raw_name_id_(context->storage->InternString("raw_name")),
       power_rail_subsys_name_arg_id_(
           context->storage->InternString("subsystem_name")),
-      rail_packet_timestamp_id_(context->storage->InternString("packet_ts")) {}
+      rail_packet_timestamp_id_(context->storage->InternString("packet_ts")),
+      aflags_read_only_id_(context->storage->InternString("read-only")),
+      aflags_read_write_id_(context->storage->InternString("read-write")),
+      aflags_default_id_(context->storage->InternString("default")),
+      aflags_server_id_(context->storage->InternString("server")),
+      aflags_local_id_(context->storage->InternString("local")),
+      aflags_none_id_(context->storage->InternString("none")),
+      aflags_aconfigd_id_(context->storage->InternString("aconfigd")),
+      aflags_device_config_id_(context->storage->InternString("device_config")),
+      aflags_unspecified_id_(context->storage->InternString("unspecified")) {}
 
 void AndroidProbesParser::ParseRailDescriptor(
     const protos::pbzero::PowerRails_Decoder& evt) {
@@ -696,4 +706,67 @@ void AndroidProbesParser::ParseBtTraceEvent(int64_t ts, ConstBytes blob) {
       });
 }
 
+StringId AndroidProbesParser::ToPermissionId(int32_t permission) {
+  switch (permission) {
+    case protos::pbzero::AndroidAflags::FLAG_PERMISSION_READ_ONLY:
+      return aflags_read_only_id_;
+    case protos::pbzero::AndroidAflags::FLAG_PERMISSION_READ_WRITE:
+      return aflags_read_write_id_;
+    case protos::pbzero::AndroidAflags::FLAG_PERMISSION_UNSPECIFIED:
+    default:
+      return aflags_unspecified_id_;
+  }
+}
+
+StringId AndroidProbesParser::ToValuePickedFromId(int32_t picked_from) {
+  switch (picked_from) {
+    case protos::pbzero::AndroidAflags::VALUE_PICKED_FROM_DEFAULT:
+      return aflags_default_id_;
+    case protos::pbzero::AndroidAflags::VALUE_PICKED_FROM_SERVER:
+      return aflags_server_id_;
+    case protos::pbzero::AndroidAflags::VALUE_PICKED_FROM_LOCAL:
+      return aflags_local_id_;
+    case protos::pbzero::AndroidAflags::VALUE_PICKED_FROM_UNSPECIFIED:
+    default:
+      return aflags_unspecified_id_;
+  }
+}
+
+StringId AndroidProbesParser::ToStorageBackendId(int32_t backend) {
+  switch (backend) {
+    case protos::pbzero::AndroidAflags::FLAG_STORAGE_BACKEND_NONE:
+      return aflags_none_id_;
+    case protos::pbzero::AndroidAflags::FLAG_STORAGE_BACKEND_ACONFIGD:
+      return aflags_aconfigd_id_;
+    case protos::pbzero::AndroidAflags::FLAG_STORAGE_BACKEND_DEVICE_CONFIG:
+      return aflags_device_config_id_;
+    case protos::pbzero::AndroidAflags::FLAG_STORAGE_BACKEND_UNSPECIFIED:
+    default:
+      return aflags_unspecified_id_;
+  }
+}
+
+void AndroidProbesParser::ParseAndroidAflags(int64_t ts, ConstBytes blob) {
+  protos::pbzero::AndroidAflags::Decoder decoder(blob.data, blob.size);
+  for (auto it = decoder.flags(); it; ++it) {
+    protos::pbzero::AndroidAflags::Flag::Decoder flag(*it);
+
+    tables::AndroidAflagsTable::Row row;
+    row.ts = ts;
+    row.package = context_->storage->InternString(flag.package());
+    row.name = context_->storage->InternString(flag.name());
+    row.flag_namespace = context_->storage->InternString(flag.flag_namespace());
+    row.container = context_->storage->InternString(flag.container());
+    row.value = context_->storage->InternString(flag.value());
+    if (flag.has_staged_value()) {
+      row.staged_value = context_->storage->InternString(flag.staged_value());
+    }
+    row.permission = ToPermissionId(flag.permission());
+    row.value_picked_from = ToValuePickedFromId(flag.value_picked_from());
+    row.storage_backend = ToStorageBackendId(flag.storage_backend());
+
+    context_->storage->mutable_android_aflags_table()->Insert(row);
+  }
+}
+
 }  // namespace perfetto::trace_processor

src/trace_processor/importers/proto/android_probes_parser.h

@@ -21,6 +21,7 @@
 
 #include "perfetto/protozero/field.h"
 
+#include "protos/perfetto/trace/android/android_aflags.pbzero.h"
 #include "protos/perfetto/trace/power/power_rails.pbzero.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -49,11 +50,16 @@ class AndroidProbesParser {
   void ParseEntityStateResidency(int64_t ts, ConstBytes);
   void ParseInitialDisplayState(int64_t ts, ConstBytes);
   void ParseAndroidSystemProperty(int64_t ts, ConstBytes);
+  void ParseAndroidAflags(int64_t ts, ConstBytes);
   void ParseBtTraceEvent(int64_t ts, ConstBytes);
 
  private:
   void ParseAndroidLogEvent(int64_t ts, protozero::ConstBytes);
 
+  StringId ToPermissionId(int32_t);
+  StringId ToValuePickedFromId(int32_t);
+  StringId ToStorageBackendId(int32_t);
+
   TraceProcessorContext* const context_;
   AndroidProbesTracker* const tracker_;
 
@@ -75,6 +81,15 @@ class AndroidProbesParser {
   const StringId power_rail_raw_name_id_;
   const StringId power_rail_subsys_name_arg_id_;
   const StringId rail_packet_timestamp_id_;
+  const StringId aflags_read_only_id_;
+  const StringId aflags_read_write_id_;
+  const StringId aflags_default_id_;
+  const StringId aflags_server_id_;
+  const StringId aflags_local_id_;
+  const StringId aflags_none_id_;
+  const StringId aflags_aconfigd_id_;
+  const StringId aflags_device_config_id_;
+  const StringId aflags_unspecified_id_;
 };
 }  // namespace perfetto::trace_processor
 

src/trace_processor/perfetto_sql/stdlib/android/BUILD.gn

@@ -30,6 +30,7 @@ perfetto_sql_source_set("android") {
     "winscope",
   ]
   sources = [
+    "aflags.sql",
     "anrs.sql",
     "app_process_starts.sql",
     "battery.sql",

src/trace_processor/perfetto_sql/stdlib/android/aflags.sql

@@ -0,0 +1,62 @@
+--
+-- Copyright (C) 2026 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
+--
+--     https://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.
+--
+
+-- Android aconfig flags ("aflags") are a configuration system used to manage
+-- feature rollout and behavior across the Android platform.
+--
+-- For more details on aconfig, see:
+-- https://source.android.com/docs/setup/build/feature-flagging/declare-flag
+--
+-- This view presents snapshots of the state of these flags as captured
+-- during the trace. Data is collected by the `android.aflags` data-source,
+-- which periodically polls the `aflags` tool on Android devices.
+-- Each row in this view represents the state of a single flag at a specific
+-- point in time (the `ts` column).
+CREATE PERFETTO VIEW android_aflags (
+  -- Timestamp of the flag snapshot.
+  ts TIMESTAMP,
+  -- Package name of the flag (e.g. "com.android.window.flags").
+  package STRING,
+  -- Name of the flag within the package (e.g. "enable_multi_window").
+  name STRING,
+  -- The namespace this flag belongs to (often used for grouping).
+  flag_namespace STRING,
+  -- The container for the flag (e.g. "system", "product").
+  container STRING,
+  -- Current effective value of the flag at this timestamp.
+  value STRING,
+  -- The value this flag will take after the next reboot, if a change has
+  -- been staged.
+  staged_value STRING,
+  -- Whether the flag is read-only or read-write.
+  permission STRING,
+  -- Where the current value was picked from (e.g. "default", "local", "server").
+  value_picked_from STRING,
+  -- The underlying storage backend for this flag (e.g. "aconfigd", "device_config").
+  storage_backend STRING
+) AS
+SELECT
+  ts,
+  package,
+  name,
+  flag_namespace,
+  container,
+  value,
+  staged_value,
+  permission,
+  value_picked_from,
+  storage_backend
+FROM __intrinsic_android_aflags;

src/trace_processor/storage/trace_storage.h

@@ -413,6 +413,13 @@ class TraceStorage {
   const SqlStats& sql_stats() const { return sql_stats_; }
   SqlStats* mutable_sql_stats() { return &sql_stats_; }
 
+  const tables::AndroidAflagsTable& android_aflags_table() const {
+    return table<tables::AndroidAflagsTable>();
+  }
+  tables::AndroidAflagsTable* mutable_android_aflags_table() {
+    return mutable_table<tables::AndroidAflagsTable>();
+  }
+
   const tables::AndroidCpuPerUidTrackTable& android_cpu_per_uid_track_table()
       const {
     return table<tables::AndroidCpuPerUidTrackTable>();

src/trace_processor/tables/android_tables.py

@@ -359,8 +359,46 @@
             'android_user_id': '''User id on device''',
         }))
 
+ANDROID_AFLAGS_TABLE = Table(
+    python_module=__file__,
+    class_name='AndroidAflagsTable',
+    sql_name='__intrinsic_android_aflags',
+    columns=[
+        C('ts', CppInt64()),
+        C('package', CppString()),
+        C('name', CppString()),
+        C('flag_namespace', CppString()),
+        C('container', CppString()),
+        C('value', CppString()),
+        C('staged_value', CppOptional(CppString())),
+        C('permission', CppString()),
+        C('value_picked_from', CppString()),
+        C('storage_backend', CppString()),
+    ],
+    tabledoc=TableDoc(
+        doc='''
+          A table presenting all aconfig flags and their values.
+          This is generated by the android.aflags data-source.
+        ''',
+        group='Android',
+        columns={
+            'ts': 'Timestamp of the flag snapshot.',
+            'package': 'Package of the flag.',
+            'name': 'Name of the flag.',
+            'flag_namespace': 'Namespace of the flag.',
+            'container': 'Container of the flag.',
+            'value': 'Current value of the flag.',
+            'staged_value': 'Value of the flag after next reboot.',
+            'permission': 'Permission of the flag (read-only or read-write).',
+            'value_picked_from': 'Source of the current flag value.',
+            'storage_backend': 'The storage backend that owns this flag.',
+        },
+    ),
+)
+
 # Keep this list sorted.
 ALL_TABLES = [
+    ANDROID_AFLAGS_TABLE,
     ANDROID_CPU_PER_UID_TRACK_TABLE,
     ANDROID_DUMPSTATE_TABLE,
     ANDROID_GAME_INTERVENTION_LIST_TABLE,

src/trace_processor/trace_processor_impl.cc

@@ -1048,6 +1048,7 @@ std::vector<PerfettoSqlEngine::StaticTable> TraceProcessorImpl::GetStaticTables(
   std::vector<PerfettoSqlEngine::StaticTable> tables;
   AddStaticTable(tables, storage->mutable_aggregate_profile_table());
   AddStaticTable(tables, storage->mutable_aggregate_sample_table());
+  AddStaticTable(tables, storage->mutable_android_aflags_table());
   AddStaticTable(tables, storage->mutable_android_cpu_per_uid_track_table());
   AddStaticTable(tables, storage->mutable_android_dumpstate_table());
   AddStaticTable(tables,