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
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/android/binder_box.h"
#include <android/binder_ibinder.h>
#include <jni.h>
#include <cstddef>
#include <utility>
#include <vector>
#include "base/android/binder.h"
#include "base/android/scoped_java_ref.h"
#include "base/types/expected_macros.h"
namespace base::android {
namespace {
DEFINE_BINDER_CLASS(BinderBoxInterface);
// Binder transaction support for PackBinderBox() and UnpackBinderBox().
class BinderBox : public SupportsBinder<BinderBoxInterface> {
static constexpr transaction_code_t kUnpack = 1;
public:
explicit BinderBox(std::vector<BinderRef> binders)
: binders_(std::move(binders)) {}
ScopedJavaLocalRef<jobject> GetJavaBinder(JNIEnv* env) {
return GetBinder().ToJavaBinder(env);
}
static BinderStatusOr<std::vector<BinderRef>> Unpack(
JNIEnv* env,
const JavaRef<jobject>& box) {
auto proxy = TypedBinderRef<BinderBoxInterface>::Adopt(
BinderRef::FromJavaBinder(env, box.obj()));
if (!proxy) {
return unexpected(STATUS_BAD_TYPE);
}
ASSIGN_OR_RETURN(auto parcel, proxy.PrepareTransaction());
ASSIGN_OR_RETURN(const auto reply,
proxy.Transact(kUnpack, std::move(parcel)));
ASSIGN_OR_RETURN(const size_t num_binders, reply.reader().ReadUint32());
std::vector<BinderRef> binders(num_binders);
for (size_t i = 0; i < num_binders; ++i) {
ASSIGN_OR_RETURN(binders[i], reply.reader().ReadBinder());
}
return binders;
}
private:
~BinderBox() override = default;
// SupportsBinder<BinderBoxInterface>:
BinderStatusOr<void> OnBinderTransaction(transaction_code_t code,
const ParcelReader& in,
const ParcelWriter& out) override {
if (code != kUnpack) {
return unexpected(STATUS_UNKNOWN_TRANSACTION);
}
const uint32_t num_binders = checked_cast<uint32_t>(binders_.size());
RETURN_IF_ERROR(out.WriteUint32(num_binders));
for (uint32_t i = 0; i < num_binders; ++i) {
RETURN_IF_ERROR(out.WriteBinder(binders_[i]));
}
binders_.clear();
return ok();
}
std::vector<BinderRef> binders_;
};
} // namespace
ScopedJavaLocalRef<jobject> PackBinderBox(JNIEnv* env,
std::vector<BinderRef> binders) {
if (binders.empty()) {
return nullptr;
}
return MakeRefCounted<BinderBox>(std::move(binders))->GetJavaBinder(env);
}
BinderStatusOr<std::vector<BinderRef>> UnpackBinderBox(
JNIEnv* env,
const JavaRef<jobject>& box) {
return BinderBox::Unpack(env, box);
}
} // namespace base::android
|
