Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c7edaaa0 authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

InputTracer: s/TracedEventArgs/TracedEventMetadata 

Bug: 210460522
Test: atest inputflinger_tests
Change-Id: Ibd4f17fd47adf0e2af3a6910a9d81cc7f83043fe
parent bf3c8322

services/inputflinger/dispatcher/trace/InputTracer.cpp

+13 −13
Original line number Diff line number Diff line
@@ -61,10 +61,10 @@ TracedEvent createTracedEvent(const KeyEntry& e, EventType type) { 
                          e.downTime,  e.flags,     e.repeatCount, type};

}



void writeEventToBackend(const TracedEvent& event, const TracedEventArgs args,

void writeEventToBackend(const TracedEvent& event, const TracedEventMetadata metadata,

                         InputTracingBackendInterface& backend) {

    std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e, args); },

                       [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e, args); }},

    std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e, metadata); },

                       [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e, metadata); }},

               event);

}
@@ -177,9 +177,9 @@ std::unique_ptr<EventTrackerInterface> InputTracer::traceDerivedEvent( 
        // is dispatched, such as in the case of key fallback events. To account for these cases,

        // derived events can be traced after the processing is complete for the original event.

        const auto& event = eventState->events.back();

        const TracedEventArgs traceArgs{.isSecure = eventState->isSecure,

        const TracedEventMetadata metadata{.isSecure = eventState->isSecure,

                                           .targets = eventState->targets};

        writeEventToBackend(event, std::move(traceArgs), *mBackend);

        writeEventToBackend(event, std::move(metadata), *mBackend);

    }

    return std::make_unique<EventTrackerImpl>(std::move(eventState), /*isDerived=*/true);

}
@@ -226,9 +226,9 @@ void InputTracer::traceEventDispatch(const DispatchEntry& dispatchEntry, 
                                                /*hmac=*/{},

                                                resolvedKeyRepeatCount};

    if (eventState->isEventProcessingComplete) {

        const TracedEventArgs traceArgs{.isSecure = eventState->isSecure,

        const TracedEventMetadata metadata{.isSecure = eventState->isSecure,

                                           .targets = eventState->targets};

        mBackend->traceWindowDispatch(std::move(windowDispatchArgs), std::move(traceArgs));

        mBackend->traceWindowDispatch(std::move(windowDispatchArgs), std::move(metadata));

    } else {

        eventState->pendingDispatchArgs.emplace_back(std::move(windowDispatchArgs));

    }
@@ -248,8 +248,8 @@ bool InputTracer::isDerivedCookie(const EventTrackerInterface& cookie) { 
void InputTracer::EventState::onEventProcessingComplete() {

    // Write all of the events known so far to the trace.

    for (const auto& event : events) {

        const TracedEventArgs traceArgs{.isSecure = isSecure, .targets = targets};

        writeEventToBackend(event, traceArgs, *tracer.mBackend);

        const TracedEventMetadata metadata{.isSecure = isSecure, .targets = targets};

        writeEventToBackend(event, std::move(metadata), *tracer.mBackend);

    }

    // Write all pending dispatch args to the trace.

    for (const auto& windowDispatchArgs : pendingDispatchArgs) {
@@ -263,8 +263,8 @@ void InputTracer::EventState::onEventProcessingComplete() { 
                       << ": Failed to find a previously traced event that matches the dispatched "

                          "event";

        }

        const TracedEventArgs traceArgs{.isSecure = isSecure, .targets = targets};

        tracer.mBackend->traceWindowDispatch(windowDispatchArgs, std::move(traceArgs));

        const TracedEventMetadata metadata{.isSecure = isSecure, .targets = targets};

        tracer.mBackend->traceWindowDispatch(windowDispatchArgs, std::move(metadata));

    }

    pendingDispatchArgs.clear();

services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h

+4 −4
Original line number Diff line number Diff line
@@ -92,7 +92,7 @@ struct TracedMotionEvent { 
using TracedEvent = std::variant<TracedKeyEvent, TracedMotionEvent>;



/** Additional information about an input event being traced. */

struct TracedEventArgs {

struct TracedEventMetadata {

    // True if the event is targeting at least one secure window.

    bool isSecure;

    // The list of possible UIDs that this event could be targeting.
@@ -121,13 +121,13 @@ public: 
    virtual ~InputTracingBackendInterface() = default;



    /** Trace a KeyEvent. */

    virtual void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) = 0;

    virtual void traceKeyEvent(const TracedKeyEvent&, const TracedEventMetadata&) = 0;



    /** Trace a MotionEvent. */

    virtual void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) = 0;

    virtual void traceMotionEvent(const TracedMotionEvent&, const TracedEventMetadata&) = 0;



    /** Trace an event being sent to a window. */

    virtual void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) = 0;

    virtual void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventMetadata&) = 0;

};



} // namespace android::inputdispatcher::trace

