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