Skip to content

Commit d3fe671

Browse files
wilhuffa-maurice
wilhuff
authored and
a-maurice
committed
Convert EventListener to the new JNI framework
PiperOrigin-RevId: 334212158
1 parent 3cc9467 commit d3fe671

File tree

3 files changed

+80
-167
lines changed

3 files changed

+80
-167
lines changed

‎firestore/src/android/event_listener_android.cc‎

Lines changed: 75 additions & 152 deletions
Original file line numberDiff line numberDiff line change
@@ -13,223 +13,146 @@
1313
#include "firestore/src/common/util.h"
1414
#include "firestore/src/include/firebase/firestore/query_snapshot.h"
1515
#include "firestore/src/jni/env.h"
16+
#include "firestore/src/jni/loader.h"
1617
#include "firebase/firestore/firestore_errors.h"
1718

1819
namespace firebase {
1920
namespace firestore {
2021
namespace {
2122

23+
using jni::Constructor;
2224
using jni::Env;
2325
using jni::Local;
26+
using jni::Method;
2427
using jni::Object;
2528

26-
} // namespace
29+
constexpr char kCppEventListenerClassName[] =
30+
"com/google/firebase/firestore/internal/cpp/CppEventListener";
31+
Method<void> kDiscardPointers("discardPointers", "()V");
32+
33+
constexpr char kDocumentEventListenerClassName[] =
34+
"com/google/firebase/firestore/internal/cpp/DocumentEventListener";
35+
Constructor<Object> kNewDocumentEventListener("(JJ)V");
36+
37+
constexpr char kQueryEventListenerClassName[] =
38+
"com/google/firebase/firestore/internal/cpp/QueryEventListener";
39+
Constructor<Object> kNewQueryEventListener("(JJ)V");
40+
41+
constexpr char kVoidEventListenerClassName[] =
42+
"com/google/firebase/firestore/internal/cpp/VoidEventListener";
43+
Constructor<Object> kNewVoidEventListener("(J)V");
2744

28-
#define CPP_EVENT_LISTENER_METHODS(X) \
29-
X(DiscardPointers, "discardPointers", "()V")
30-
METHOD_LOOKUP_DECLARATION(cpp_event_listener, CPP_EVENT_LISTENER_METHODS)
31-
METHOD_LOOKUP_DEFINITION(
32-
cpp_event_listener,
33-
"com/google/firebase/firestore/internal/cpp/CppEventListener",
34-
CPP_EVENT_LISTENER_METHODS)
35-
36-
#define DOCUMENT_EVENT_LISTENER_METHODS(X) X(Constructor, "<init>", "(JJ)V")
37-
METHOD_LOOKUP_DECLARATION(document_event_listener,
38-
DOCUMENT_EVENT_LISTENER_METHODS)
39-
METHOD_LOOKUP_DEFINITION(
40-
document_event_listener,
41-
"com/google/firebase/firestore/internal/cpp/DocumentEventListener",
42-
DOCUMENT_EVENT_LISTENER_METHODS)
43-
44-
#define QUERY_EVENT_LISTENER_METHODS(X) X(Constructor, "<init>", "(JJ)V")
45-
METHOD_LOOKUP_DECLARATION(query_event_listener, QUERY_EVENT_LISTENER_METHODS)
46-
METHOD_LOOKUP_DEFINITION(
47-
query_event_listener,
48-
"com/google/firebase/firestore/internal/cpp/QueryEventListener",
49-
QUERY_EVENT_LISTENER_METHODS)
50-
51-
#define VOID_EVENT_LISTENER_METHODS(X) X(Constructor, "<init>", "(J)V")
52-
METHOD_LOOKUP_DECLARATION(void_event_listener, VOID_EVENT_LISTENER_METHODS)
53-
METHOD_LOOKUP_DEFINITION(
54-
void_event_listener,
55-
"com/google/firebase/firestore/internal/cpp/VoidEventListener",
56-
VOID_EVENT_LISTENER_METHODS)
45+
} // namespace
5746

5847
/* static */
48+
void EventListenerInternal::Initialize(jni::Loader& loader) {
49+
loader.LoadClass(kCppEventListenerClassName, kDiscardPointers);
50+
51+
static const JNINativeMethod kDocumentEventListenerNatives[] = {
52+
{"nativeOnEvent",
53+
"(JJLjava/lang/Object;Lcom/google/firebase/firestore/"
54+
"FirebaseFirestoreException;)V",
55+
reinterpret_cast<void*>(
56+
&EventListenerInternal::DocumentEventListenerNativeOnEvent)}};
57+
loader.LoadClass(kDocumentEventListenerClassName, kNewDocumentEventListener);
58+
loader.RegisterNatives(kDocumentEventListenerNatives,
59+
FIREBASE_ARRAYSIZE(kDocumentEventListenerNatives));
60+
61+
static const JNINativeMethod kQueryEventListenerNatives[] = {
62+
{"nativeOnEvent",
63+
"(JJLjava/lang/Object;Lcom/google/firebase/firestore/"
64+
"FirebaseFirestoreException;)V",
65+
reinterpret_cast<void*>(
66+
&EventListenerInternal::QueryEventListenerNativeOnEvent)}};
67+
loader.LoadClass(kQueryEventListenerClassName, kNewQueryEventListener);
68+
loader.RegisterNatives(kQueryEventListenerNatives,
69+
FIREBASE_ARRAYSIZE(kQueryEventListenerNatives));
70+
71+
static const JNINativeMethod kVoidEventListenerNatives[] = {
72+
{"nativeOnEvent", "(J)V",
73+
reinterpret_cast<void*>(
74+
&EventListenerInternal::VoidEventListenerNativeOnEvent)}};
75+
loader.LoadClass(kVoidEventListenerClassName, kNewVoidEventListener);
76+
loader.RegisterNatives(kVoidEventListenerNatives,
77+
FIREBASE_ARRAYSIZE(kVoidEventListenerNatives));
78+
}
79+
5980
void EventListenerInternal::DocumentEventListenerNativeOnEvent(
60-
JNIEnv* env, jclass clazz, jlong firestore_ptr, jlong listener_ptr,
61-
jobject value, jobject error) {
81+
JNIEnv* env, jclass, jlong firestore_ptr, jlong listener_ptr, jobject value,
82+
jobject error) {
6283
if (firestore_ptr == 0 || listener_ptr == 0) {
6384
return;
6485
}
65-
EventListener<DocumentSnapshot>* listener =
86+
auto* listener =
6687
reinterpret_cast<EventListener<DocumentSnapshot>*>(listener_ptr);
88+
auto* firestore = reinterpret_cast<FirestoreInternal*>(firestore_ptr);
89+
6790
Error error_code =
6891
FirebaseFirestoreExceptionInternal::ToErrorCode(env, error);
6992
std::string error_message =
7093
FirebaseFirestoreExceptionInternal::ToString(env, error);
7194
if (error_code != Error::kErrorOk) {
72-
listener->OnEvent(DocumentSnapshot{}, error_code, error_message);
95+
listener->OnEvent({}, error_code, error_message);
7396
return;
7497
}
7598

76-
FirestoreInternal* firestore =
77-
reinterpret_cast<FirestoreInternal*>(firestore_ptr);
78-
DocumentSnapshot snapshot(new DocumentSnapshotInternal{firestore, value});
99+
DocumentSnapshot snapshot(new DocumentSnapshotInternal(firestore, value));
79100
listener->OnEvent(snapshot, error_code, error_message);
80101
}
81102

82103
/* static */
83-
void EventListenerInternal::QueryEventListenerNativeOnEvent(
84-
JNIEnv* env, jclass clazz, jlong firestore_ptr, jlong listener_ptr,
85-
jobject value, jobject error) {
104+
void EventListenerInternal::QueryEventListenerNativeOnEvent(JNIEnv* env, jclass,
105+
jlong firestore_ptr,
106+
jlong listener_ptr,
107+
jobject value,
108+
jobject error) {
86109
if (firestore_ptr == 0 || listener_ptr == 0) {
87110
return;
88111
}
89-
EventListener<QuerySnapshot>* listener =
112+
auto* listener =
90113
reinterpret_cast<EventListener<QuerySnapshot>*>(listener_ptr);
114+
auto* firestore = reinterpret_cast<FirestoreInternal*>(firestore_ptr);
115+
91116
Error error_code =
92117
FirebaseFirestoreExceptionInternal::ToErrorCode(env, error);
93118
std::string error_message =
94119
FirebaseFirestoreExceptionInternal::ToString(env, error);
95120
if (error_code != Error::kErrorOk) {
96-
listener->OnEvent(QuerySnapshot{}, error_code, error_message);
121+
listener->OnEvent({}, error_code, error_message);
97122
return;
98123
}
99124

100-
FirestoreInternal* firestore =
101-
reinterpret_cast<FirestoreInternal*>(firestore_ptr);
102-
QuerySnapshot snapshot(new QuerySnapshotInternal{firestore, value});
125+
QuerySnapshot snapshot(new QuerySnapshotInternal(firestore, value));
103126
listener->OnEvent(snapshot, error_code, error_message);
104127
}
105128

106129
/* static */
107-
void EventListenerInternal::VoidEventListenerNativeOnEvent(JNIEnv* env,
108-
jclass clazz,
130+
void EventListenerInternal::VoidEventListenerNativeOnEvent(JNIEnv*, jclass,
109131
jlong listener_ptr) {
110132
if (listener_ptr == 0) {
111133
return;
112134
}
113-
EventListener<void>* listener =
114-
reinterpret_cast<EventListener<void>*>(listener_ptr);
115-
135+
auto* listener = reinterpret_cast<EventListener<void>*>(listener_ptr);
116136
listener->OnEvent(Error::kErrorOk, EmptyString());
117137
}
118138

119139
Local<Object> EventListenerInternal::Create(
120140
Env& env, FirestoreInternal* firestore,
121141
EventListener<DocumentSnapshot>* listener) {
122-
return Local<Object>(env.get(), EventListenerToJavaEventListener(
123-
env.get(), firestore, listener));
124-
}
125-
126-
/* static */
127-
jobject EventListenerInternal::EventListenerToJavaEventListener(
128-
JNIEnv* env, FirestoreInternal* firestore,
129-
EventListener<DocumentSnapshot>* listener) {
130-
jobject result = env->NewObject(document_event_listener::GetClass(),
131-
document_event_listener::GetMethodId(
132-
document_event_listener::kConstructor),
133-
reinterpret_cast<jlong>(firestore),
134-
reinterpret_cast<jlong>(listener));
135-
CheckAndClearJniExceptions(env);
136-
return result;
142+
return env.New(kNewDocumentEventListener, reinterpret_cast<jlong>(firestore),
143+
reinterpret_cast<jlong>(listener));
137144
}
138145

139146
Local<Object> EventListenerInternal::Create(
140147
Env& env, FirestoreInternal* firestore,
141148
EventListener<QuerySnapshot>* listener) {
142-
return Local<Object>(env.get(), EventListenerToJavaEventListener(
143-
env.get(), firestore, listener));
144-
}
145-
146-
/* static */
147-
jobject EventListenerInternal::EventListenerToJavaEventListener(
148-
JNIEnv* env, FirestoreInternal* firestore,
149-
EventListener<QuerySnapshot>* listener) {
150-
jobject result = env->NewObject(
151-
query_event_listener::GetClass(),
152-
query_event_listener::GetMethodId(query_event_listener::kConstructor),
153-
reinterpret_cast<jlong>(firestore), reinterpret_cast<jlong>(listener));
154-
CheckAndClearJniExceptions(env);
155-
return result;
149+
return env.New(kNewQueryEventListener, reinterpret_cast<jlong>(firestore),
150+
reinterpret_cast<jlong>(listener));
156151
}
157152

158153
Local<Object> EventListenerInternal::Create(Env& env,
159154
EventListener<void>* listener) {
160-
return Local<Object>(env.get(),
161-
EventListenerToJavaRunnable(env.get(), listener));
162-
}
163-
164-
/* static */
165-
jobject EventListenerInternal::EventListenerToJavaRunnable(
166-
JNIEnv* env, EventListener<void>* listener) {
167-
jobject result = env->NewObject(
168-
void_event_listener::GetClass(),
169-
void_event_listener::GetMethodId(void_event_listener::kConstructor),
170-
reinterpret_cast<jlong>(listener));
171-
CheckAndClearJniExceptions(env);
172-
return result;
173-
}
174-
175-
/* static */
176-
bool EventListenerInternal::InitializeEmbeddedClasses(
177-
App* app, const std::vector<internal::EmbeddedFile>* embedded_files) {
178-
static const JNINativeMethod kDocumentEventListenerNatives[] = {
179-
{"nativeOnEvent",
180-
"(JJLjava/lang/Object;Lcom/google/firebase/firestore/"
181-
"FirebaseFirestoreException;)V",
182-
reinterpret_cast<void*>(
183-
&EventListenerInternal::DocumentEventListenerNativeOnEvent)}};
184-
static const JNINativeMethod kQueryEventListenerNatives[] = {
185-
{"nativeOnEvent",
186-
"(JJLjava/lang/Object;Lcom/google/firebase/firestore/"
187-
"FirebaseFirestoreException;)V",
188-
reinterpret_cast<void*>(
189-
&EventListenerInternal::QueryEventListenerNativeOnEvent)}};
190-
static const JNINativeMethod kVoidEventListenerNatives[] = {
191-
{"nativeOnEvent", "(J)V",
192-
reinterpret_cast<void*>(
193-
&EventListenerInternal::VoidEventListenerNativeOnEvent)}};
194-
195-
JNIEnv* env = app->GetJNIEnv();
196-
jobject activity = app->activity();
197-
bool result =
198-
// Cache classes
199-
cpp_event_listener::CacheClassFromFiles(env, activity, embedded_files) &&
200-
document_event_listener::CacheClassFromFiles(env, activity,
201-
embedded_files) &&
202-
query_event_listener::CacheClassFromFiles(env, activity,
203-
embedded_files) &&
204-
void_event_listener::CacheClassFromFiles(env, activity, embedded_files) &&
205-
// Cache method-ids
206-
cpp_event_listener::CacheMethodIds(env, activity) &&
207-
document_event_listener::CacheMethodIds(env, activity) &&
208-
query_event_listener::CacheMethodIds(env, activity) &&
209-
void_event_listener::CacheMethodIds(env, activity) &&
210-
// Register natives
211-
document_event_listener::RegisterNatives(
212-
env, kDocumentEventListenerNatives,
213-
FIREBASE_ARRAYSIZE(kDocumentEventListenerNatives)) &&
214-
query_event_listener::RegisterNatives(
215-
env, kQueryEventListenerNatives,
216-
FIREBASE_ARRAYSIZE(kQueryEventListenerNatives)) &&
217-
void_event_listener::RegisterNatives(
218-
env, kVoidEventListenerNatives,
219-
FIREBASE_ARRAYSIZE(kVoidEventListenerNatives));
220-
util::CheckAndClearJniExceptions(env);
221-
return result;
222-
}
223-
224-
/* static */
225-
void EventListenerInternal::Terminate(App* app) {
226-
JNIEnv* env = app->GetJNIEnv();
227-
// Release embedded classes.
228-
cpp_event_listener::ReleaseClass(env);
229-
document_event_listener::ReleaseClass(env);
230-
query_event_listener::ReleaseClass(env);
231-
void_event_listener::ReleaseClass(env);
232-
util::CheckAndClearJniExceptions(env);
155+
return env.New(kNewVoidEventListener, reinterpret_cast<jlong>(listener));
233156
}
234157

235158
} // namespace firestore

‎firestore/src/android/event_listener_android.h‎

Lines changed: 2 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,6 @@
11
#ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_ANDROID_EVENT_LISTENER_ANDROID_H_
22
#define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_ANDROID_EVENT_LISTENER_ANDROID_H_
33

4-
#include <jni.h>
5-
6-
#include "app/src/embedded_file.h"
74
#include "firestore/src/android/firestore_android.h"
85
#include "firestore/src/include/firebase/firestore/document_snapshot.h"
96
#include "firestore/src/include/firebase/firestore/event_listener.h"
@@ -14,6 +11,8 @@ namespace firestore {
1411

1512
class EventListenerInternal {
1613
public:
14+
static void Initialize(jni::Loader& loader);
15+
1716
static void DocumentEventListenerNativeOnEvent(JNIEnv* env, jclass clazz,
1817
jlong firestore_ptr,
1918
jlong listener_ptr,
@@ -46,13 +45,6 @@ class EventListenerInternal {
4645

4746
static jobject EventListenerToJavaRunnable(JNIEnv* env,
4847
EventListener<void>* listener);
49-
50-
private:
51-
friend class FirestoreInternal;
52-
53-
static bool InitializeEmbeddedClasses(
54-
App* app, const std::vector<internal::EmbeddedFile>* embedded_files);
55-
static void Terminate(App* app);
5648
};
5749

5850
} // namespace firestore

‎firestore/src/android/firestore_android.cc‎

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -201,6 +201,7 @@ bool FirestoreInternal::Initialize(App* app) {
201201
DocumentChangeTypeInternal::Initialize(loader);
202202
DocumentReferenceInternal::Initialize(loader);
203203
DocumentSnapshotInternal::Initialize(loader);
204+
EventListenerInternal::Initialize(loader);
204205
FieldPathConverter::Initialize(loader);
205206
GeoPointInternal::Initialize(loader);
206207
ListenerRegistrationInternal::Initialize(loader);
@@ -230,10 +231,8 @@ bool FirestoreInternal::Initialize(App* app) {
230231
bool FirestoreInternal::InitializeEmbeddedClasses(App* app, Loader& loader) {
231232
// Terminate() handles tearing this down.
232233
// Load embedded classes.
233-
return EventListenerInternal::InitializeEmbeddedClasses(
234-
app, loader.embedded_files()) &&
235-
TransactionInternal::InitializeEmbeddedClasses(
236-
app, loader.embedded_files());
234+
return TransactionInternal::InitializeEmbeddedClasses(
235+
app, loader.embedded_files());
237236
}
238237

239238
/* static */
@@ -242,7 +241,6 @@ void FirestoreInternal::ReleaseClasses(App* app) {
242241
loader_ = nullptr;
243242

244243
// Call Terminate on each Firestore internal class.
245-
EventListenerInternal::Terminate(app);
246244
FieldValueInternal::Terminate(app);
247245
FirebaseFirestoreExceptionInternal::Terminate(app);
248246
TransactionInternal::Terminate(app);

0 commit comments

Comments
 (0)