mirror of
https://github.com/zhigang1992/react-native.git
synced 2026-06-14 23:39:15 +08:00
802534e611
Summary: In React Native there are several use cases where React State is not the only input that affects the component tree. E.g., in case of a <Modal> component, the screen size directly affects the layout of components inside modal; in the case of uncontrolled <TextInput> component, the text inside the input affects the layout of the surrounding components. `State` is a special (legit!) workaround for all those similar cases. Native part of React Native maintains a special shared object between all nodes of the same family and use that during cloning and commits. See coming commits to know how to use that. In the near future State will fully replace LocalData concept but for simplicity they both exist for now. Reviewed By: mdvacca Differential Revision: D14217184 fbshipit-source-id: 6e018c5b68208d662462013bce0f4e2733d2f673
115 lines
2.6 KiB
C++
115 lines
2.6 KiB
C++
/**
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#include "EventQueue.h"
|
|
|
|
#include "EventEmitter.h"
|
|
|
|
namespace facebook {
|
|
namespace react {
|
|
|
|
EventQueue::EventQueue(
|
|
EventPipe eventPipe,
|
|
StatePipe statePipe,
|
|
std::unique_ptr<EventBeat> eventBeat)
|
|
: eventPipe_(std::move(eventPipe)),
|
|
statePipe_(std::move(statePipe)),
|
|
eventBeat_(std::move(eventBeat)) {
|
|
eventBeat_->setBeatCallback(
|
|
std::bind(&EventQueue::onBeat, this, std::placeholders::_1));
|
|
}
|
|
|
|
void EventQueue::enqueueEvent(const RawEvent &rawEvent) const {
|
|
{
|
|
std::lock_guard<std::mutex> lock(queueMutex_);
|
|
eventQueue_.push_back(rawEvent);
|
|
}
|
|
|
|
onEnqueue();
|
|
}
|
|
|
|
void EventQueue::enqueueStateUpdate(const StateUpdate &stateUpdate) const {
|
|
{
|
|
std::lock_guard<std::mutex> lock(queueMutex_);
|
|
stateUpdateQueue_.push_back(stateUpdate);
|
|
}
|
|
|
|
onEnqueue();
|
|
}
|
|
|
|
void EventQueue::onEnqueue() const {
|
|
// Default implementation does nothing.
|
|
}
|
|
|
|
void EventQueue::onBeat(jsi::Runtime &runtime) const {
|
|
flushEvents(runtime);
|
|
flushStateUpdates();
|
|
}
|
|
|
|
void EventQueue::flushEvents(jsi::Runtime &runtime) const {
|
|
std::vector<RawEvent> queue;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(queueMutex_);
|
|
|
|
if (eventQueue_.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
queue = std::move(eventQueue_);
|
|
eventQueue_.clear();
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
|
|
|
|
for (const auto &event : queue) {
|
|
if (event.eventTarget) {
|
|
event.eventTarget->retain(runtime);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto &event : queue) {
|
|
eventPipe_(
|
|
runtime, event.eventTarget.get(), event.type, event.payloadFactory);
|
|
}
|
|
|
|
// No need to lock `EventEmitter::DispatchMutex()` here.
|
|
// The mutex protects from a situation when the `instanceHandle` can be
|
|
// deallocated during accessing, but that's impossible at this point because
|
|
// we have a strong pointer to it.
|
|
for (const auto &event : queue) {
|
|
if (event.eventTarget) {
|
|
event.eventTarget->release(runtime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void EventQueue::flushStateUpdates() const {
|
|
std::vector<StateUpdate> stateUpdateQueue;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(queueMutex_);
|
|
|
|
if (stateUpdateQueue_.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
stateUpdateQueue = std::move(stateUpdateQueue_);
|
|
stateUpdateQueue_.clear();
|
|
}
|
|
|
|
for (const auto &stateUpdate : stateUpdateQueue) {
|
|
auto pair = stateUpdate();
|
|
statePipe_(pair.second, pair.first);
|
|
}
|
|
}
|
|
|
|
} // namespace react
|
|
} // namespace facebook
|