diff --git a/include/input/Flags.h b/include/input/Flags.h
index 0f52e18..f43829f 100644
--- a/include/input/Flags.h
+++ b/include/input/Flags.h
@@ -16,6 +16,7 @@
 
 #include <android-base/stringprintf.h>
 
+#include <array>
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -28,6 +29,69 @@
 
 namespace android {
 
+namespace details {
+template <typename F, F V>
+constexpr std::optional<std::string_view> enum_value_name() {
+    // Should look something like (but all on one line):
+    //   std::optional<std::string_view>
+    //   android::details::enum_value_name()
+    //   [F = android::test::TestFlags, V = android::test::TestFlags::ONE]
+    std::string_view view = __PRETTY_FUNCTION__;
+    size_t templateStart = view.rfind("[");
+    size_t templateEnd = view.rfind("]");
+    if (templateStart == std::string::npos || templateEnd == std::string::npos) {
+        return std::nullopt;
+    }
+
+    // Extract the template parameters without the enclosing braces.
+    // Example (cont'd): F = android::test::TestFlags, V = android::test::TestFlags::ONE
+    view = view.substr(templateStart + 1, templateEnd - templateStart - 1);
+    size_t valStart = view.rfind("V = ");
+    if (valStart == std::string::npos) {
+        return std::nullopt;
+    }
+
+    // Example (cont'd): V = android::test::TestFlags::ONE
+    view = view.substr(valStart);
+    size_t nameStart = view.rfind("::");
+    if (nameStart == std::string::npos) {
+        return std::nullopt;
+    }
+
+    // Chop off the initial "::"
+    nameStart += 2;
+    return view.substr(nameStart);
+}
+
+template <typename F>
+inline constexpr auto flag_count = sizeof(F) * __CHAR_BIT__;
+
+template <typename F, typename T, T... I>
+constexpr auto generate_flag_values(std::integer_sequence<T, I...> seq) {
+    constexpr int count = seq.size();
+
+    std::array<F, count> values{};
+    for (int i = 0, v = 0; v < count; ++i) {
+        values[v++] = static_cast<F>(T{1} << i);
+    }
+
+    return values;
+}
+
+template <typename F>
+inline constexpr auto flag_values = generate_flag_values<F>(
+        std::make_integer_sequence<std::underlying_type_t<F>, flag_count<F>>{});
+
+template <typename F, std::size_t... I>
+constexpr auto generate_flag_names(std::index_sequence<I...>) noexcept {
+    return std::array<std::optional<std::string_view>, sizeof...(I)>{
+            {enum_value_name<F, flag_values<F>[I]>()...}};
+}
+
+template <typename F>
+inline constexpr auto flag_names =
+        generate_flag_names<F>(std::make_index_sequence<flag_count<F>>{});
+
 // A trait for determining whether a type is specifically an enum class or not.
 template <typename T, bool = std::is_enum_v<T>>
 struct is_enum_class : std::false_type {};
@@ -40,13 +104,28 @@
 
 template <typename T>
 inline constexpr bool is_enum_class_v = is_enum_class<T>::value;
+} // namespace details
+
+template <auto V>
+constexpr auto flag_name() {
+    using F = decltype(V);
+    return details::enum_value_name<F, V>();
+}
+
+template <typename F>
+constexpr std::optional<std::string_view> flag_name(F flag) {
+    using U = std::underlying_type_t<F>;
+    auto idx = __builtin_ctzl(static_cast<U>(flag));
+    return details::flag_names<F>[idx];
+}
 
 /* A class for handling flags defined by an enum or enum class in a type-safe way. */
-template <class F, typename = std::enable_if_t<std::is_enum_v<F>>>
+template <typename F>
 class Flags {
     // F must be an enum or its underlying type is undefined. Theoretically we could specialize this
     // further to avoid this restriction but in general we want to encourage the use of enums
     // anyways.
+    static_assert(std::is_enum_v<F>, "Flags type must be an enum");
     using U = typename std::underlying_type_t<F>;
 
 public:
@@ -59,10 +138,11 @@
     // should force them to be explicitly constructed from their underlying types to make full use
     // of the type checker.
     template <typename T = U>
-    constexpr Flags(T t, typename std::enable_if_t<!is_enum_class_v<F>, T>* = nullptr)
+    constexpr Flags(T t, typename std::enable_if_t<!details::is_enum_class_v<F>, T>* = nullptr)
           : mFlags(t) {}
     template <typename T = U>
-    explicit constexpr Flags(T t, typename std::enable_if_t<is_enum_class_v<F>, T>* = nullptr)
+    explicit constexpr Flags(T t,
+                             typename std::enable_if_t<details::is_enum_class_v<F>, T>* = nullptr)
           : mFlags(t) {}
 
     class Iterator {
@@ -176,14 +256,12 @@
      */
     U get() const { return mFlags; }
 
-    std::string string() const { return string(defaultStringify); }
-
-    std::string string(std::function<std::optional<std::string>(F)> stringify) const {
+    std::string string() const {
         std::string result;
         bool first = true;
         U unstringified = 0;
         for (const F f : *this) {
-            std::optional<std::string> flagString = stringify(f);
+            std::optional<std::string_view> flagString = flag_name(f);
             if (flagString) {
                 appendFlag(result, flagString.value(), first);
             } else {
@@ -205,8 +283,7 @@
 private:
     U mFlags;
 
-    static std::optional<std::string> defaultStringify(F) { return std::nullopt; }
-    static void appendFlag(std::string& str, const std::string& flag, bool& first) {
+    static void appendFlag(std::string& str, const std::string_view& flag, bool& first) {
         if (first) {
             first = false;
         } else {
@@ -220,12 +297,12 @@
 // as flags. In order to use these, add them via a `using namespace` declaration.
 namespace flag_operators {
 
-template <typename F, typename = std::enable_if_t<is_enum_class_v<F>>>
+template <typename F, typename = std::enable_if_t<details::is_enum_class_v<F>>>
 inline Flags<F> operator~(F f) {
     using U = typename std::underlying_type_t<F>;
     return static_cast<F>(~static_cast<U>(f));
 }
-template <typename F, typename = std::enable_if_t<is_enum_class_v<F>>>
+template <typename F, typename = std::enable_if_t<details::is_enum_class_v<F>>>
 Flags<F> operator|(F lhs, F rhs) {
     using U = typename std::underlying_type_t<F>;
     return static_cast<F>(static_cast<U>(lhs) | static_cast<U>(rhs));
diff --git a/include/input/InputWindow.h b/include/input/InputWindow.h
index 233c7ae..268a3b8 100644
--- a/include/input/InputWindow.h
+++ b/include/input/InputWindow.h
@@ -205,8 +205,6 @@
     status_t writeToParcel(android::Parcel* parcel) const override;
 
     status_t readFromParcel(const android::Parcel* parcel) override;
-
-    static std::optional<std::string> flagToString(Flag f);
 };
 
 /*