services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp

+13 −12
Original line number Diff line number Diff line
@@ -98,10 +98,10 @@ bool PerfettoBackend::InputEventDataSource::shouldIgnoreTracedInputEvent( 
}



TraceLevel PerfettoBackend::InputEventDataSource::resolveTraceLevel(

        const TracedEventArgs& args) const {

        const TracedEventMetadata& metadata) const {

    // Check for matches with the rules in the order that they are defined.

    for (const auto& rule : mConfig.rules) {

        if (ruleMatches(rule, args)) {

        if (ruleMatches(rule, metadata)) {

            return rule.level;

        }

    }
@@ -110,17 +110,17 @@ TraceLevel PerfettoBackend::InputEventDataSource::resolveTraceLevel( 
}



bool PerfettoBackend::InputEventDataSource::ruleMatches(const TraceRule& rule,

                                                        const TracedEventArgs& args) const {

                                                        const TracedEventMetadata& metadata) const {

    // By default, a rule will match all events. Return early if the rule does not match.



    // Match the event if it is directed to a secure window.

    if (rule.matchSecure.has_value() && *rule.matchSecure != args.isSecure) {

    if (rule.matchSecure.has_value() && *rule.matchSecure != metadata.isSecure) {

        return false;

    }



    // Match the event if all of its target packages are explicitly allowed in the "match all" list.

    if (!rule.matchAllPackages.empty() &&

        !std::all_of(args.targets.begin(), args.targets.end(), [&](const auto& uid) {

        !std::all_of(metadata.targets.begin(), metadata.targets.end(), [&](const auto& uid) {

            return isPermanentlyAllowed(uid) ||

                    std::any_of(rule.matchAllPackages.begin(), rule.matchAllPackages.end(),

                                [&](const auto& pkg) { return uid == mUidMap->at(pkg); });
@@ -130,7 +130,7 @@ bool PerfettoBackend::InputEventDataSource::ruleMatches(const TraceRule& rule, 


    // Match the event if any of its target packages are allowed in the "match any" list.

    if (!rule.matchAnyPackages.empty() &&

        !std::any_of(args.targets.begin(), args.targets.end(), [&](const auto& uid) {

        !std::any_of(metadata.targets.begin(), metadata.targets.end(), [&](const auto& uid) {

            return std::any_of(rule.matchAnyPackages.begin(), rule.matchAnyPackages.end(),

                               [&](const auto& pkg) { return uid == mUidMap->at(pkg); });

        })) {
@@ -166,14 +166,14 @@ PerfettoBackend::PerfettoBackend(GetPackageUid getPackagesForUid) 
}



void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event,

                                       const TracedEventArgs& args) {

                                       const TracedEventMetadata& metadata) {

    InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) {

        auto dataSource = ctx.GetDataSourceLocked();

        dataSource->initializeUidMap(mGetPackageUid);

        if (dataSource->shouldIgnoreTracedInputEvent(event.eventType)) {

            return;

        }

        const TraceLevel traceLevel = dataSource->resolveTraceLevel(args);

        const TraceLevel traceLevel = dataSource->resolveTraceLevel(metadata);

        if (traceLevel == TraceLevel::TRACE_LEVEL_NONE) {

            return;

        }
@@ -186,14 +186,15 @@ void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event, 
    });

}



void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event, const TracedEventArgs& args) {

void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event,

                                    const TracedEventMetadata& metadata) {

    InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) {

        auto dataSource = ctx.GetDataSourceLocked();

        dataSource->initializeUidMap(mGetPackageUid);

        if (dataSource->shouldIgnoreTracedInputEvent(event.eventType)) {

            return;

        }

        const TraceLevel traceLevel = dataSource->resolveTraceLevel(args);

        const TraceLevel traceLevel = dataSource->resolveTraceLevel(metadata);

        if (traceLevel == TraceLevel::TRACE_LEVEL_NONE) {

            return;

        }
@@ -207,14 +208,14 @@ void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event, const TracedEve 
}



void PerfettoBackend::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs,

                                          const TracedEventArgs& args) {

                                          const TracedEventMetadata& metadata) {

    InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) {

        auto dataSource = ctx.GetDataSourceLocked();

        dataSource->initializeUidMap(mGetPackageUid);

        if (!dataSource->getFlags().test(TraceFlag::TRACE_DISPATCHER_WINDOW_DISPATCH)) {

            return;

        }

        const TraceLevel traceLevel = dataSource->resolveTraceLevel(args);

        const TraceLevel traceLevel = dataSource->resolveTraceLevel(metadata);

        if (traceLevel == TraceLevel::TRACE_LEVEL_NONE) {

            return;

        }

services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.h

+5 −5
Original line number Diff line number Diff line
@@ -54,9 +54,9 @@ public: 
    explicit PerfettoBackend(GetPackageUid);

    ~PerfettoBackend() override = default;



    void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) override;

    void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) override;

    void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) override;

    void traceKeyEvent(const TracedKeyEvent&, const TracedEventMetadata&) override;

    void traceMotionEvent(const TracedMotionEvent&, const TracedEventMetadata&) override;

    void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventMetadata&) override;



private:

    // Implementation of the perfetto data source.
@@ -72,13 +72,13 @@ private: 
        void initializeUidMap(GetPackageUid);

        bool shouldIgnoreTracedInputEvent(const EventType&) const;

        inline ftl::Flags<TraceFlag> getFlags() const { return mConfig.flags; }

        TraceLevel resolveTraceLevel(const TracedEventArgs&) const;

        TraceLevel resolveTraceLevel(const TracedEventMetadata&) const;



    private:

        const int32_t mInstanceId;

        TraceConfig mConfig;



        bool ruleMatches(const TraceRule&, const TracedEventArgs&) const;

        bool ruleMatches(const TraceRule&, const TracedEventMetadata&) const;



        std::optional<std::map<std::string, gui::Uid>> mUidMap;

    };

services/inputflinger/dispatcher/trace/ThreadedBackend.cpp

+6 −6
Original line number Diff line number Diff line
@@ -54,25 +54,25 @@ ThreadedBackend<Backend>::~ThreadedBackend() { 


template <typename Backend>

void ThreadedBackend<Backend>::traceMotionEvent(const TracedMotionEvent& event,

                                                const TracedEventArgs& traceArgs) {

                                                const TracedEventMetadata& metadata) {

    std::scoped_lock lock(mLock);

    mQueue.emplace_back(event, traceArgs);

    mQueue.emplace_back(event, metadata);

    mThreadWakeCondition.notify_all();

}



template <typename Backend>

void ThreadedBackend<Backend>::traceKeyEvent(const TracedKeyEvent& event,

                                             const TracedEventArgs& traceArgs) {

                                             const TracedEventMetadata& metadata) {

    std::scoped_lock lock(mLock);

    mQueue.emplace_back(event, traceArgs);

    mQueue.emplace_back(event, metadata);

    mThreadWakeCondition.notify_all();

}



template <typename Backend>

void ThreadedBackend<Backend>::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs,

                                                   const TracedEventArgs& traceArgs) {

                                                   const TracedEventMetadata& metadata) {

    std::scoped_lock lock(mLock);

    mQueue.emplace_back(dispatchArgs, traceArgs);

    mQueue.emplace_back(dispatchArgs, metadata);

    mThreadWakeCondition.notify_all();

}