1 /*
2  * Copyright 2024 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 #pragma once
18 
19 #include "InputTracerInterface.h"
20 
21 #include <memory>
22 
23 #include "../Entry.h"
24 #include "InputTracingBackendInterface.h"
25 
26 namespace android::inputdispatcher::trace::impl {
27 
28 /**
29  * The tracer implementation for InputDispatcher.
30  *
31  * InputTracer's responsibility is to keep track of events as they are processed by InputDispatcher,
32  * and to write the events to the tracing backend when enough information is collected. InputTracer
33  * is not thread-safe.
34  *
35  * See the documentation in InputTracerInterface for the API surface.
36  */
37 class InputTracer : public InputTracerInterface {
38 public:
39     explicit InputTracer(std::unique_ptr<InputTracingBackendInterface>);
40     ~InputTracer() = default;
41     InputTracer(const InputTracer&) = delete;
42     InputTracer& operator=(const InputTracer&) = delete;
43 
44     std::unique_ptr<EventTrackerInterface> traceInboundEvent(const EventEntry&) override;
45     std::unique_ptr<EventTrackerInterface> createTrackerForSyntheticEvent() override;
46     void dispatchToTargetHint(const EventTrackerInterface&, const InputTarget&) override;
47     void eventProcessingComplete(const EventTrackerInterface&,
48                                  nsecs_t processingTimestamp) override;
49     std::unique_ptr<EventTrackerInterface> traceDerivedEvent(const EventEntry&,
50                                                              const EventTrackerInterface&) override;
51     void traceEventDispatch(const DispatchEntry&, const EventTrackerInterface&) override;
setInputMethodConnectionIsActive(bool isActive)52     void setInputMethodConnectionIsActive(bool isActive) override {
53         mIsImeConnectionActive = isActive;
54     }
55 
56 private:
57     std::unique_ptr<InputTracingBackendInterface> mBackend;
58     bool mIsImeConnectionActive{false};
59 
60     // The state of a tracked event, shared across all events derived from the original event.
61     struct EventState {
EventStateEventState62         explicit inline EventState(InputTracer& tracer) : tracer(tracer){};
63         ~EventState();
64 
65         void onEventProcessingComplete(nsecs_t processingTimestamp);
66 
67         InputTracer& tracer;
68         std::vector<const TracedEvent> events;
69         bool isEventProcessingComplete{false};
70         // A queue to hold dispatch args from being traced until event processing is complete.
71         std::vector<const WindowDispatchArgs> pendingDispatchArgs;
72         // The metadata should not be modified after event processing is complete.
73         TracedEventMetadata metadata{};
74     };
75 
76     // Get the event state associated with a tracking cookie.
77     std::shared_ptr<EventState>& getState(const EventTrackerInterface&);
78     bool isDerivedCookie(const EventTrackerInterface&);
79 
80     // Implementation of the event tracker cookie. The cookie holds the event state directly for
81     // convenience to avoid the overhead of tracking the state separately in InputTracer.
82     class EventTrackerImpl : public EventTrackerInterface {
83     public:
EventTrackerImpl(const std::shared_ptr<EventState> & state,bool isDerivedEvent)84         inline EventTrackerImpl(const std::shared_ptr<EventState>& state, bool isDerivedEvent)
85               : mState(state), mIsDerived(isDerivedEvent) {}
86         EventTrackerImpl(const EventTrackerImpl&) = default;
87 
88     private:
89         mutable std::shared_ptr<EventState> mState;
90         const bool mIsDerived;
91 
92         friend std::shared_ptr<EventState>& InputTracer::getState(const EventTrackerInterface&);
93         friend bool InputTracer::isDerivedCookie(const EventTrackerInterface&);
94     };
95 };
96 
97 } // namespace android::inputdispatcher::trace::impl
98