1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sensor_file_descriptor_listener.h"
17 #include "print_sensor_data.h"
18 #include "sensor_errors.h"
19
20 #undef LOG_TAG
21 #define LOG_TAG "SensorFileDescriptorListener"
22
23 namespace OHOS {
24 namespace Sensors {
25 using namespace OHOS::HiviewDFX;
26 using namespace OHOS::AppExecFwk;
27
28 namespace {
29 constexpr int32_t RECEIVE_DATA_SIZE = 100;
30 } // namespace
31
SensorFileDescriptorListener()32 SensorFileDescriptorListener::SensorFileDescriptorListener()
33 {
34 receiveDataBuff_ = new (std::nothrow) SensorData[RECEIVE_DATA_SIZE];
35 CHKPL(receiveDataBuff_);
36 }
37
~SensorFileDescriptorListener()38 SensorFileDescriptorListener::~SensorFileDescriptorListener()
39 {
40 CALL_LOG_ENTER;
41 if (receiveDataBuff_ != nullptr) {
42 delete[] receiveDataBuff_;
43 receiveDataBuff_ = nullptr;
44 }
45 }
46
OnReadable(int32_t fileDescriptor)47 void SensorFileDescriptorListener::OnReadable(int32_t fileDescriptor)
48 {
49 if (fileDescriptor < 0) {
50 SEN_HILOGE("fileDescriptor:%{public}d", fileDescriptor);
51 return;
52 }
53 CHKPV(channel_);
54 if (receiveDataBuff_ == nullptr) {
55 SEN_HILOGE("Receive data buff_ is null");
56 return;
57 }
58 channel_->ReceiveData([this] (int32_t length) {
59 this->ExcuteCallback(length);
60 }, receiveDataBuff_, sizeof(SensorData) * RECEIVE_DATA_SIZE);
61 }
62
ExcuteCallback(int32_t length)63 void SensorFileDescriptorListener::ExcuteCallback(int32_t length)
64 {
65 int32_t eventSize = static_cast<int32_t>(sizeof(SensorData));
66 int32_t num = length / eventSize;
67 if (num <= 0 || num > RECEIVE_DATA_SIZE) {
68 SEN_HILOGE("num:%{public}d is invalid", num);
69 return;
70 }
71 for (int i = 0; i < num; i++) {
72 SensorEvent event = {
73 .sensorTypeId = receiveDataBuff_[i].sensorTypeId,
74 .version = receiveDataBuff_[i].version,
75 .timestamp = receiveDataBuff_[i].timestamp,
76 .option = receiveDataBuff_[i].option,
77 .mode = receiveDataBuff_[i].mode,
78 .data = receiveDataBuff_[i].data,
79 .dataLen = receiveDataBuff_[i].dataLen,
80 .deviceId = receiveDataBuff_[i].deviceId,
81 .sensorId = receiveDataBuff_[i].sensorId,
82 .location = receiveDataBuff_[i].location
83 };
84 if (receiveDataBuff_[i].sensorTypeId == SENSOR_TYPE_ID_HALL_EXT) {
85 PrintSensorData::GetInstance().PrintSensorDataLog("ExcuteCallback", receiveDataBuff_[i]);
86 }
87 channel_->dataCB_(&event, 1, channel_->privateData_);
88 }
89 }
90
SetChannel(SensorDataChannel * channel)91 void SensorFileDescriptorListener::SetChannel(SensorDataChannel *channel)
92 {
93 SEN_HILOGI("In");
94 channel_ = channel;
95 }
96
OnShutdown(int32_t fileDescriptor)97 void SensorFileDescriptorListener::OnShutdown(int32_t fileDescriptor)
98 {
99 if (fileDescriptor < 0) {
100 SEN_HILOGE("Invalid fd:%{public}d", fileDescriptor);
101 }
102 if (receiveDataBuff_ != nullptr) {
103 delete[] receiveDataBuff_;
104 receiveDataBuff_ = nullptr;
105 }
106 CHKPV(channel_);
107 channel_->DestroySensorDataChannel();
108 }
109 } // namespace Sensors
110 } // namespace OHOS