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 = NULL;
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 = NULL;
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, NULL);
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, NULL,
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 rdpSettings* settings;
434 rdpUpdate* update;
435
436 WINPR_ASSERT(instance);
437 WINPR_ASSERT(instance->context);
438
439 update = instance->context->update;
440 WINPR_ASSERT(update);
441
442 settings = instance->context->settings;
443 WINPR_ASSERT(settings);
444
445 if (freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationMode) &&
446 !freerdp_callback_bool_result("OnExperimentalFeature", "(JI)Z", (jlong)instance,
447 ANDROID_EXPERIMENTAL_REMOTEAPP))
448 return FALSE;
449
450 if (freerdp_dynamic_channel_collection_find(settings, "rdpecam") &&
451 !freerdp_callback_bool_result("OnExperimentalFeature", "(JI)Z", (jlong)instance,
452 ANDROID_EXPERIMENTAL_CAMERA))
453 return FALSE;
454
455 if (!gdi_init(instance, PIXEL_FORMAT_RGBX32))
456 return FALSE;
457
458 if (!android_register_pointer(instance->context->graphics))
459 return FALSE;
460
461 update->BeginPaint = android_begin_paint;
462 update->EndPaint = android_end_paint;
463 update->DesktopResize = android_desktop_resize;
464 freerdp_callback("OnSettingsChanged", "(JIII)V", (jlong)instance,
465 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
466 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
467 freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
468 freerdp_callback("OnConnectionSuccess", "(J)V", (jlong)instance);
469 return TRUE;
470}
471
472static void android_post_disconnect(freerdp* instance)
473{
474 freerdp_callback("OnDisconnecting", "(J)V", (jlong)instance);
475 gdi_free(instance);
476}
477
478static BOOL android_authenticate_int(freerdp* instance, char** username, char** password,
479 char** domain, const char* cb_name)
480{
481 JNIEnv* env;
482 jboolean attached = jni_attach_thread(&env);
483 jobject jstr1 = create_string_builder(env, *username);
484 jobject jstr2 = create_string_builder(env, *domain);
485 jobject jstr3 = create_string_builder(env, *password);
486 jboolean res;
487 res = freerdp_callback_bool_result(cb_name,
488 "(JLjava/lang/StringBuilder;"
489 "Ljava/lang/StringBuilder;"
490 "Ljava/lang/StringBuilder;)Z",
491 (jlong)instance, jstr1, jstr2, jstr3);
492
493 if (res == JNI_TRUE)
494 {
495 // read back string values
496 free(*username);
497 *username = get_string_from_string_builder(env, jstr1);
498 free(*domain);
499 *domain = get_string_from_string_builder(env, jstr2);
500 free(*password);
501 *password = get_string_from_string_builder(env, jstr3);
502 }
503
504 if (attached == JNI_TRUE)
505 jni_detach_thread();
506
507 return ((res == JNI_TRUE) ? TRUE : FALSE);
508}
509
510static BOOL android_authenticate_ex(freerdp* instance, char** username, char** password,
511 char** domain, rdp_auth_reason reason)
512{
513 switch (reason)
514 {
515 case AUTH_NLA:
516 case AUTH_TLS:
517 case AUTH_RDP:
518 return android_authenticate_int(instance, username, password, domain, "OnAuthenticate");
519 case GW_AUTH_HTTP:
520 case GW_AUTH_RDG:
521 case GW_AUTH_RPC:
522 return android_authenticate_int(instance, username, password, domain,
523 "OnGatewayAuthenticate");
524 default:
525 return FALSE;
526 }
527}
528
529static DWORD android_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
530 const char* common_name, const char* subject,
531 const char* issuer, const char* fingerprint, DWORD flags)
532{
533 WLog_DBG(TAG, "Certificate details [%s:%" PRIu16 ":", host, port);
534 WLog_DBG(TAG, "\tSubject: %s", subject);
535 WLog_DBG(TAG, "\tIssuer: %s", issuer);
536 WLog_DBG(TAG, "\tThumbprint: %s", fingerprint);
537 WLog_DBG(TAG,
538 "The above X.509 certificate could not be verified, possibly because you do not have "
539 "the CA certificate in your certificate store, or the certificate has expired."
540 "Please look at the OpenSSL documentation on how to add a private CA to the store.\n");
541 JNIEnv* env;
542 jboolean attached = jni_attach_thread(&env);
543 jstring jstr0 = (*env)->NewStringUTF(env, host);
544 jstring jstr1 = (*env)->NewStringUTF(env, common_name);
545 jstring jstr2 = (*env)->NewStringUTF(env, subject);
546 jstring jstr3 = (*env)->NewStringUTF(env, issuer);
547 jstring jstr4 = (*env)->NewStringUTF(env, fingerprint);
548 jint res = freerdp_callback_int_result("OnVerifyCertificateEx",
549 "(JLjava/lang/String;JLjava/lang/String;Ljava/lang/"
550 "String;Ljava/lang/String;Ljava/lang/String;J)I",
551 (jlong)instance, jstr0, (jlong)port, jstr1, jstr2, jstr3,
552 jstr4, (jlong)flags);
553
554 if (attached == JNI_TRUE)
555 jni_detach_thread();
556
557 return res;
558}
559
560static DWORD android_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
561 const char* common_name, const char* subject,
562 const char* issuer, const char* new_fingerprint,
563 const char* old_subject, const char* old_issuer,
564 const char* old_fingerprint, DWORD flags)
565{
566 JNIEnv* env;
567 jboolean attached = jni_attach_thread(&env);
568 jstring jhost = (*env)->NewStringUTF(env, host);
569 jstring jstr0 = (*env)->NewStringUTF(env, common_name);
570 jstring jstr1 = (*env)->NewStringUTF(env, subject);
571 jstring jstr2 = (*env)->NewStringUTF(env, issuer);
572 jstring jstr3 = (*env)->NewStringUTF(env, new_fingerprint);
573 jstring jstr4 = (*env)->NewStringUTF(env, old_subject);
574 jstring jstr5 = (*env)->NewStringUTF(env, old_issuer);
575 jstring jstr6 = (*env)->NewStringUTF(env, old_fingerprint);
576 jint res =
577 freerdp_callback_int_result("OnVerifyChangedCertificateEx",
578 "(JLjava/lang/String;JLjava/lang/String;Ljava/lang/"
579 "String;Ljava/lang/String;Ljava/lang/String;"
580 "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;J)I",
581 (jlong)instance, jhost, (jlong)port, jstr0, jstr1, jstr2, jstr3,
582 jstr4, jstr5, jstr6, (jlong)flags);
583
584 if (attached == JNI_TRUE)
585 jni_detach_thread();
586
587 return res;
588}
589
590static int android_freerdp_run(freerdp* instance)
591{
592 DWORD count;
593 DWORD status = WAIT_FAILED;
594 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
595 HANDLE inputEvent = nullptr;
596 const rdpSettings* settings = instance->context->settings;
597 rdpContext* context = instance->context;
598
599 inputEvent = android_get_handle(instance);
600
601 while (!freerdp_shall_disconnect_context(instance->context))
602 {
603 DWORD tmp;
604 count = 0;
605
606 handles[count++] = inputEvent;
607
608 tmp = freerdp_get_event_handles(context, &handles[count], 64 - count);
609
610 if (tmp == 0)
611 {
612 WLog_ERR(TAG, "freerdp_get_event_handles failed");
613 break;
614 }
615
616 count += tmp;
617 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
618
619 if (status == WAIT_FAILED)
620 {
621 WLog_ERR(TAG, "WaitForMultipleObjects failed with %u [%08X]", status,
622 (unsigned)GetLastError());
623 break;
624 }
625
626 if (!freerdp_check_event_handles(context))
627 {
628 /* TODO: Auto reconnect
629 if (xf_auto_reconnect(instance))
630 continue;
631 */
632 WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
633 status = GetLastError();
634 break;
635 }
636
637 if (freerdp_shall_disconnect_context(instance->context))
638 break;
639
640 if (android_check_handle(instance) != TRUE)
641 {
642 WLog_ERR(TAG, "Failed to check android file descriptor");
643 status = GetLastError();
644 break;
645 }
646 }
647
648disconnect:
649 WLog_INFO(TAG, "Prepare shutdown...");
650
651 return status;
652}
653
654static DWORD WINAPI android_thread_func(LPVOID param)
655{
656 DWORD status = ERROR_BAD_ARGUMENTS;
657 freerdp* instance = param;
658 WLog_DBG(TAG, "Start...");
659
660 WINPR_ASSERT(instance);
661 WINPR_ASSERT(instance->context);
662
663 if (freerdp_client_start(instance->context) != CHANNEL_RC_OK)
664 goto fail;
665
666 WLog_DBG(TAG, "Connect...");
667
668 if (!freerdp_connect(instance))
669 status = GetLastError();
670 else
671 {
672 status = android_freerdp_run(instance);
673 WLog_DBG(TAG, "Disconnect...");
674
675 if (!freerdp_disconnect(instance))
676 status = GetLastError();
677 }
678
679 WLog_DBG(TAG, "Stop...");
680
681 if (freerdp_client_stop(instance->context) != CHANNEL_RC_OK)
682 goto fail;
683
684fail:
685 WLog_DBG(TAG, "Session ended with %08" PRIX32 "", status);
686
687 if (status == CHANNEL_RC_OK)
688 freerdp_callback("OnDisconnected", "(J)V", (jlong)instance);
689 else
690 freerdp_callback("OnConnectionFailure", "(J)V", (jlong)instance);
691
692 WLog_DBG(TAG, "Quit.");
693 ExitThread(status);
694 return status;
695}
696
697static BOOL android_client_new(freerdp* instance, rdpContext* context)
698{
699 WINPR_ASSERT(instance);
700 WINPR_ASSERT(context);
701
702 if (!android_event_queue_init(instance))
703 return FALSE;
704
705 instance->PreConnect = android_pre_connect;
706 instance->PostConnect = android_post_connect;
707 instance->PostDisconnect = android_post_disconnect;
708 instance->AuthenticateEx = android_authenticate_ex;
709 instance->VerifyCertificateEx = android_verify_certificate_ex;
710 instance->VerifyChangedCertificateEx = android_verify_changed_certificate_ex;
711 instance->LogonErrorInfo = nullptr;
712 return TRUE;
713}
714
715static void android_client_free(freerdp* instance, rdpContext* context)
716{
717 if (!context)
718 return;
719
720 android_event_queue_uninit(instance);
721}
722
723static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
724{
725 WINPR_ASSERT(pEntryPoints);
726
727 ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
728
729 pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
730 pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
731 pEntryPoints->GlobalInit = nullptr;
732 pEntryPoints->GlobalUninit = nullptr;
733 pEntryPoints->ContextSize = sizeof(androidContext);
734 pEntryPoints->ClientNew = android_client_new;
735 pEntryPoints->ClientFree = android_client_free;
736 pEntryPoints->ClientStart = nullptr;
737 pEntryPoints->ClientStop = nullptr;
738 return 0;
739}
740
741JNIEXPORT jlong JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1new(
742 JNIEnv* env, jclass cls, jobject context)
743{
744 jclass contextClass;
745 jclass fileClass;
746 jobject filesDirObj;
747 jmethodID getFilesDirID;
748 jmethodID getAbsolutePathID;
749 jstring path;
750 const char* raw;
751 char* envStr;
752 RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
753 rdpContext* ctx;
754#if defined(WITH_GPROF)
755 setenv("CPUPROFILE_FREQUENCY", "200", 1);
756 monstartup("libfreerdp-android.so");
757#endif
758 contextClass = (*env)->FindClass(env, JAVA_CONTEXT_CLASS);
759 fileClass = (*env)->FindClass(env, JAVA_FILE_CLASS);
760
761 if (!contextClass || !fileClass)
762 {
763 WLog_FATAL(TAG, "Failed to load class references %s=%p, %s=%p", JAVA_CONTEXT_CLASS,
764 (void*)contextClass, JAVA_FILE_CLASS, (void*)fileClass);
765 return (jlong) nullptr;
766 }
767
768 getFilesDirID =
769 (*env)->GetMethodID(env, contextClass, "getFilesDir", "()L" JAVA_FILE_CLASS ";");
770
771 if (!getFilesDirID)
772 {
773 WLog_FATAL(TAG, "Failed to find method ID getFilesDir ()L" JAVA_FILE_CLASS ";");
774 return (jlong) nullptr;
775 }
776
777 getAbsolutePathID =
778 (*env)->GetMethodID(env, fileClass, "getAbsolutePath", "()Ljava/lang/String;");
779
780 if (!getAbsolutePathID)
781 {
782 WLog_FATAL(TAG, "Failed to find method ID getAbsolutePath ()Ljava/lang/String;");
783 return (jlong) nullptr;
784 }
785
786 filesDirObj = (*env)->CallObjectMethod(env, context, getFilesDirID);
787
788 if (!filesDirObj)
789 {
790 WLog_FATAL(TAG, "Failed to call getFilesDir");
791 return (jlong) nullptr;
792 }
793
794 path = (*env)->CallObjectMethod(env, filesDirObj, getAbsolutePathID);
795
796 if (!path)
797 {
798 WLog_FATAL(TAG, "Failed to call getAbsolutePath");
799 return (jlong) nullptr;
800 }
801
802 raw = (*env)->GetStringUTFChars(env, path, 0);
803
804 if (!raw)
805 {
806 WLog_FATAL(TAG, "Failed to get C string from java string");
807 return (jlong) nullptr;
808 }
809
810 envStr = _strdup(raw);
811 (*env)->ReleaseStringUTFChars(env, path, raw);
812
813 if (!envStr)
814 {
815 WLog_FATAL(TAG, "_strdup(%s) failed", raw);
816 return (jlong) nullptr;
817 }
818
819 if (setenv("HOME", _strdup(envStr), 1) != 0)
820 {
821 char ebuffer[256] = WINPR_C_ARRAY_INIT;
822 WLog_FATAL(TAG, "Failed to set environment HOME=%s %s [%d]", envStr,
823 winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
824 return (jlong) nullptr;
825 }
826
827 RdpClientEntry(&clientEntryPoints);
828 ctx = freerdp_client_context_new(&clientEntryPoints);
829
830 if (!ctx)
831 return (jlong) nullptr;
832
833 return (jlong)ctx->instance;
834}
835
836JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1free(
837 JNIEnv* env, jclass cls, jlong instance)
838{
839 freerdp* inst = (freerdp*)instance;
840
841 if (inst)
842 freerdp_client_context_free(inst->context);
843
844#if defined(WITH_GPROF)
845 moncleanup();
846#endif
847}
848
849JNIEXPORT jstring JNICALL
850Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1last_1error_1string(JNIEnv* env,
851 jclass cls,
852 jlong instance)
853{
854 freerdp* inst = (freerdp*)instance;
855
856 if (!inst || !inst->context)
857 return (*env)->NewStringUTF(env, "");
858
859 return (*env)->NewStringUTF(
860 env, freerdp_get_last_error_string(freerdp_get_last_error(inst->context)));
861}
862
863JNIEXPORT jboolean JNICALL
864Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1parse_1arguments(JNIEnv* env, jclass cls,
865 jlong instance,
866 jobjectArray arguments)
867{
868 freerdp* inst = (freerdp*)instance;
869 int count;
870 char** argv;
871 DWORD status;
872
873 if (!inst || !inst->context)
874 return JNI_FALSE;
875
876 count = (*env)->GetArrayLength(env, arguments);
877 argv = calloc(count, sizeof(char*));
878
879 if (!argv)
880 return JNI_TRUE;
881
882 for (int i = 0; i < count; i++)
883 {
884 jstring str = (jstring)(*env)->GetObjectArrayElement(env, arguments, i);
885 const char* raw = (*env)->GetStringUTFChars(env, str, 0);
886 argv[i] = _strdup(raw);
887 (*env)->ReleaseStringUTFChars(env, str, raw);
888 }
889
890 status =
891 freerdp_client_settings_parse_command_line(inst->context->settings, count, argv, FALSE);
892
893 for (int i = 0; i < count; i++)
894 free(argv[i]);
895
896 free(argv);
897 return (status == 0) ? JNI_TRUE : JNI_FALSE;
898}
899
900JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1connect(
901 JNIEnv* env, jclass cls, jlong instance)
902{
903 freerdp* inst = (freerdp*)instance;
904
905 if (!inst || !inst->context)
906 {
907 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%" PRId64, (void*)env, (void*)cls,
908 (int64_t)instance);
909 return JNI_FALSE;
910 }
911
912 androidContext* ctx = (androidContext*)inst->context;
913
914 if (!(ctx->thread = CreateThread(nullptr, 0, android_thread_func, inst, 0, nullptr)))
915 {
916 return JNI_FALSE;
917 }
918
919 return JNI_TRUE;
920}
921
922JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1disconnect(
923 JNIEnv* env, jclass cls, jlong instance)
924{
925 freerdp* inst = (freerdp*)instance;
926
927 if (!inst || !inst->context || !cls || !env)
928 {
929 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%" PRId64, (void*)env, (void*)cls,
930 (int64_t)instance);
931 return JNI_FALSE;
932 }
933
934 androidContext* ctx = (androidContext*)inst->context;
935 ANDROID_EVENT* event = (ANDROID_EVENT*)android_event_disconnect_new();
936
937 if (!event)
938 return JNI_FALSE;
939
940 if (!android_push_event(inst, event))
941 {
942 android_event_free((ANDROID_EVENT*)event);
943 return JNI_FALSE;
944 }
945
946 if (!freerdp_abort_connect_context(inst->context))
947 return JNI_FALSE;
948
949 return JNI_TRUE;
950}
951
952JNIEXPORT jboolean JNICALL
953Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1update_1graphics(JNIEnv* env, jclass cls,
954 jlong instance,
955 jobject bitmap, jint x,
956 jint y, jint width,
957 jint height)
958{
959 UINT32 DstFormat;
960 jboolean rc;
961 int ret;
962 void* pixels;
963 AndroidBitmapInfo info;
964 freerdp* inst = (freerdp*)instance;
965 rdpGdi* gdi;
966
967 if (!env || !cls || !inst)
968 {
969 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%" PRId64, (void*)env, (void*)cls,
970 (int64_t)instance);
971 return JNI_FALSE;
972 }
973
974 gdi = inst->context->gdi;
975
976 if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0)
977 {
978 WLog_FATAL(TAG, "AndroidBitmap_getInfo() failed ! error=%d", ret);
979 return JNI_FALSE;
980 }
981
982 if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0)
983 {
984 WLog_FATAL(TAG, "AndroidBitmap_lockPixels() failed ! error=%d", ret);
985 return JNI_FALSE;
986 }
987
988 rc = JNI_TRUE;
989
990 switch (info.format)
991 {
992 case ANDROID_BITMAP_FORMAT_RGBA_8888:
993 DstFormat = PIXEL_FORMAT_RGBX32;
994 break;
995
996 case ANDROID_BITMAP_FORMAT_RGB_565:
997 DstFormat = PIXEL_FORMAT_RGB16;
998 break;
999
1000 case ANDROID_BITMAP_FORMAT_RGBA_4444:
1001 case ANDROID_BITMAP_FORMAT_A_8:
1002 case ANDROID_BITMAP_FORMAT_NONE:
1003 default:
1004 rc = JNI_FALSE;
1005 break;
1006 }
1007
1008 if (rc)
1009 {
1010 rc = freerdp_image_copy(pixels, DstFormat, info.stride, x, y, width, height,
1011 gdi->primary_buffer, gdi->dstFormat, gdi->stride, x, y,
1012 &gdi->palette, FREERDP_FLIP_NONE);
1013 }
1014
1015 if ((ret = AndroidBitmap_unlockPixels(env, bitmap)) < 0)
1016 {
1017 WLog_FATAL(TAG, "AndroidBitmap_unlockPixels() failed ! error=%d", ret);
1018 return JNI_FALSE;
1019 }
1020
1021 return rc;
1022}
1023
1024JNIEXPORT jboolean JNICALL
1025Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event(JNIEnv* env, jclass cls,
1026 jlong instance,
1027 jint keycode,
1028 jboolean down)
1029{
1030 DWORD scancode;
1031 ANDROID_EVENT* event;
1032 freerdp* inst = (freerdp*)instance;
1033 scancode = GetVirtualScanCodeFromVirtualKeyCode(keycode, 4);
1034 int flags = (down == JNI_TRUE) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE;
1035 flags |= (scancode & KBDEXT) ? KBD_FLAGS_EXTENDED : 0;
1036 event = (ANDROID_EVENT*)android_event_key_new(flags, scancode & 0xFF);
1037
1038 if (!event)
1039 return JNI_FALSE;
1040
1041 if (!android_push_event(inst, event))
1042 {
1043 android_event_free(event);
1044 return JNI_FALSE;
1045 }
1046
1047 WLog_DBG(TAG, "send_key_event: %" PRIu32 ", %d", scancode, flags);
1048 return JNI_TRUE;
1049}
1050
1051JNIEXPORT jboolean JNICALL
1052Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event(
1053 JNIEnv* env, jclass cls, jlong instance, jint keycode, jboolean down)
1054{
1055 ANDROID_EVENT* event;
1056 freerdp* inst = (freerdp*)instance;
1057 UINT16 flags = (down == JNI_TRUE) ? 0 : KBD_FLAGS_RELEASE;
1058 event = (ANDROID_EVENT*)android_event_unicodekey_new(flags, keycode);
1059
1060 if (!event)
1061 return JNI_FALSE;
1062
1063 if (!android_push_event(inst, event))
1064 {
1065 android_event_free(event);
1066 return JNI_FALSE;
1067 }
1068
1069 WLog_DBG(TAG, "send_unicodekey_event: %d", keycode);
1070 return JNI_TRUE;
1071}
1072
1073JNIEXPORT jboolean JNICALL
1074Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1is_1unicode_1input_1supported(
1075 JNIEnv* env, jclass cls, jlong instance)
1076{
1077 freerdp* inst = (freerdp*)instance;
1078
1079 if (!inst || !inst->context || !inst->context->settings)
1080 return JNI_FALSE;
1081
1082 if (!freerdp_settings_get_bool(inst->context->settings, FreeRDP_UnicodeInput))
1083 return JNI_FALSE;
1084
1085 return JNI_TRUE;
1086}
1087
1088JNIEXPORT jboolean JNICALL
1089Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event(
1090 JNIEnv* env, jclass cls, jlong instance, jint x, jint y, jint flags)
1091{
1092 ANDROID_EVENT* event;
1093 freerdp* inst = (freerdp*)instance;
1094 event = (ANDROID_EVENT*)android_event_cursor_new(flags, x, y);
1095
1096 if (!event)
1097 return JNI_FALSE;
1098
1099 if (!android_push_event(inst, event))
1100 {
1101 android_event_free(event);
1102 return JNI_FALSE;
1103 }
1104
1105 WLog_DBG(TAG, "send_cursor_event: (%d, %d), %d", x, y, flags);
1106 return JNI_TRUE;
1107}
1108
1109static jboolean android_push_clipboard_event(freerdp* inst, const void* data, size_t data_length,
1110 const char* mimeType)
1111{
1112 ANDROID_EVENT* event = (ANDROID_EVENT*)android_event_clipboard_new(data, data_length, mimeType);
1113 if (!event)
1114 return JNI_FALSE;
1115 if (!android_push_event(inst, event))
1116 {
1117 android_event_free(event);
1118 return JNI_FALSE;
1119 }
1120 return JNI_TRUE;
1121}
1122
1123JNIEXPORT jboolean JNICALL
1124Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data(JNIEnv* env,
1125 jclass cls,
1126 jlong instance,
1127 jstring jdata)
1128{
1129 WINPR_UNUSED(cls);
1130 freerdp* inst = (freerdp*)instance;
1131 const char* data = jdata != nullptr ? (*env)->GetStringUTFChars(env, jdata, nullptr) : nullptr;
1132 const size_t data_length = data ? (*env)->GetStringUTFLength(env, jdata) : 0;
1133 jboolean ret = android_push_clipboard_event(inst, data, data_length, "text/plain");
1134 WLog_DBG(TAG, "send_clipboard_data: (%s)", data);
1135
1136 if (data)
1137 (*env)->ReleaseStringUTFChars(env, jdata, data);
1138
1139 return ret;
1140}
1141
1142static BOOL android_is_image_mime_supported(const char* mimeType)
1143{
1144 if (!mimeType)
1145 return FALSE;
1146 if (strcmp(mimeType, "image/png") == 0)
1147 return winpr_image_format_is_supported(WINPR_IMAGE_PNG);
1148 if (strcmp(mimeType, "image/jpeg") == 0 || strcmp(mimeType, "image/jpg") == 0)
1149 return winpr_image_format_is_supported(WINPR_IMAGE_JPEG);
1150 if (strcmp(mimeType, "image/webp") == 0)
1151 return winpr_image_format_is_supported(WINPR_IMAGE_WEBP);
1152 return FALSE;
1153}
1154
1155JNIEXPORT jboolean JNICALL
1156Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1image_1data(
1157 JNIEnv* env, jclass cls, jlong instance, jbyteArray jdata, jstring jmimeType)
1158{
1159 WINPR_UNUSED(cls);
1160 freerdp* inst = (freerdp*)instance;
1161 jsize data_length = (*env)->GetArrayLength(env, jdata);
1162 jbyte* data = (*env)->GetByteArrayElements(env, jdata, nullptr);
1163 const char* mimeType = jmimeType ? (*env)->GetStringUTFChars(env, jmimeType, nullptr) : nullptr;
1164 jboolean ret = JNI_FALSE;
1165 if (android_is_image_mime_supported(mimeType))
1166 ret = android_push_clipboard_event(inst, data, (size_t)data_length, mimeType);
1167
1168 if (mimeType)
1169 (*env)->ReleaseStringUTFChars(env, jmimeType, mimeType);
1170 (*env)->ReleaseByteArrayElements(env, jdata, data, JNI_ABORT);
1171 return ret;
1172}
1173
1174JNIEXPORT jboolean JNICALL
1175Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1monitor_1layout(
1176 JNIEnv* env, jclass cls, jlong instance, jint width, jint height)
1177{
1178 WINPR_UNUSED(env);
1179 WINPR_UNUSED(cls);
1180 freerdp* inst = (freerdp*)instance;
1181
1182 if (!inst || !inst->context)
1183 return JNI_FALSE;
1184
1185 androidContext* afc = (androidContext*)inst->context;
1186 return android_disp_send_monitor_layout(afc, (UINT32)width, (UINT32)height) ? JNI_TRUE
1187 : JNI_FALSE;
1188}
1189
1190JNIEXPORT jstring JNICALL
1191Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1jni_1version(JNIEnv* env, jclass cls)
1192{
1193 return (*env)->NewStringUTF(env, FREERDP_JNI_VERSION);
1194}
1195
1196JNIEXPORT jboolean JNICALL
1197Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1has_1h264(JNIEnv* env, jclass cls)
1198{
1199 H264_CONTEXT* ctx = h264_context_new(FALSE);
1200 if (!ctx)
1201 return JNI_FALSE;
1202 h264_context_free(ctx);
1203 return JNI_TRUE;
1204}
1205
1206JNIEXPORT jboolean JNICALL
1207Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1has_1camera_1redirection(JNIEnv* env,
1208 jclass cls)
1209{
1210 return freerdp_video_conversion_supported(FREERDP_VIDEO_FORMAT_NV12,
1211 FREERDP_VIDEO_FORMAT_YUV420P)
1212 ? JNI_TRUE
1213 : JNI_FALSE;
1214}
1215
1216JNIEXPORT jstring JNICALL
1217Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1version(JNIEnv* env, jclass cls)
1218{
1219 return (*env)->NewStringUTF(env, freerdp_get_version_string());
1220}
1221
1222JNIEXPORT jstring JNICALL
1223Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1build_1revision(JNIEnv* env,
1224 jclass cls)
1225{
1226 return (*env)->NewStringUTF(env, freerdp_get_build_revision());
1227}
1228
1229JNIEXPORT jstring JNICALL
1230Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1build_1config(JNIEnv* env,
1231 jclass cls)
1232{
1233 return (*env)->NewStringUTF(env, freerdp_get_build_config());
1234}
1235
1236jint JNI_OnLoad(JavaVM* vm, void* reserved)
1237{
1238 JNIEnv* env;
1239 setlocale(LC_ALL, "");
1240 WLog_DBG(TAG, "Setting up JNI environment...");
1241
1242 /*
1243 if (freerdp_handle_signals() != 0)
1244 {
1245 WLog_FATAL(TAG, "Failed to register signal handler");
1246 return -1;
1247 }
1248 */
1249 if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK)
1250 {
1251 WLog_FATAL(TAG, "Failed to get the environment");
1252 return -1;
1253 }
1254
1255 // Get SBCEngine activity class
1256 jclass activityClass = (*env)->FindClass(env, JAVA_LIBFREERDP_CLASS);
1257
1258 if (!activityClass)
1259 {
1260 WLog_FATAL(TAG, "failed to get %s class reference", JAVA_LIBFREERDP_CLASS);
1261 return -1;
1262 }
1263
1264 /* create global reference for class */
1265 gJavaActivityClass = (*env)->NewGlobalRef(env, activityClass);
1266 gOnPointerSetMethod =
1267 (*env)->GetStaticMethodID(env, gJavaActivityClass, "OnPointerSet", "(J[IIIII)V");
1268 gOnRailWindowUpdateMethod =
1269 (*env)->GetStaticMethodID(env, gJavaActivityClass, "OnRailWindowUpdate", "(JJII[I)V");
1270 if (!gOnRailWindowUpdateMethod)
1271 {
1272 (*env)->ExceptionClear(env);
1273 WLog_WARN(TAG, "OnRailWindowUpdate method not found, RAIL window display disabled");
1274 }
1275 g_JavaVm = vm;
1276 return init_callback_environment(vm, env);
1277}
1278
1279void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved)
1280{
1281 JNIEnv* env;
1282 WLog_DBG(TAG, "Tearing down JNI environment...");
1283
1284 if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK)
1285 {
1286 WLog_FATAL(TAG, "Failed to get the environment");
1287 return;
1288 }
1289
1290 if (gJavaActivityClass)
1291 (*env)->DeleteGlobalRef(env, gJavaActivityClass);
1292}
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