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
|
/*
* Copyright 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <aidl/android/hardware/graphics/composer3/CommandResultPayload.h>
#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
#include <inttypes.h>
#include <string.h>
#include <algorithm>
#include <limits>
#include <memory>
#include <vector>
#include "Util.h"
namespace aidl::android::hardware::graphics::composer3::impl {
class ComposerServiceWriter {
public:
ComposerServiceWriter() { reset(); }
virtual ~ComposerServiceWriter() { reset(); }
void reset() { mCommandsResults.clear(); }
void setError(int32_t index, int32_t errorCode) {
CommandError error;
error.commandIndex = index;
error.errorCode = errorCode;
mCommandsResults.emplace_back(std::move(error));
}
void setPresentOrValidateResult(int64_t display, PresentOrValidate::Result result) {
PresentOrValidate presentOrValidate;
presentOrValidate.display = display;
presentOrValidate.result = result;
mCommandsResults.emplace_back(std::move(presentOrValidate));
}
void setChangedCompositionTypes(int64_t display, const std::vector<int64_t>& layers,
const std::vector<Composition>& types) {
ChangedCompositionTypes changedCompositionTypes;
changedCompositionTypes.display = display;
changedCompositionTypes.layers.reserve(layers.size());
for (int i = 0; i < layers.size(); i++) {
auto layer = ChangedCompositionLayer{.layer = layers[i], .composition = types[i]};
changedCompositionTypes.layers.emplace_back(std::move(layer));
}
mCommandsResults.emplace_back(std::move(changedCompositionTypes));
}
void setDisplayRequests(int64_t display, int32_t displayRequestMask,
const std::vector<int64_t>& layers,
const std::vector<int32_t>& layerRequestMasks) {
DisplayRequest displayRequest;
displayRequest.display = display;
displayRequest.mask = displayRequestMask;
displayRequest.layerRequests.reserve(layers.size());
for (int i = 0; i < layers.size(); i++) {
auto layerRequest =
DisplayRequest::LayerRequest{.layer = layers[i], .mask = layerRequestMasks[i]};
displayRequest.layerRequests.emplace_back(std::move(layerRequest));
}
mCommandsResults.emplace_back(std::move(displayRequest));
}
void setPresentFence(int64_t display, ::ndk::ScopedFileDescriptor presentFence) {
if (presentFence.get() >= 0) {
PresentFence presentFenceCommand;
presentFenceCommand.fence = std::move(presentFence);
presentFenceCommand.display = display;
mCommandsResults.emplace_back(std::move(presentFenceCommand));
} else {
LOG(WARNING) << __func__ << ": invalid present fence " << presentFence.get();
}
}
void setReleaseFences(int64_t display, const std::vector<int64_t>& layers,
std::vector<::ndk::ScopedFileDescriptor> releaseFences) {
ReleaseFences releaseFencesCommand;
releaseFencesCommand.display = display;
for (int i = 0; i < layers.size(); i++) {
if (releaseFences[i].get() >= 0) {
ReleaseFences::Layer layer;
layer.layer = layers[i];
layer.fence = std::move(releaseFences[i]);
releaseFencesCommand.layers.emplace_back(std::move(layer));
} else {
LOG(WARNING) << __func__ << ": invalid release fence " << releaseFences[i].get();
}
}
mCommandsResults.emplace_back(std::move(releaseFencesCommand));
}
void setClientTargetProperty(int64_t display, const ClientTargetProperty& clientTargetProperty,
float brightness) {
ClientTargetPropertyWithBrightness clientTargetPropertyWithBrightness;
clientTargetPropertyWithBrightness.display = display;
clientTargetPropertyWithBrightness.clientTargetProperty = clientTargetProperty;
clientTargetPropertyWithBrightness.brightness = brightness;
mCommandsResults.emplace_back(std::move(clientTargetPropertyWithBrightness));
}
std::vector<CommandResultPayload> getPendingCommandResults() {
return std::move(mCommandsResults);
}
private:
std::vector<CommandResultPayload> mCommandsResults;
};
} // namespace aidl::android::hardware::graphics::composer3::impl
|
