1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SensorProxy_h
#define SensorProxy_h
#include "core/dom/ExceptionCode.h"
#include "core/page/PageVisibilityObserver.h"
#include "device/generic_sensor/public/cpp/sensor_reading.h"
#include "device/generic_sensor/public/interfaces/sensor.mojom-blink.h"
#include "device/generic_sensor/public/interfaces/sensor_provider.mojom-blink.h"
#include "mojo/public/cpp/bindings/binding.h"
#include "platform/Supplementable.h"
#include "platform/heap/Handle.h"
#include "wtf/Vector.h"
namespace blink {
class SensorProviderProxy;
class SensorReading;
class SensorReadingFactory;
class SensorReadingUpdater;
// This class wraps 'Sensor' mojo interface and used by multiple
// JS sensor instances of the same type (within a single frame).
class SensorProxy final : public GarbageCollectedFinalized<SensorProxy>,
public device::mojom::blink::SensorClient,
public PageVisibilityObserver {
USING_GARBAGE_COLLECTED_MIXIN(SensorProxy);
USING_PRE_FINALIZER(SensorProxy, dispose);
WTF_MAKE_NONCOPYABLE(SensorProxy);
public:
class Observer : public GarbageCollectedMixin {
public:
// Has valid 'Sensor' binding, {add, remove}Configuration()
// methods can be called.
virtual void onSensorInitialized() {}
// Platfrom sensort reading has changed.
// |timestamp| Reference timestamp in seconds of the moment when
// sensor reading was updated from the buffer.
// Note: |timestamp| values are only used to calculate elapsed time
// between shared buffer readings. These values *do not* correspond
// to sensor reading timestamps which are obtained on platform side.
virtual void onSensorReadingChanged(double timestamp) {}
// An error has occurred.
virtual void onSensorError(ExceptionCode,
const String& sanitizedMessage,
const String& unsanitizedMessage) {}
};
~SensorProxy();
void dispose();
void addObserver(Observer*);
void removeObserver(Observer*);
void initialize();
bool isInitializing() const { return m_state == Initializing; }
bool isInitialized() const { return m_state == Initialized; }
// Is watching new reading data (initialized, not suspended and has
// configurations added).
bool isActive() const;
void addConfiguration(device::mojom::blink::SensorConfigurationPtr,
std::unique_ptr<Function<void(bool)>>);
void removeConfiguration(device::mojom::blink::SensorConfigurationPtr);
void suspend();
void resume();
device::mojom::blink::SensorType type() const { return m_type; }
device::mojom::blink::ReportingMode reportingMode() const { return m_mode; }
// The |SensorReading| instance which is shared between sensor instances
// of the same type.
// Note: the returned value is reset after updateSensorReading() call.
SensorReading* sensorReading() const { return m_reading; }
const device::mojom::blink::SensorConfiguration* defaultConfig() const;
double maximumFrequency() const { return m_maximumFrequency; }
Document* document() const { return m_document; }
const WTF::Vector<double>& frequenciesUsed() const {
return m_frequenciesUsed;
}
DECLARE_VIRTUAL_TRACE();
private:
friend class SensorProviderProxy;
friend class SensorReadingUpdaterContinuous;
friend class SensorReadingUpdaterOnChange;
SensorProxy(device::mojom::blink::SensorType,
SensorProviderProxy*,
Document*,
std::unique_ptr<SensorReadingFactory>);
// Updates sensor reading from shared buffer.
void updateSensorReading();
void notifySensorChanged(double timestamp);
// device::mojom::blink::SensorClient overrides.
void RaiseError() override;
void SensorReadingChanged() override;
// PageVisibilityObserver overrides.
void pageVisibilityChanged() override;
// Generic handler for a fatal error.
// String parameters are intentionally copied.
void handleSensorError(ExceptionCode = UnknownError,
String sanitizedMessage = String(),
String unsanitizedMessage = String());
// mojo call callbacks.
void onSensorCreated(device::mojom::blink::SensorInitParamsPtr,
device::mojom::blink::SensorClientRequest);
void onAddConfigurationCompleted(
double frequency,
std::unique_ptr<Function<void(bool)>> callback,
bool result);
void onRemoveConfigurationCompleted(double frequency, bool result);
bool tryReadFromBuffer(device::SensorReading& result);
void onAnimationFrame(double timestamp);
device::mojom::blink::SensorType m_type;
device::mojom::blink::ReportingMode m_mode;
Member<SensorProviderProxy> m_provider;
using ObserversSet = HeapHashSet<WeakMember<Observer>>;
ObserversSet m_observers;
device::mojom::blink::SensorPtr m_sensor;
device::mojom::blink::SensorConfigurationPtr m_defaultConfig;
mojo::Binding<device::mojom::blink::SensorClient> m_clientBinding;
enum State { Uninitialized, Initializing, Initialized };
State m_state;
mojo::ScopedSharedBufferHandle m_sharedBufferHandle;
mojo::ScopedSharedBufferMapping m_sharedBuffer;
bool m_suspended;
Member<Document> m_document;
Member<SensorReading> m_reading;
std::unique_ptr<SensorReadingFactory> m_readingFactory;
double m_maximumFrequency;
Member<SensorReadingUpdater> m_readingUpdater;
WTF::Vector<double> m_frequenciesUsed;
double m_lastRafTimestamp;
using ReadingBuffer = device::SensorReadingSharedBuffer;
static_assert(
sizeof(ReadingBuffer) ==
device::mojom::blink::SensorInitParams::kReadBufferSizeForTests,
"Check reading buffer size for tests");
};
} // namespace blink
#endif // SensorProxy_h
|