FreeRDP
Loading...
Searching...
No Matches
android_freerdp.c
1/*
2 Android JNI Client Layer
3
4 Copyright 2010-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
5 Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz
6 Copyright 2013 Thincast Technologies GmbH, Author: Armin Novak
7 Copyright 2015 Bernhard Miklautz <bernhard.miklautz@thincast.com>
8 Copyright 2016 Thincast Technologies GmbH
9 Copyright 2016 Armin Novak <armin.novak@thincast.com>
10
11 This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
12 If a copy of the MPL was not distributed with this file, You can obtain one at
13 http://mozilla.org/MPL/2.0/.
14*/
15
16#include <freerdp/config.h>
17
18#include <locale.h>
19
20#include <jni.h>
21#include <stdio.h>
22#include <stdlib.h>
23#include <errno.h>
24
25#include <winpr/assert.h>
26#include <winpr/image.h>
27
28#include <freerdp/graphics.h>
29#include <freerdp/codec/rfx.h>
30#include <freerdp/gdi/gdi.h>
31#include <freerdp/gdi/gfx.h>
32#include <freerdp/client/rdpei.h>
33#include <freerdp/client/rdpgfx.h>
34#include <freerdp/client/cliprdr.h>
35#include <freerdp/codec/h264.h>
36#include <freerdp/codec/video.h>
37#include <freerdp/channels/channels.h>
38#include <freerdp/client/channels.h>
39#include <freerdp/client/cmdline.h>
40#include <freerdp/constants.h>
41#include <freerdp/locale/keyboard.h>
42#include <freerdp/primitives.h>
43#include <freerdp/version.h>
44#include <freerdp/settings.h>
45#include <freerdp/utils/signal.h>
46
47#include <android/bitmap.h>
48
49#include "android_jni_callback.h"
50#include "android_jni_utils.h"
51#include "android_cliprdr.h"
52#include "android_disp.h"
53#include "android_rail.h"
54#include "android_freerdp_jni.h"
55
56#if defined(WITH_GPROF)
57#include "jni/prof.h"
58#endif
59
60#define TAG CLIENT_TAG("android")
61
62/* Defines the JNI version supported by this library. */
63#define FREERDP_JNI_VERSION FREERDP_VERSION_FULL
64
65static jclass gJavaActivityClass;
66static jmethodID gOnPointerSetMethod;
67static jmethodID gOnRailWindowUpdateMethod;
68
69static UINT android_UpdateWindowFromSurface(RdpgfxClientContext* context, gdiGfxSurface* surface);
70
71static void android_OnChannelConnectedEventHandler(void* context,
72 const ChannelConnectedEventArgs* e)
73{
74 rdpSettings* settings;
75 androidContext* afc;
76
77 if (!context || !e)
78 {
79 WLog_FATAL(TAG, "(context=%p, EventArgs=%p", context, (void*)e);
80 return;
81 }
82
83 afc = (androidContext*)context;
84 settings = afc->common.context.settings;
85
86 if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
87 {
88 android_cliprdr_init(afc, (CliprdrClientContext*)e->pInterface);
89 }
90 else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
91 {
92 android_disp_init(afc, (DispClientContext*)e->pInterface);
93 }
94 else if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
95 {
96 android_rail_init(afc, (RailClientContext*)e->pInterface);
97 }
98 else if (strcmp(e->name, RDPGFX_DVC_CHANNEL_NAME) == 0)
99 {
100 freerdp_client_OnChannelConnectedEventHandler(context, e);
101 RdpgfxClientContext* gfx = (RdpgfxClientContext*)e->pInterface;
102 if (gfx)
103 gfx->UpdateWindowFromSurface = android_UpdateWindowFromSurface;
104 }
105 else
106 freerdp_client_OnChannelConnectedEventHandler(context, e);
107}
108
109static void android_OnChannelDisconnectedEventHandler(void* context,
110 const ChannelDisconnectedEventArgs* e)
111{
112 rdpSettings* settings;
113 androidContext* afc;
114
115 if (!context || !e)
116 {
117 WLog_FATAL(TAG, "(context=%p, EventArgs=%p", context, (void*)e);
118 return;
119 }
120
121 afc = (androidContext*)context;
122 settings = afc->common.context.settings;
123
124 if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
125 {
126 android_cliprdr_uninit(afc, (CliprdrClientContext*)e->pInterface);
127 }
128 else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
129 {
130 android_disp_uninit(afc, (DispClientContext*)e->pInterface);
131 }
132 else if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
133 {
134 android_rail_uninit(afc, (RailClientContext*)e->pInterface);
135 }
136 else
137 freerdp_client_OnChannelDisconnectedEventHandler(context, e);
138}
139
140static BOOL android_begin_paint(rdpContext* context)
141{
142 return TRUE;
143}
144
145static BOOL android_end_paint(rdpContext* context)
146{
147 HGDI_WND hwnd;
148 int ninvalid;
149 rdpGdi* gdi;
150 HGDI_RGN cinvalid;
151 int x1, y1, x2, y2;
152 androidContext* ctx = (androidContext*)context;
153 rdpSettings* settings;
154
155 if (!ctx || !context->instance)
156 return FALSE;
157
158 settings = context->settings;
159
160 if (!settings)
161 return FALSE;
162
163 gdi = context->gdi;
164
165 if (!gdi || !gdi->primary || !gdi->primary->hdc)
166 return FALSE;
167
168 hwnd = ctx->common.context.gdi->primary->hdc->hwnd;
169
170 if (!hwnd)
171 return FALSE;
172
173 ninvalid = hwnd->ninvalid;
174
175 if (ninvalid < 1)
176 return TRUE;
177
178 cinvalid = hwnd->cinvalid;
179
180 if (!cinvalid)
181 return FALSE;
182
183 x1 = cinvalid[0].x;
184 y1 = cinvalid[0].y;
185 x2 = cinvalid[0].x + cinvalid[0].w;
186 y2 = cinvalid[0].y + cinvalid[0].h;
187
188 for (int i = 0; i < ninvalid; i++)
189 {
190 x1 = MIN(x1, cinvalid[i].x);
191 y1 = MIN(y1, cinvalid[i].y);
192 x2 = MAX(x2, cinvalid[i].x + cinvalid[i].w);
193 y2 = MAX(y2, cinvalid[i].y + cinvalid[i].h);
194 }
195
196 freerdp_callback("OnGraphicsUpdate", "(JIIII)V", (jlong)context->instance, x1, y1, x2 - x1,
197 y2 - y1);
198
199 hwnd->invalid->null = TRUE;
200 hwnd->ninvalid = 0;
201 return TRUE;
202}
203
204static BOOL android_desktop_resize(rdpContext* context)
205{
206 WINPR_ASSERT(context);
207 WINPR_ASSERT(context->settings);
208 WINPR_ASSERT(context->instance);
209
210 const UINT32 width = freerdp_settings_get_uint32(context->settings, FreeRDP_DesktopWidth);
211 const UINT32 height = freerdp_settings_get_uint32(context->settings, FreeRDP_DesktopHeight);
212
213 if (context->gdi && !gdi_resize(context->gdi, width, height))
214 return FALSE;
215
216 freerdp_callback("OnGraphicsResize", "(JIII)V", (jlong)context->instance, width, height,
217 freerdp_settings_get_uint32(context->settings, FreeRDP_ColorDepth));
218 return TRUE;
219}
220
221static BOOL android_pre_connect(freerdp* instance)
222{
223 WINPR_ASSERT(instance);
224 WINPR_ASSERT(instance->context);
225
226 rdpSettings* settings = instance->context->settings;
227
228 if (!settings)
229 return FALSE;
230
231 int rc = PubSub_SubscribeChannelConnected(instance->context->pubSub,
232 android_OnChannelConnectedEventHandler);
233
234 if (rc != CHANNEL_RC_OK)
235 {
236 WLog_ERR(TAG, "Could not subscribe to connect event handler [%08X]", rc);
237 return FALSE;
238 }
239
240 rc = PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
241 android_OnChannelDisconnectedEventHandler);
242
243 if (rc != CHANNEL_RC_OK)
244 {
245 WLog_ERR(TAG, "Could not subscribe to disconnect event handler [%08X]", rc);
246 return FALSE;
247 }
248
249 freerdp_callback("OnPreConnect", "(J)V", (jlong)instance);
250 return TRUE;
251}
252
253typedef struct
254{
255 rdpPointer pointer;
256 size_t size;
257 void* data;
258} androidPointer;
259
260static BOOL android_Pointer_New(rdpContext* context, rdpPointer* pointer)
261{
262 WINPR_ASSERT(context);
263 WINPR_ASSERT(pointer);
264 WINPR_ASSERT(context->gdi);
265
266 androidPointer* ptr = (androidPointer*)pointer;
267 if (!ptr)
268 return FALSE;
269
270 ptr->size = 4ULL * pointer->width * pointer->height;
271 ptr->data = winpr_aligned_malloc(ptr->size, 16);
272 if (!ptr->data)
273 return FALSE;
274
275 if (!freerdp_image_copy_from_pointer_data(
276 ptr->data, PIXEL_FORMAT_BGRA32, 0, 0, 0, pointer->width, pointer->height,
277 pointer->xorMaskData, pointer->lengthXorMask, pointer->andMaskData,
278 pointer->lengthAndMask, pointer->xorBpp, &context->gdi->palette))
279 {
280 winpr_aligned_free(ptr->data);
281 ptr->data = nullptr;
282 return FALSE;
283 }
284
285 return TRUE;
286}
287
288static void android_Pointer_Free(rdpContext* context, rdpPointer* pointer)
289{
290 WINPR_UNUSED(context);
291 androidPointer* ptr = (androidPointer*)pointer;
292
293 if (ptr)
294 {
295 winpr_aligned_free(ptr->data);
296 ptr->data = nullptr;
297 }
298}
299
300static BOOL android_Pointer_Set(rdpContext* context, rdpPointer* pointer)
301{
302 WINPR_ASSERT(context);
303 WINPR_ASSERT(pointer);
304
305 androidPointer* ptr = (androidPointer*)pointer;
306 if (!ptr->data)
307 return FALSE;
308
309 const jsize nPixels = (jsize)(pointer->width * pointer->height);
310
311 JNIEnv* env = nullptr;
312 jboolean attached = jni_attach_thread(&env);
313
314 if (!gJavaActivityClass || !gOnPointerSetMethod)
315 goto done;
316
317 jintArray pixels = (*env)->NewIntArray(env, nPixels);
318 if (!pixels)
319 goto done;
320
321 (*env)->SetIntArrayRegion(env, pixels, 0, nPixels, (const jint*)ptr->data);
322 (*env)->CallStaticVoidMethod(env, gJavaActivityClass, gOnPointerSetMethod,
323 (jlong)context->instance, pixels, (jint)pointer->width,
324 (jint)pointer->height, (jint)pointer->xPos, (jint)pointer->yPos);
325 (*env)->DeleteLocalRef(env, pixels);
326done:
327 if (attached)
328 jni_detach_thread();
329
330 return TRUE;
331}
332
333static BOOL android_Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
334{
335 WINPR_ASSERT(context);
336
337 return TRUE;
338}
339
340static BOOL android_Pointer_SetNull(rdpContext* context)
341{
342 WINPR_ASSERT(context);
343
344 freerdp_callback("OnPointerSetNull", "(J)V", (jlong)context->instance);
345 return TRUE;
346}
347
348static BOOL android_Pointer_SetDefault(rdpContext* context)
349{
350 WINPR_ASSERT(context);
351
352 freerdp_callback("OnPointerSetDefault", "(J)V", (jlong)context->instance);
353 return TRUE;
354}
355
356static UINT android_UpdateWindowFromSurface(RdpgfxClientContext* context, gdiGfxSurface* surface)
357{
358 if (!context || !surface)
359 return CHANNEL_RC_OK;
360
361 rdpGdi* gdi = (rdpGdi*)context->custom;
362 if (!gdi || !gdi->context)
363 return CHANNEL_RC_OK;
364
365 const UINT32 width = surface->mappedWidth ? surface->mappedWidth : surface->width;
366 const UINT32 height = surface->mappedHeight ? surface->mappedHeight : surface->height;
367 if (width == 0 || height == 0)
368 return CHANNEL_RC_OK;
369
370 JNIEnv* env = nullptr;
371 jboolean attached = jni_attach_thread(&env);
372 if (!gJavaActivityClass || !gOnRailWindowUpdateMethod)
373 goto done;
374
375 const jsize nPixels = (jsize)(width * height);
376 jintArray pixels = (*env)->NewIntArray(env, nPixels);
377 if (!pixels)
378 goto done;
379
380 jint* dst = (*env)->GetIntArrayElements(env, pixels, nullptr);
381 if (dst)
382 {
383 freerdp_image_copy((BYTE*)dst, surface->format, width * 4, 0, 0, width, height,
384 surface->data, surface->format, surface->scanline, 0, 0, nullptr,
385 FREERDP_FLIP_NONE);
386
387 /* Force coloured pixels opaque (ARGB_8888 would otherwise blend the active window's
388 * frame away), but keep transparent black so menu corners/shadows stay see-through. */
389 const size_t total = (size_t)width * height;
390 for (size_t i = 0; i < total; i++)
391 {
392 const UINT32 px = (UINT32)dst[i];
393 if ((px & 0x00FFFFFFu) != 0)
394 dst[i] = (jint)(px | 0xFF000000u);
395 }
396 (*env)->ReleaseIntArrayElements(env, pixels, dst, 0);
397 }
398
399 freerdp* inst = gdi->context->instance;
400 (*env)->CallStaticVoidMethod(env, gJavaActivityClass, gOnRailWindowUpdateMethod, (jlong)inst,
401 (jlong)surface->windowId, (jint)width, (jint)height, pixels);
402 (*env)->DeleteLocalRef(env, pixels);
403done:
404 if (attached)
405 jni_detach_thread();
406 return CHANNEL_RC_OK;
407}
408
409static BOOL android_register_pointer(rdpGraphics* graphics)
410{
411 rdpPointer pointer = WINPR_C_ARRAY_INIT;
412
413 if (!graphics)
414 return FALSE;
415
416 pointer.size = sizeof(androidPointer);
417 pointer.New = android_Pointer_New;
418 pointer.Free = android_Pointer_Free;
419 pointer.Set = android_Pointer_Set;
420 pointer.SetNull = android_Pointer_SetNull;
421 pointer.SetDefault = android_Pointer_SetDefault;
422 pointer.SetPosition = android_Pointer_SetPosition;
423 graphics_register_pointer(graphics, &pointer);
424 return TRUE;
425}
426
427/* Keep in sync with LibFreeRDP.EXPERIMENTAL_*. */
428#define ANDROID_EXPERIMENTAL_REMOTEAPP 0
429#define ANDROID_EXPERIMENTAL_CAMERA 1
430
431static BOOL android_post_connect(freerdp* instance)
432{
433 WINPR_ASSERT(instance);
434 WINPR_ASSERT(instance->context);
435
436 rdpUpdate* update = instance->context->update;
437 WINPR_ASSERT(update);
438
439 rdpSettings* settings = instance->context->settings;
440 WINPR_ASSERT(settings);
441
442 if (freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationMode) &&
443 !freerdp_callback_bool_result("OnExperimentalFeature", "(JI)Z", (jlong)instance,
444 ANDROID_EXPERIMENTAL_REMOTEAPP))
445 return FALSE;
446
447 if (freerdp_dynamic_channel_collection_find(settings, "rdpecam") &&
448 !freerdp_callback_bool_result("OnExperimentalFeature", "(JI)Z", (jlong)instance,
449 ANDROID_EXPERIMENTAL_CAMERA))
450 return FALSE;
451
452 if (!gdi_init(instance, PIXEL_FORMAT_RGBX32))
453 return FALSE;
454
455 if (!android_register_pointer(instance->context->graphics))
456 return FALSE;
457
458 update->BeginPaint = android_begin_paint;
459 update->EndPaint = android_end_paint;
460 update->DesktopResize = android_desktop_resize;
461 freerdp_callback("OnSettingsChanged", "(JIII)V", (jlong)instance,
462 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
463 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
464 freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
465 freerdp_callback("OnConnectionSuccess", "(J)V", (jlong)instance);
466 return TRUE;
467}
468
469static void android_post_disconnect(freerdp* instance)
470{
471 freerdp_callback("OnDisconnecting", "(J)V", (jlong)instance);
472 gdi_free(instance);
473}
474
475static void android_post_final_disconnect(freerdp* instance)
476{
477 WINPR_ASSERT(instance);
478 WINPR_ASSERT(instance->context);
479
480 PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
481 android_OnChannelConnectedEventHandler);
482 PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
483 android_OnChannelDisconnectedEventHandler);
484}
485
486static BOOL android_authenticate_int(freerdp* instance, char** username, char** password,
487 char** domain, const char* cb_name)
488{
489 JNIEnv* env;
490 jboolean attached = jni_attach_thread(&env);
491 jobject jstr1 = create_string_builder(env, *username);
492 jobject jstr2 = create_string_builder(env, *domain);
493 jobject jstr3 = create_string_builder(env, *password);
494 jboolean res;
495 res = freerdp_callback_bool_result(cb_name,
496 "(JLjava/lang/StringBuilder;"
497 "Ljava/lang/StringBuilder;"
498 "Ljava/lang/StringBuilder;)Z",
499 (jlong)instance, jstr1, jstr2, jstr3);
500
501 if (res == JNI_TRUE)
502 {
503 // read back string values
504 free(*username);
505 *username = get_string_from_string_builder(env, jstr1);
506 free(*domain);
507 *domain = get_string_from_string_builder(env, jstr2);
508 free(*password);
509 *password = get_string_from_string_builder(env, jstr3);
510 }
511
512 if (attached == JNI_TRUE)
513 jni_detach_thread();
514
515 return ((res == JNI_TRUE) ? TRUE : FALSE);
516}
517
518static BOOL android_authenticate_ex(freerdp* instance, char** username, char** password,
519 char** domain, rdp_auth_reason reason)
520{
521 switch (reason)
522 {
523 case AUTH_NLA:
524 case AUTH_TLS:
525 case AUTH_RDP:
526 return android_authenticate_int(instance, username, password, domain, "OnAuthenticate");
527 case GW_AUTH_HTTP:
528 case GW_AUTH_RDG:
529 case GW_AUTH_RPC:
530 return android_authenticate_int(instance, username, password, domain,
531 "OnGatewayAuthenticate");
532 default:
533 return FALSE;
534 }
535}
536
537static DWORD android_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
538 const char* common_name, const char* subject,
539 const char* issuer, const char* fingerprint, DWORD flags)
540{
541 WLog_DBG(TAG, "Certificate details [%s:%" PRIu16 ":", host, port);
542 WLog_DBG(TAG, "\tSubject: %s", subject);
543 WLog_DBG(TAG, "\tIssuer: %s", issuer);
544 WLog_DBG(TAG, "\tThumbprint: %s", fingerprint);
545 WLog_DBG(TAG,
546 "The above X.509 certificate could not be verified, possibly because you do not have "
547 "the CA certificate in your certificate store, or the certificate has expired."
548 "Please look at the OpenSSL documentation on how to add a private CA to the store.\n");
549 JNIEnv* env;
550 jboolean attached = jni_attach_thread(&env);
551 jstring jstr0 = (*env)->NewStringUTF(env, host);
552 jstring jstr1 = (*env)->NewStringUTF(env, common_name);
553 jstring jstr2 = (*env)->NewStringUTF(env, subject);
554 jstring jstr3 = (*env)->NewStringUTF(env, issuer);
555 jstring jstr4 = (*env)->NewStringUTF(env, fingerprint);
556 jint res = freerdp_callback_int_result("OnVerifyCertificateEx",
557 "(JLjava/lang/String;JLjava/lang/String;Ljava/lang/"
558 "String;Ljava/lang/String;Ljava/lang/String;J)I",
559 (jlong)instance, jstr0, (jlong)port, jstr1, jstr2, jstr3,
560 jstr4, (jlong)flags);
561
562 if (attached == JNI_TRUE)
563 jni_detach_thread();
564
565 return res;
566}
567
568static DWORD android_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
569 const char* common_name, const char* subject,
570 const char* issuer, const char* new_fingerprint,
571 const char* old_subject, const char* old_issuer,
572 const char* old_fingerprint, DWORD flags)
573{
574 JNIEnv* env;
575 jboolean attached = jni_attach_thread(&env);
576 jstring jhost = (*env)->NewStringUTF(env, host);
577 jstring jstr0 = (*env)->NewStringUTF(env, common_name);
578 jstring jstr1 = (*env)->NewStringUTF(env, subject);
579 jstring jstr2 = (*env)->NewStringUTF(env, issuer);
580 jstring jstr3 = (*env)->NewStringUTF(env, new_fingerprint);
581 jstring jstr4 = (*env)->NewStringUTF(env, old_subject);
582 jstring jstr5 = (*env)->NewStringUTF(env, old_issuer);
583 jstring jstr6 = (*env)->NewStringUTF(env, old_fingerprint);
584 jint res =
585 freerdp_callback_int_result("OnVerifyChangedCertificateEx",
586 "(JLjava/lang/String;JLjava/lang/String;Ljava/lang/"
587 "String;Ljava/lang/String;Ljava/lang/String;"
588 "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;J)I",
589 (jlong)instance, jhost, (jlong)port, jstr0, jstr1, jstr2, jstr3,
590 jstr4, jstr5, jstr6, (jlong)flags);
591
592 if (attached == JNI_TRUE)
593 jni_detach_thread();
594
595 return res;
596}
597
598static int android_freerdp_run(freerdp* instance)
599{
600 WINPR_ASSERT(instance);
601
602 DWORD status = WAIT_FAILED;
603 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
604 HANDLE inputEvent = nullptr;
605 rdpContext* context = instance->context;
606 WINPR_ASSERT(context);
607
608 const rdpSettings* settings = context->settings;
609
610 inputEvent = android_get_handle(instance);
611
612 while (!freerdp_shall_disconnect_context(context))
613 {
614 DWORD count = 0;
615
616 handles[count++] = inputEvent;
617
618 DWORD tmp = freerdp_get_event_handles(context, &handles[count], 64 - count);
619
620 if (tmp == 0)
621 {
622 WLog_ERR(TAG, "freerdp_get_event_handles failed");
623 break;
624 }
625
626 count += tmp;
627 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
628
629 if (status == WAIT_FAILED)
630 {
631 WLog_ERR(TAG, "WaitForMultipleObjects failed with %u [%08X]", status,
632 (unsigned)GetLastError());
633 break;
634 }
635
636 if (!freerdp_check_event_handles(context))
637 {
638 if (!client_auto_reconnect(instance))
639 {
640 WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
641 status = GetLastError();
642 break;
643 }
644 }
645
646 if (freerdp_shall_disconnect_context(instance->context))
647 break;
648
649 if (android_check_handle(instance) != TRUE)
650 {
651 WLog_ERR(TAG, "Failed to check android file descriptor");
652 status = GetLastError();
653 break;
654 }
655 }
656
657disconnect:
658 WLog_INFO(TAG, "Prepare shutdown...");
659
660 return status;
661}
662
663static DWORD WINAPI android_thread_func(LPVOID param)
664{
665 DWORD status = ERROR_BAD_ARGUMENTS;
666 freerdp* instance = param;
667 WLog_DBG(TAG, "Start...");
668
669 WINPR_ASSERT(instance);
670 WINPR_ASSERT(instance->context);
671
672 if (freerdp_client_start(instance->context) != CHANNEL_RC_OK)
673 goto fail;
674
675 WLog_DBG(TAG, "Connect...");
676
677 if (!freerdp_connect(instance))
678 status = GetLastError();
679 else
680 {
681 status = android_freerdp_run(instance);
682 WLog_DBG(TAG, "Disconnect...");
683
684 if (!freerdp_disconnect(instance))
685 status = GetLastError();
686 }
687
688 WLog_DBG(TAG, "Stop...");
689
690 if (freerdp_client_stop(instance->context) != CHANNEL_RC_OK)
691 goto fail;
692
693fail:
694 WLog_DBG(TAG, "Session ended with %08" PRIX32 "", status);
695
696 if (status == CHANNEL_RC_OK)
697 freerdp_callback("OnDisconnected", "(J)V", (jlong)instance);
698 else
699 freerdp_callback("OnConnectionFailure", "(J)V", (jlong)instance);
700
701 WLog_DBG(TAG, "Quit.");
702 ExitThread(status);
703 return status;
704}
705
706static BOOL android_client_new(freerdp* instance, rdpContext* context)
707{
708 WINPR_ASSERT(instance);
709 WINPR_ASSERT(context);
710
711 if (!android_event_queue_init(instance))
712 return FALSE;
713
714 instance->PreConnect = android_pre_connect;
715 instance->PostConnect = android_post_connect;
716 instance->PostDisconnect = android_post_disconnect;
717 instance->PostFinalDisconnect = android_post_final_disconnect;
718 instance->AuthenticateEx = android_authenticate_ex;
719 instance->VerifyCertificateEx = android_verify_certificate_ex;
720 instance->VerifyChangedCertificateEx = android_verify_changed_certificate_ex;
721 instance->LogonErrorInfo = nullptr;
722 return TRUE;
723}
724
725static void android_client_free(freerdp* instance, rdpContext* context)
726{
727 if (!context)
728 return;
729
730 android_event_queue_uninit(instance);
731}
732
733static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
734{
735 WINPR_ASSERT(pEntryPoints);
736
737 ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
738
739 pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
740 pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
741 pEntryPoints->GlobalInit = nullptr;
742 pEntryPoints->GlobalUninit = nullptr;
743 pEntryPoints->ContextSize = sizeof(androidContext);
744 pEntryPoints->ClientNew = android_client_new;
745 pEntryPoints->ClientFree = android_client_free;
746 pEntryPoints->ClientStart = nullptr;
747 pEntryPoints->ClientStop = nullptr;
748 return 0;
749}
750
751JNIEXPORT jlong JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1new(
752 JNIEnv* env, jclass cls, jobject context)
753{
754 jclass contextClass;
755 jclass fileClass;
756 jobject filesDirObj;
757 jmethodID getFilesDirID;
758 jmethodID getAbsolutePathID;
759 jstring path;
760 const char* raw;
761 char* envStr;
762 RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
763 rdpContext* ctx;
764#if defined(WITH_GPROF)
765 setenv("CPUPROFILE_FREQUENCY", "200", 1);
766 monstartup("libfreerdp-android.so");
767#endif
768 contextClass = (*env)->FindClass(env, JAVA_CONTEXT_CLASS);
769 fileClass = (*env)->FindClass(env, JAVA_FILE_CLASS);
770
771 if (!contextClass || !fileClass)
772 {
773 WLog_FATAL(TAG, "Failed to load class references %s=%p, %s=%p", JAVA_CONTEXT_CLASS,
774 (void*)contextClass, JAVA_FILE_CLASS, (void*)fileClass);
775 return (jlong) nullptr;
776 }
777
778 getFilesDirID =
779 (*env)->GetMethodID(env, contextClass, "getFilesDir", "()L" JAVA_FILE_CLASS ";");
780
781 if (!getFilesDirID)
782 {
783 WLog_FATAL(TAG, "Failed to find method ID getFilesDir ()L" JAVA_FILE_CLASS ";");
784 return (jlong) nullptr;
785 }
786
787 getAbsolutePathID =
788 (*env)->GetMethodID(env, fileClass, "getAbsolutePath", "()Ljava/lang/String;");
789
790 if (!getAbsolutePathID)
791 {
792 WLog_FATAL(TAG, "Failed to find method ID getAbsolutePath ()Ljava/lang/String;");
793 return (jlong) nullptr;
794 }
795
796 filesDirObj = (*env)->CallObjectMethod(env, context, getFilesDirID);
797
798 if (!filesDirObj)
799 {
800 WLog_FATAL(TAG, "Failed to call getFilesDir");
801 return (jlong) nullptr;
802 }
803
804 path = (*env)->CallObjectMethod(env, filesDirObj, getAbsolutePathID);
805
806 if (!path)
807 {
808 WLog_FATAL(TAG, "Failed to call getAbsolutePath");
809 return (jlong) nullptr;
810 }
811
812 raw = (*env)->GetStringUTFChars(env, path, 0);
813
814 if (!raw)
815 {
816 WLog_FATAL(TAG, "Failed to get C string from java string");
817 return (jlong) nullptr;
818 }
819
820 envStr = _strdup(raw);
821 (*env)->ReleaseStringUTFChars(env, path, raw);
822
823 if (!envStr)
824 {
825 WLog_FATAL(TAG, "_strdup(%s) failed", raw);
826 return (jlong) nullptr;
827 }
828
829 if (setenv("HOME", _strdup(envStr), 1) != 0)
830 {
831 char ebuffer[256] = WINPR_C_ARRAY_INIT;
832 WLog_FATAL(TAG, "Failed to set environment HOME=%s %s [%d]", envStr,
833 winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
834 return (jlong) nullptr;
835 }
836
837 RdpClientEntry(&clientEntryPoints);
838 ctx = freerdp_client_context_new(&clientEntryPoints);
839
840 if (!ctx)
841 return (jlong) nullptr;
842
843 return (jlong)ctx->instance;
844}
845
846JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1free(
847 JNIEnv* env, jclass cls, jlong instance)
848{
849 freerdp* inst = (freerdp*)instance;
850
851 if (inst)
852 freerdp_client_context_free(inst->context);
853
854#if defined(WITH_GPROF)
855 moncleanup();
856#endif
857}
858
859JNIEXPORT jstring JNICALL
860Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1last_1error_1string(JNIEnv* env,
861 jclass cls,
862 jlong instance)
863{
864 freerdp* inst = (freerdp*)instance;
865
866 if (!inst || !inst->context)
867 return (*env)->NewStringUTF(env, "");
868
869 return (*env)->NewStringUTF(
870 env, freerdp_get_last_error_string(freerdp_get_last_error(inst->context)));
871}
872
873JNIEXPORT jboolean JNICALL
874Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1parse_1arguments(JNIEnv* env, jclass cls,
875 jlong instance,
876 jobjectArray arguments)
877{
878 freerdp* inst = (freerdp*)instance;
879 int count;
880 char** argv;
881 DWORD status;
882
883 if (!inst || !inst->context)
884 return JNI_FALSE;
885
886 count = (*env)->GetArrayLength(env, arguments);
887 argv = calloc(count, sizeof(char*));
888
889 if (!argv)
890 return JNI_TRUE;
891
892 for (int i = 0; i < count; i++)
893 {
894 jstring str = (jstring)(*env)->GetObjectArrayElement(env, arguments, i);
895 const char* raw = (*env)->GetStringUTFChars(env, str, 0);
896 argv[i] = _strdup(raw);
897 (*env)->ReleaseStringUTFChars(env, str, raw);
898 }
899
900 status =
901 freerdp_client_settings_parse_command_line(inst->context->settings, count, argv, FALSE);
902
903 for (int i = 0; i < count; i++)
904 free(argv[i]);
905
906 free(argv);
907 return (status == 0) ? JNI_TRUE : JNI_FALSE;
908}
909
910JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1connect(
911 JNIEnv* env, jclass cls, jlong instance)
912{
913 freerdp* inst = (freerdp*)instance;
914
915 if (!inst || !inst->context)
916 {
917 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%" PRId64, (void*)env, (void*)cls,
918 (int64_t)instance);
919 return JNI_FALSE;
920 }
921
922 androidContext* ctx = (androidContext*)inst->context;
923
924 if (!(ctx->thread = CreateThread(nullptr, 0, android_thread_func, inst, 0, nullptr)))
925 {
926 return JNI_FALSE;
927 }
928
929 return JNI_TRUE;
930}
931
932JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1disconnect(
933 JNIEnv* env, jclass cls, jlong instance)
934{
935 freerdp* inst = (freerdp*)instance;
936
937 if (!inst || !inst->context || !cls || !env)
938 {
939 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%" PRId64, (void*)env, (void*)cls,
940 (int64_t)instance);
941 return JNI_FALSE;
942 }
943
944 androidContext* ctx = (androidContext*)inst->context;
945 ANDROID_EVENT* event = (ANDROID_EVENT*)android_event_disconnect_new();
946
947 if (!event)
948 return JNI_FALSE;
949
950 if (!android_push_event(inst, event))
951 {
952 android_event_free((ANDROID_EVENT*)event);
953 return JNI_FALSE;
954 }
955
956 if (!freerdp_abort_connect_context(inst->context))
957 return JNI_FALSE;
958
959 return JNI_TRUE;
960}
961
962JNIEXPORT jboolean JNICALL
963Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1update_1graphics(JNIEnv* env, jclass cls,
964 jlong instance,
965 jobject bitmap, jint x,
966 jint y, jint width,
967 jint height)
968{
969 UINT32 DstFormat;
970 jboolean rc;
971 int ret;
972 void* pixels;
973 AndroidBitmapInfo info;
974 freerdp* inst = (freerdp*)instance;
975 rdpGdi* gdi;
976
977 if (!env || !cls || !inst)
978 {
979 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%" PRId64, (void*)env, (void*)cls,
980 (int64_t)instance);
981 return JNI_FALSE;
982 }
983
984 gdi = inst->context->gdi;
985
986 if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0)
987 {
988 WLog_FATAL(TAG, "AndroidBitmap_getInfo() failed ! error=%d", ret);
989 return JNI_FALSE;
990 }
991
992 if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0)
993 {
994 WLog_FATAL(TAG, "AndroidBitmap_lockPixels() failed ! error=%d", ret);
995 return JNI_FALSE;
996 }
997
998 rc = JNI_TRUE;
999
1000 switch (info.format)
1001 {
1002 case ANDROID_BITMAP_FORMAT_RGBA_8888:
1003 DstFormat = PIXEL_FORMAT_RGBX32;
1004 break;
1005
1006 case ANDROID_BITMAP_FORMAT_RGB_565:
1007 DstFormat = PIXEL_FORMAT_RGB16;
1008 break;
1009
1010 case ANDROID_BITMAP_FORMAT_RGBA_4444:
1011 case ANDROID_BITMAP_FORMAT_A_8:
1012 case ANDROID_BITMAP_FORMAT_NONE:
1013 default:
1014 rc = JNI_FALSE;
1015 break;
1016 }
1017
1018 if (rc)
1019 {
1020 rc = freerdp_image_copy(pixels, DstFormat, info.stride, x, y, width, height,
1021 gdi->primary_buffer, gdi->dstFormat, gdi->stride, x, y,
1022 &gdi->palette, FREERDP_FLIP_NONE);
1023 }
1024
1025 if ((ret = AndroidBitmap_unlockPixels(env, bitmap)) < 0)
1026 {
1027 WLog_FATAL(TAG, "AndroidBitmap_unlockPixels() failed ! error=%d", ret);
1028 return JNI_FALSE;
1029 }
1030
1031 return rc;
1032}
1033
1034JNIEXPORT jboolean JNICALL
1035Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event(JNIEnv* env, jclass cls,
1036 jlong instance,
1037 jint keycode,
1038 jboolean down)
1039{
1040 DWORD scancode;
1041 ANDROID_EVENT* event;
1042 freerdp* inst = (freerdp*)instance;
1043 scancode = GetVirtualScanCodeFromVirtualKeyCode(keycode, 4);
1044 int flags = (down == JNI_TRUE) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE;
1045 flags |= (scancode & KBDEXT) ? KBD_FLAGS_EXTENDED : 0;
1046 event = (ANDROID_EVENT*)android_event_key_new(flags, scancode & 0xFF);
1047
1048 if (!event)
1049 return JNI_FALSE;
1050
1051 if (!android_push_event(inst, event))
1052 {
1053 android_event_free(event);
1054 return JNI_FALSE;
1055 }
1056
1057 WLog_DBG(TAG, "send_key_event: %" PRIu32 ", %d", scancode, flags);
1058 return JNI_TRUE;
1059}
1060
1061JNIEXPORT jboolean JNICALL
1062Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event(
1063 JNIEnv* env, jclass cls, jlong instance, jint keycode, jboolean down)
1064{
1065 ANDROID_EVENT* event;
1066 freerdp* inst = (freerdp*)instance;
1067 UINT16 flags = (down == JNI_TRUE) ? 0 : KBD_FLAGS_RELEASE;
1068 event = (ANDROID_EVENT*)android_event_unicodekey_new(flags, keycode);
1069
1070 if (!event)
1071 return JNI_FALSE;
1072
1073 if (!android_push_event(inst, event))
1074 {
1075 android_event_free(event);
1076 return JNI_FALSE;
1077 }
1078
1079 WLog_DBG(TAG, "send_unicodekey_event: %d", keycode);
1080 return JNI_TRUE;
1081}
1082
1083JNIEXPORT jboolean JNICALL
1084Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1is_1unicode_1input_1supported(
1085 JNIEnv* env, jclass cls, jlong instance)
1086{
1087 freerdp* inst = (freerdp*)instance;
1088
1089 if (!inst || !inst->context || !inst->context->settings)
1090 return JNI_FALSE;
1091
1092 if (!freerdp_settings_get_bool(inst->context->settings, FreeRDP_UnicodeInput))
1093 return JNI_FALSE;
1094
1095 return JNI_TRUE;
1096}
1097
1098JNIEXPORT jboolean JNICALL
1099Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event(
1100 JNIEnv* env, jclass cls, jlong instance, jint x, jint y, jint flags)
1101{
1102 ANDROID_EVENT* event;
1103 freerdp* inst = (freerdp*)instance;
1104 event = (ANDROID_EVENT*)android_event_cursor_new(flags, x, y);
1105
1106 if (!event)
1107 return JNI_FALSE;
1108
1109 if (!android_push_event(inst, event))
1110 {
1111 android_event_free(event);
1112 return JNI_FALSE;
1113 }
1114
1115 WLog_DBG(TAG, "send_cursor_event: (%d, %d), %d", x, y, flags);
1116 return JNI_TRUE;
1117}
1118
1119static jboolean android_push_clipboard_event(freerdp* inst, const void* data, size_t data_length,
1120 const char* mimeType)
1121{
1122 ANDROID_EVENT* event = (ANDROID_EVENT*)android_event_clipboard_new(data, data_length, mimeType);
1123 if (!event)
1124 return JNI_FALSE;
1125 if (!android_push_event(inst, event))
1126 {
1127 android_event_free(event);
1128 return JNI_FALSE;
1129 }
1130 return JNI_TRUE;
1131}
1132
1133JNIEXPORT jboolean JNICALL
1134Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data(JNIEnv* env,
1135 jclass cls,
1136 jlong instance,
1137 jstring jdata)
1138{
1139 WINPR_UNUSED(cls);
1140 freerdp* inst = (freerdp*)instance;
1141 const char* data = jdata != nullptr ? (*env)->GetStringUTFChars(env, jdata, nullptr) : nullptr;
1142 const size_t data_length = data ? (*env)->GetStringUTFLength(env, jdata) : 0;
1143 jboolean ret = android_push_clipboard_event(inst, data, data_length, "text/plain");
1144 WLog_DBG(TAG, "send_clipboard_data: (%s)", data);
1145
1146 if (data)
1147 (*env)->ReleaseStringUTFChars(env, jdata, data);
1148
1149 return ret;
1150}
1151
1152static BOOL android_is_image_mime_supported(const char* mimeType)
1153{
1154 if (!mimeType)
1155 return FALSE;
1156 if (strcmp(mimeType, "image/png") == 0)
1157 return winpr_image_format_is_supported(WINPR_IMAGE_PNG);
1158 if (strcmp(mimeType, "image/jpeg") == 0 || strcmp(mimeType, "image/jpg") == 0)
1159 return winpr_image_format_is_supported(WINPR_IMAGE_JPEG);
1160 if (strcmp(mimeType, "image/webp") == 0)
1161 return winpr_image_format_is_supported(WINPR_IMAGE_WEBP);
1162 return FALSE;
1163}
1164
1165JNIEXPORT jboolean JNICALL
1166Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1image_1data(
1167 JNIEnv* env, jclass cls, jlong instance, jbyteArray jdata, jstring jmimeType)
1168{
1169 WINPR_UNUSED(cls);
1170 freerdp* inst = (freerdp*)instance;
1171 jsize data_length = (*env)->GetArrayLength(env, jdata);
1172 jbyte* data = (*env)->GetByteArrayElements(env, jdata, nullptr);
1173 const char* mimeType = jmimeType ? (*env)->GetStringUTFChars(env, jmimeType, nullptr) : nullptr;
1174 jboolean ret = JNI_FALSE;
1175 if (android_is_image_mime_supported(mimeType))
1176 ret = android_push_clipboard_event(inst, data, (size_t)data_length, mimeType);
1177
1178 if (mimeType)
1179 (*env)->ReleaseStringUTFChars(env, jmimeType, mimeType);
1180 (*env)->ReleaseByteArrayElements(env, jdata, data, JNI_ABORT);
1181 return ret;
1182}
1183
1184JNIEXPORT jboolean JNICALL
1185Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1monitor_1layout(
1186 JNIEnv* env, jclass cls, jlong instance, jint width, jint height)
1187{
1188 WINPR_UNUSED(env);
1189 WINPR_UNUSED(cls);
1190 freerdp* inst = (freerdp*)instance;
1191
1192 if (!inst || !inst->context)
1193 return JNI_FALSE;
1194
1195 androidContext* afc = (androidContext*)inst->context;
1196 return android_disp_send_monitor_layout(afc, (UINT32)width, (UINT32)height) ? JNI_TRUE
1197 : JNI_FALSE;
1198}
1199
1200JNIEXPORT jstring JNICALL
1201Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1jni_1version(JNIEnv* env, jclass cls)
1202{
1203 return (*env)->NewStringUTF(env, FREERDP_JNI_VERSION);
1204}
1205
1206JNIEXPORT jboolean JNICALL
1207Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1has_1h264(JNIEnv* env, jclass cls)
1208{
1209 H264_CONTEXT* ctx = h264_context_new(FALSE);
1210 if (!ctx)
1211 return JNI_FALSE;
1212 h264_context_free(ctx);
1213 return JNI_TRUE;
1214}
1215
1216JNIEXPORT jboolean JNICALL
1217Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1has_1camera_1redirection(JNIEnv* env,
1218 jclass cls)
1219{
1220 return freerdp_video_conversion_supported(FREERDP_VIDEO_FORMAT_NV12,
1221 FREERDP_VIDEO_FORMAT_YUV420P)
1222 ? JNI_TRUE
1223 : JNI_FALSE;
1224}
1225
1226JNIEXPORT jstring JNICALL
1227Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1version(JNIEnv* env, jclass cls)
1228{
1229 return (*env)->NewStringUTF(env, freerdp_get_version_string());
1230}
1231
1232JNIEXPORT jstring JNICALL
1233Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1build_1revision(JNIEnv* env,
1234 jclass cls)
1235{
1236 return (*env)->NewStringUTF(env, freerdp_get_build_revision());
1237}
1238
1239JNIEXPORT jstring JNICALL
1240Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1build_1config(JNIEnv* env,
1241 jclass cls)
1242{
1243 return (*env)->NewStringUTF(env, freerdp_get_build_config());
1244}
1245
1246jint JNI_OnLoad(JavaVM* vm, void* reserved)
1247{
1248 JNIEnv* env;
1249 setlocale(LC_ALL, "");
1250 WLog_DBG(TAG, "Setting up JNI environment...");
1251
1252 /*
1253 if (freerdp_handle_signals() != 0)
1254 {
1255 WLog_FATAL(TAG, "Failed to register signal handler");
1256 return -1;
1257 }
1258 */
1259 if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK)
1260 {
1261 WLog_FATAL(TAG, "Failed to get the environment");
1262 return -1;
1263 }
1264
1265 // Get SBCEngine activity class
1266 jclass activityClass = (*env)->FindClass(env, JAVA_LIBFREERDP_CLASS);
1267
1268 if (!activityClass)
1269 {
1270 WLog_FATAL(TAG, "failed to get %s class reference", JAVA_LIBFREERDP_CLASS);
1271 return -1;
1272 }
1273
1274 /* create global reference for class */
1275 gJavaActivityClass = (*env)->NewGlobalRef(env, activityClass);
1276 gOnPointerSetMethod =
1277 (*env)->GetStaticMethodID(env, gJavaActivityClass, "OnPointerSet", "(J[IIIII)V");
1278 gOnRailWindowUpdateMethod =
1279 (*env)->GetStaticMethodID(env, gJavaActivityClass, "OnRailWindowUpdate", "(JJII[I)V");
1280 if (!gOnRailWindowUpdateMethod)
1281 {
1282 (*env)->ExceptionClear(env);
1283 WLog_WARN(TAG, "OnRailWindowUpdate method not found, RAIL window display disabled");
1284 }
1285 g_JavaVm = vm;
1286 return init_callback_environment(vm, env);
1287}
1288
1289void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved)
1290{
1291 JNIEnv* env;
1292 WLog_DBG(TAG, "Tearing down JNI environment...");
1293
1294 if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK)
1295 {
1296 WLog_FATAL(TAG, "Failed to get the environment");
1297 return;
1298 }
1299
1300 if (gJavaActivityClass)
1301 (*env)->DeleteGlobalRef(env, gJavaActivityClass);
1302}
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
ANDROID_EVENT
Definition android_event.h:24
GDI_RGN
Definition include/freerdp/gdi/gdi.h:381
GDI_WND
Definition include/freerdp/gdi/gdi.h:449