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
27#include <freerdp/graphics.h>
28#include <freerdp/codec/rfx.h>
29#include <freerdp/gdi/gdi.h>
30#include <freerdp/gdi/gfx.h>
31#include <freerdp/client/rdpei.h>
32#include <freerdp/client/rdpgfx.h>
33#include <freerdp/client/cliprdr.h>
34#include <freerdp/codec/h264.h>
35#include <freerdp/channels/channels.h>
36#include <freerdp/client/channels.h>
37#include <freerdp/client/cmdline.h>
38#include <freerdp/constants.h>
39#include <freerdp/locale/keyboard.h>
40#include <freerdp/primitives.h>
41#include <freerdp/version.h>
42#include <freerdp/settings.h>
43#include <freerdp/utils/signal.h>
44
45#include <android/bitmap.h>
46
47#include "android_jni_callback.h"
48#include "android_jni_utils.h"
49#include "android_cliprdr.h"
50#include "android_freerdp_jni.h"
51
52#if defined(WITH_GPROF)
53#include "jni/prof.h"
54#endif
55
56#define TAG CLIENT_TAG("android")
57
58/* Defines the JNI version supported by this library. */
59#define FREERDP_JNI_VERSION FREERDP_VERSION_FULL
60static void android_OnChannelConnectedEventHandler(void* context,
61 const ChannelConnectedEventArgs* e)
62{
63 rdpSettings* settings;
64 androidContext* afc;
65
66 if (!context || !e)
67 {
68 WLog_FATAL(TAG, "(context=%p, EventArgs=%p", context, (void*)e);
69 return;
70 }
71
72 afc = (androidContext*)context;
73 settings = afc->common.context.settings;
74
75 if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
76 {
77 android_cliprdr_init(afc, (CliprdrClientContext*)e->pInterface);
78 }
79 else
80 freerdp_client_OnChannelConnectedEventHandler(context, e);
81}
82
83static void android_OnChannelDisconnectedEventHandler(void* context,
84 const ChannelDisconnectedEventArgs* e)
85{
86 rdpSettings* settings;
87 androidContext* afc;
88
89 if (!context || !e)
90 {
91 WLog_FATAL(TAG, "(context=%p, EventArgs=%p", context, (void*)e);
92 return;
93 }
94
95 afc = (androidContext*)context;
96 settings = afc->common.context.settings;
97
98 if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
99 {
100 android_cliprdr_uninit(afc, (CliprdrClientContext*)e->pInterface);
101 }
102 else
103 freerdp_client_OnChannelDisconnectedEventHandler(context, e);
104}
105
106static BOOL android_begin_paint(rdpContext* context)
107{
108 return TRUE;
109}
110
111static BOOL android_end_paint(rdpContext* context)
112{
113 HGDI_WND hwnd;
114 int ninvalid;
115 rdpGdi* gdi;
116 HGDI_RGN cinvalid;
117 int x1, y1, x2, y2;
118 androidContext* ctx = (androidContext*)context;
119 rdpSettings* settings;
120
121 if (!ctx || !context->instance)
122 return FALSE;
123
124 settings = context->settings;
125
126 if (!settings)
127 return FALSE;
128
129 gdi = context->gdi;
130
131 if (!gdi || !gdi->primary || !gdi->primary->hdc)
132 return FALSE;
133
134 hwnd = ctx->common.context.gdi->primary->hdc->hwnd;
135
136 if (!hwnd)
137 return FALSE;
138
139 ninvalid = hwnd->ninvalid;
140
141 if (ninvalid < 1)
142 return TRUE;
143
144 cinvalid = hwnd->cinvalid;
145
146 if (!cinvalid)
147 return FALSE;
148
149 x1 = cinvalid[0].x;
150 y1 = cinvalid[0].y;
151 x2 = cinvalid[0].x + cinvalid[0].w;
152 y2 = cinvalid[0].y + cinvalid[0].h;
153
154 for (int i = 0; i < ninvalid; i++)
155 {
156 x1 = MIN(x1, cinvalid[i].x);
157 y1 = MIN(y1, cinvalid[i].y);
158 x2 = MAX(x2, cinvalid[i].x + cinvalid[i].w);
159 y2 = MAX(y2, cinvalid[i].y + cinvalid[i].h);
160 }
161
162 freerdp_callback("OnGraphicsUpdate", "(JIIII)V", (jlong)context->instance, x1, y1, x2 - x1,
163 y2 - y1);
164
165 hwnd->invalid->null = TRUE;
166 hwnd->ninvalid = 0;
167 return TRUE;
168}
169
170static BOOL android_desktop_resize(rdpContext* context)
171{
172 WINPR_ASSERT(context);
173 WINPR_ASSERT(context->settings);
174 WINPR_ASSERT(context->instance);
175
176 freerdp_callback("OnGraphicsResize", "(JIII)V", (jlong)context->instance,
177 freerdp_settings_get_uint32(context->settings, FreeRDP_DesktopWidth),
178 freerdp_settings_get_uint32(context->settings, FreeRDP_DesktopHeight),
179 freerdp_settings_get_uint32(context->settings, FreeRDP_ColorDepth));
180 return TRUE;
181}
182
183static BOOL android_pre_connect(freerdp* instance)
184{
185 WINPR_ASSERT(instance);
186 WINPR_ASSERT(instance->context);
187
188 rdpSettings* settings = instance->context->settings;
189
190 if (!settings)
191 return FALSE;
192
193 int rc = PubSub_SubscribeChannelConnected(instance->context->pubSub,
194 android_OnChannelConnectedEventHandler);
195
196 if (rc != CHANNEL_RC_OK)
197 {
198 WLog_ERR(TAG, "Could not subscribe to connect event handler [%08X]", rc);
199 return FALSE;
200 }
201
202 rc = PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
203 android_OnChannelDisconnectedEventHandler);
204
205 if (rc != CHANNEL_RC_OK)
206 {
207 WLog_ERR(TAG, "Could not subscribe to disconnect event handler [%08X]", rc);
208 return FALSE;
209 }
210
211 freerdp_callback("OnPreConnect", "(J)V", (jlong)instance);
212 return TRUE;
213}
214
215static BOOL android_Pointer_New(rdpContext* context, rdpPointer* pointer)
216{
217 WINPR_ASSERT(context);
218 WINPR_ASSERT(pointer);
219 WINPR_ASSERT(context->gdi);
220
221 return TRUE;
222}
223
224static void android_Pointer_Free(rdpContext* context, rdpPointer* pointer)
225{
226 WINPR_ASSERT(context);
227}
228
229static BOOL android_Pointer_Set(rdpContext* context, rdpPointer* pointer)
230{
231 WINPR_ASSERT(context);
232 WINPR_ASSERT(pointer);
233
234 return TRUE;
235}
236
237static BOOL android_Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
238{
239 WINPR_ASSERT(context);
240
241 return TRUE;
242}
243
244static BOOL android_Pointer_SetNull(rdpContext* context)
245{
246 WINPR_ASSERT(context);
247
248 return TRUE;
249}
250
251static BOOL android_Pointer_SetDefault(rdpContext* context)
252{
253 WINPR_ASSERT(context);
254
255 return TRUE;
256}
257
258static BOOL android_register_pointer(rdpGraphics* graphics)
259{
260 rdpPointer pointer = { 0 };
261
262 if (!graphics)
263 return FALSE;
264
265 pointer.size = sizeof(pointer);
266 pointer.New = android_Pointer_New;
267 pointer.Free = android_Pointer_Free;
268 pointer.Set = android_Pointer_Set;
269 pointer.SetNull = android_Pointer_SetNull;
270 pointer.SetDefault = android_Pointer_SetDefault;
271 pointer.SetPosition = android_Pointer_SetPosition;
272 graphics_register_pointer(graphics, &pointer);
273 return TRUE;
274}
275
276static BOOL android_post_connect(freerdp* instance)
277{
278 rdpSettings* settings;
279 rdpUpdate* update;
280
281 WINPR_ASSERT(instance);
282 WINPR_ASSERT(instance->context);
283
284 update = instance->context->update;
285 WINPR_ASSERT(update);
286
287 settings = instance->context->settings;
288 WINPR_ASSERT(settings);
289
290 if (!gdi_init(instance, PIXEL_FORMAT_RGBX32))
291 return FALSE;
292
293 if (!android_register_pointer(instance->context->graphics))
294 return FALSE;
295
296 update->BeginPaint = android_begin_paint;
297 update->EndPaint = android_end_paint;
298 update->DesktopResize = android_desktop_resize;
299 freerdp_callback("OnSettingsChanged", "(JIII)V", (jlong)instance,
300 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
301 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
302 freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
303 freerdp_callback("OnConnectionSuccess", "(J)V", (jlong)instance);
304 return TRUE;
305}
306
307static void android_post_disconnect(freerdp* instance)
308{
309 freerdp_callback("OnDisconnecting", "(J)V", (jlong)instance);
310 gdi_free(instance);
311}
312
313static BOOL android_authenticate_int(freerdp* instance, char** username, char** password,
314 char** domain, const char* cb_name)
315{
316 JNIEnv* env;
317 jboolean attached = jni_attach_thread(&env);
318 jobject jstr1 = create_string_builder(env, *username);
319 jobject jstr2 = create_string_builder(env, *domain);
320 jobject jstr3 = create_string_builder(env, *password);
321 jboolean res;
322 res = freerdp_callback_bool_result(cb_name,
323 "(JLjava/lang/StringBuilder;"
324 "Ljava/lang/StringBuilder;"
325 "Ljava/lang/StringBuilder;)Z",
326 (jlong)instance, jstr1, jstr2, jstr3);
327
328 if (res == JNI_TRUE)
329 {
330 // read back string values
331 free(*username);
332 *username = get_string_from_string_builder(env, jstr1);
333 free(*domain);
334 *domain = get_string_from_string_builder(env, jstr2);
335 free(*password);
336 *password = get_string_from_string_builder(env, jstr3);
337 }
338
339 if (attached == JNI_TRUE)
340 jni_detach_thread();
341
342 return ((res == JNI_TRUE) ? TRUE : FALSE);
343}
344
345static BOOL android_authenticate(freerdp* instance, char** username, char** password, char** domain)
346{
347 return android_authenticate_int(instance, username, password, domain, "OnAuthenticate");
348}
349
350static BOOL android_gw_authenticate(freerdp* instance, char** username, char** password,
351 char** domain)
352{
353 return android_authenticate_int(instance, username, password, domain, "OnGatewayAuthenticate");
354}
355
356static DWORD android_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
357 const char* common_name, const char* subject,
358 const char* issuer, const char* fingerprint, DWORD flags)
359{
360 WLog_DBG(TAG, "Certificate details [%s:%" PRIu16 ":", host, port);
361 WLog_DBG(TAG, "\tSubject: %s", subject);
362 WLog_DBG(TAG, "\tIssuer: %s", issuer);
363 WLog_DBG(TAG, "\tThumbprint: %s", fingerprint);
364 WLog_DBG(TAG,
365 "The above X.509 certificate could not be verified, possibly because you do not have "
366 "the CA certificate in your certificate store, or the certificate has expired."
367 "Please look at the OpenSSL documentation on how to add a private CA to the store.\n");
368 JNIEnv* env;
369 jboolean attached = jni_attach_thread(&env);
370 jstring jstr0 = (*env)->NewStringUTF(env, host);
371 jstring jstr1 = (*env)->NewStringUTF(env, common_name);
372 jstring jstr2 = (*env)->NewStringUTF(env, subject);
373 jstring jstr3 = (*env)->NewStringUTF(env, issuer);
374 jstring jstr4 = (*env)->NewStringUTF(env, fingerprint);
375 jint res = freerdp_callback_int_result("OnVerifyCertificateEx",
376 "(JLjava/lang/String;JLjava/lang/String;Ljava/lang/"
377 "String;Ljava/lang/String;Ljava/lang/String;J)I",
378 (jlong)instance, jstr0, (jlong)port, jstr1, jstr2, jstr3,
379 jstr4, (jlong)flags);
380
381 if (attached == JNI_TRUE)
382 jni_detach_thread();
383
384 return res;
385}
386
387static DWORD android_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
388 const char* common_name, const char* subject,
389 const char* issuer, const char* new_fingerprint,
390 const char* old_subject, const char* old_issuer,
391 const char* old_fingerprint, DWORD flags)
392{
393 JNIEnv* env;
394 jboolean attached = jni_attach_thread(&env);
395 jstring jhost = (*env)->NewStringUTF(env, host);
396 jstring jstr0 = (*env)->NewStringUTF(env, common_name);
397 jstring jstr1 = (*env)->NewStringUTF(env, subject);
398 jstring jstr2 = (*env)->NewStringUTF(env, issuer);
399 jstring jstr3 = (*env)->NewStringUTF(env, new_fingerprint);
400 jstring jstr4 = (*env)->NewStringUTF(env, old_subject);
401 jstring jstr5 = (*env)->NewStringUTF(env, old_issuer);
402 jstring jstr6 = (*env)->NewStringUTF(env, old_fingerprint);
403 jint res =
404 freerdp_callback_int_result("OnVerifyChangedCertificateEx",
405 "(JLjava/lang/String;JLjava/lang/String;Ljava/lang/"
406 "String;Ljava/lang/String;Ljava/lang/String;"
407 "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;J)I",
408 (jlong)instance, jhost, (jlong)port, jstr0, jstr1, jstr2, jstr3,
409 jstr4, jstr5, jstr6, (jlong)flags);
410
411 if (attached == JNI_TRUE)
412 jni_detach_thread();
413
414 return res;
415}
416
417static int android_freerdp_run(freerdp* instance)
418{
419 DWORD count;
420 DWORD status = WAIT_FAILED;
421 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
422 HANDLE inputEvent = NULL;
423 const rdpSettings* settings = instance->context->settings;
424 rdpContext* context = instance->context;
425
426 inputEvent = android_get_handle(instance);
427
428 while (!freerdp_shall_disconnect_context(instance->context))
429 {
430 DWORD tmp;
431 count = 0;
432
433 handles[count++] = inputEvent;
434
435 tmp = freerdp_get_event_handles(context, &handles[count], 64 - count);
436
437 if (tmp == 0)
438 {
439 WLog_ERR(TAG, "freerdp_get_event_handles failed");
440 break;
441 }
442
443 count += tmp;
444 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
445
446 if (status == WAIT_FAILED)
447 {
448 WLog_ERR(TAG, "WaitForMultipleObjects failed with %u [%08X]", status,
449 (unsigned)GetLastError());
450 break;
451 }
452
453 if (!freerdp_check_event_handles(context))
454 {
455 /* TODO: Auto reconnect
456 if (xf_auto_reconnect(instance))
457 continue;
458 */
459 WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
460 status = GetLastError();
461 break;
462 }
463
464 if (freerdp_shall_disconnect_context(instance->context))
465 break;
466
467 if (android_check_handle(instance) != TRUE)
468 {
469 WLog_ERR(TAG, "Failed to check android file descriptor");
470 status = GetLastError();
471 break;
472 }
473 }
474
475disconnect:
476 WLog_INFO(TAG, "Prepare shutdown...");
477
478 return status;
479}
480
481static DWORD WINAPI android_thread_func(LPVOID param)
482{
483 DWORD status = ERROR_BAD_ARGUMENTS;
484 freerdp* instance = param;
485 WLog_DBG(TAG, "Start...");
486
487 WINPR_ASSERT(instance);
488 WINPR_ASSERT(instance->context);
489
490 if (freerdp_client_start(instance->context) != CHANNEL_RC_OK)
491 goto fail;
492
493 WLog_DBG(TAG, "Connect...");
494
495 if (!freerdp_connect(instance))
496 status = GetLastError();
497 else
498 {
499 status = android_freerdp_run(instance);
500 WLog_DBG(TAG, "Disconnect...");
501
502 if (!freerdp_disconnect(instance))
503 status = GetLastError();
504 }
505
506 WLog_DBG(TAG, "Stop...");
507
508 if (freerdp_client_stop(instance->context) != CHANNEL_RC_OK)
509 goto fail;
510
511fail:
512 WLog_DBG(TAG, "Session ended with %08" PRIX32 "", status);
513
514 if (status == CHANNEL_RC_OK)
515 freerdp_callback("OnDisconnected", "(J)V", (jlong)instance);
516 else
517 freerdp_callback("OnConnectionFailure", "(J)V", (jlong)instance);
518
519 WLog_DBG(TAG, "Quit.");
520 ExitThread(status);
521 return status;
522}
523
524static BOOL android_client_new(freerdp* instance, rdpContext* context)
525{
526 WINPR_ASSERT(instance);
527 WINPR_ASSERT(context);
528
529 if (!android_event_queue_init(instance))
530 return FALSE;
531
532 instance->PreConnect = android_pre_connect;
533 instance->PostConnect = android_post_connect;
534 instance->PostDisconnect = android_post_disconnect;
535 instance->Authenticate = android_authenticate;
536 instance->GatewayAuthenticate = android_gw_authenticate;
537 instance->VerifyCertificateEx = android_verify_certificate_ex;
538 instance->VerifyChangedCertificateEx = android_verify_changed_certificate_ex;
539 instance->LogonErrorInfo = NULL;
540 return TRUE;
541}
542
543static void android_client_free(freerdp* instance, rdpContext* context)
544{
545 if (!context)
546 return;
547
548 android_event_queue_uninit(instance);
549}
550
551static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
552{
553 WINPR_ASSERT(pEntryPoints);
554
555 ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
556
557 pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
558 pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
559 pEntryPoints->GlobalInit = NULL;
560 pEntryPoints->GlobalUninit = NULL;
561 pEntryPoints->ContextSize = sizeof(androidContext);
562 pEntryPoints->ClientNew = android_client_new;
563 pEntryPoints->ClientFree = android_client_free;
564 pEntryPoints->ClientStart = NULL;
565 pEntryPoints->ClientStop = NULL;
566 return 0;
567}
568
569JNIEXPORT jlong JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1new(
570 JNIEnv* env, jclass cls, jobject context)
571{
572 jclass contextClass;
573 jclass fileClass;
574 jobject filesDirObj;
575 jmethodID getFilesDirID;
576 jmethodID getAbsolutePathID;
577 jstring path;
578 const char* raw;
579 char* envStr;
580 RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
581 rdpContext* ctx;
582#if defined(WITH_GPROF)
583 setenv("CPUPROFILE_FREQUENCY", "200", 1);
584 monstartup("libfreerdp-android.so");
585#endif
586 contextClass = (*env)->FindClass(env, JAVA_CONTEXT_CLASS);
587 fileClass = (*env)->FindClass(env, JAVA_FILE_CLASS);
588
589 if (!contextClass || !fileClass)
590 {
591 WLog_FATAL(TAG, "Failed to load class references %s=%p, %s=%p", JAVA_CONTEXT_CLASS,
592 (void*)contextClass, JAVA_FILE_CLASS, (void*)fileClass);
593 return (jlong)NULL;
594 }
595
596 getFilesDirID =
597 (*env)->GetMethodID(env, contextClass, "getFilesDir", "()L" JAVA_FILE_CLASS ";");
598
599 if (!getFilesDirID)
600 {
601 WLog_FATAL(TAG, "Failed to find method ID getFilesDir ()L" JAVA_FILE_CLASS ";");
602 return (jlong)NULL;
603 }
604
605 getAbsolutePathID =
606 (*env)->GetMethodID(env, fileClass, "getAbsolutePath", "()Ljava/lang/String;");
607
608 if (!getAbsolutePathID)
609 {
610 WLog_FATAL(TAG, "Failed to find method ID getAbsolutePath ()Ljava/lang/String;");
611 return (jlong)NULL;
612 }
613
614 filesDirObj = (*env)->CallObjectMethod(env, context, getFilesDirID);
615
616 if (!filesDirObj)
617 {
618 WLog_FATAL(TAG, "Failed to call getFilesDir");
619 return (jlong)NULL;
620 }
621
622 path = (*env)->CallObjectMethod(env, filesDirObj, getAbsolutePathID);
623
624 if (!path)
625 {
626 WLog_FATAL(TAG, "Failed to call getAbsolutePath");
627 return (jlong)NULL;
628 }
629
630 raw = (*env)->GetStringUTFChars(env, path, 0);
631
632 if (!raw)
633 {
634 WLog_FATAL(TAG, "Failed to get C string from java string");
635 return (jlong)NULL;
636 }
637
638 envStr = _strdup(raw);
639 (*env)->ReleaseStringUTFChars(env, path, raw);
640
641 if (!envStr)
642 {
643 WLog_FATAL(TAG, "_strdup(%s) failed", raw);
644 return (jlong)NULL;
645 }
646
647 if (setenv("HOME", _strdup(envStr), 1) != 0)
648 {
649 char ebuffer[256] = { 0 };
650 WLog_FATAL(TAG, "Failed to set environment HOME=%s %s [%d]", envStr,
651 winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
652 return (jlong)NULL;
653 }
654
655 RdpClientEntry(&clientEntryPoints);
656 ctx = freerdp_client_context_new(&clientEntryPoints);
657
658 if (!ctx)
659 return (jlong)NULL;
660
661 return (jlong)ctx->instance;
662}
663
664JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1free(
665 JNIEnv* env, jclass cls, jlong instance)
666{
667 freerdp* inst = (freerdp*)instance;
668
669 if (inst)
670 freerdp_client_context_free(inst->context);
671
672#if defined(WITH_GPROF)
673 moncleanup();
674#endif
675}
676
677JNIEXPORT jstring JNICALL
678Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1last_1error_1string(JNIEnv* env,
679 jclass cls,
680 jlong instance)
681{
682 freerdp* inst = (freerdp*)instance;
683
684 if (!inst || !inst->context)
685 return (*env)->NewStringUTF(env, "");
686
687 return (*env)->NewStringUTF(
688 env, freerdp_get_last_error_string(freerdp_get_last_error(inst->context)));
689}
690
691JNIEXPORT jboolean JNICALL
692Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1parse_1arguments(JNIEnv* env, jclass cls,
693 jlong instance,
694 jobjectArray arguments)
695{
696 freerdp* inst = (freerdp*)instance;
697 int count;
698 char** argv;
699 DWORD status;
700
701 if (!inst || !inst->context)
702 return JNI_FALSE;
703
704 count = (*env)->GetArrayLength(env, arguments);
705 argv = calloc(count, sizeof(char*));
706
707 if (!argv)
708 return JNI_TRUE;
709
710 for (int i = 0; i < count; i++)
711 {
712 jstring str = (jstring)(*env)->GetObjectArrayElement(env, arguments, i);
713 const char* raw = (*env)->GetStringUTFChars(env, str, 0);
714 argv[i] = _strdup(raw);
715 (*env)->ReleaseStringUTFChars(env, str, raw);
716 }
717
718 status =
719 freerdp_client_settings_parse_command_line(inst->context->settings, count, argv, FALSE);
720
721 for (int i = 0; i < count; i++)
722 free(argv[i]);
723
724 free(argv);
725 return (status == 0) ? JNI_TRUE : JNI_FALSE;
726}
727
728JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1connect(
729 JNIEnv* env, jclass cls, jlong instance)
730{
731 freerdp* inst = (freerdp*)instance;
732
733 if (!inst || !inst->context)
734 {
735 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%lld", (void*)env, (void*)cls, instance);
736 return JNI_FALSE;
737 }
738
739 androidContext* ctx = (androidContext*)inst->context;
740
741 if (!(ctx->thread = CreateThread(NULL, 0, android_thread_func, inst, 0, NULL)))
742 {
743 return JNI_FALSE;
744 }
745
746 return JNI_TRUE;
747}
748
749JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1disconnect(
750 JNIEnv* env, jclass cls, jlong instance)
751{
752 freerdp* inst = (freerdp*)instance;
753
754 if (!inst || !inst->context || !cls || !env)
755 {
756 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%lld", (void*)env, (void*)cls, instance);
757 return JNI_FALSE;
758 }
759
760 androidContext* ctx = (androidContext*)inst->context;
761 ANDROID_EVENT* event = (ANDROID_EVENT*)android_event_disconnect_new();
762
763 if (!event)
764 return JNI_FALSE;
765
766 if (!android_push_event(inst, event))
767 {
768 android_event_free((ANDROID_EVENT*)event);
769 return JNI_FALSE;
770 }
771
772 if (!freerdp_abort_connect_context(inst->context))
773 return JNI_FALSE;
774
775 return JNI_TRUE;
776}
777
778JNIEXPORT jboolean JNICALL
779Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1update_1graphics(JNIEnv* env, jclass cls,
780 jlong instance,
781 jobject bitmap, jint x,
782 jint y, jint width,
783 jint height)
784{
785 UINT32 DstFormat;
786 jboolean rc;
787 int ret;
788 void* pixels;
789 AndroidBitmapInfo info;
790 freerdp* inst = (freerdp*)instance;
791 rdpGdi* gdi;
792
793 if (!env || !cls || !inst)
794 {
795 WLog_FATAL(TAG, "(env=%p, cls=%p, instance=%lld", (void*)env, (void*)cls, instance);
796 return JNI_FALSE;
797 }
798
799 gdi = inst->context->gdi;
800
801 if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0)
802 {
803 WLog_FATAL(TAG, "AndroidBitmap_getInfo() failed ! error=%d", ret);
804 return JNI_FALSE;
805 }
806
807 if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0)
808 {
809 WLog_FATAL(TAG, "AndroidBitmap_lockPixels() failed ! error=%d", ret);
810 return JNI_FALSE;
811 }
812
813 rc = JNI_TRUE;
814
815 switch (info.format)
816 {
817 case ANDROID_BITMAP_FORMAT_RGBA_8888:
818 DstFormat = PIXEL_FORMAT_RGBX32;
819 break;
820
821 case ANDROID_BITMAP_FORMAT_RGB_565:
822 DstFormat = PIXEL_FORMAT_RGB16;
823 break;
824
825 case ANDROID_BITMAP_FORMAT_RGBA_4444:
826 case ANDROID_BITMAP_FORMAT_A_8:
827 case ANDROID_BITMAP_FORMAT_NONE:
828 default:
829 rc = JNI_FALSE;
830 break;
831 }
832
833 if (rc)
834 {
835 rc = freerdp_image_copy(pixels, DstFormat, info.stride, x, y, width, height,
836 gdi->primary_buffer, gdi->dstFormat, gdi->stride, x, y,
837 &gdi->palette, FREERDP_FLIP_NONE);
838 }
839
840 if ((ret = AndroidBitmap_unlockPixels(env, bitmap)) < 0)
841 {
842 WLog_FATAL(TAG, "AndroidBitmap_unlockPixels() failed ! error=%d", ret);
843 return JNI_FALSE;
844 }
845
846 return rc;
847}
848
849JNIEXPORT jboolean JNICALL
850Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event(JNIEnv* env, jclass cls,
851 jlong instance,
852 jint keycode,
853 jboolean down)
854{
855 DWORD scancode;
856 ANDROID_EVENT* event;
857 freerdp* inst = (freerdp*)instance;
858 scancode = GetVirtualScanCodeFromVirtualKeyCode(keycode, 4);
859 int flags = (down == JNI_TRUE) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE;
860 flags |= (scancode & KBDEXT) ? KBD_FLAGS_EXTENDED : 0;
861 event = (ANDROID_EVENT*)android_event_key_new(flags, scancode & 0xFF);
862
863 if (!event)
864 return JNI_FALSE;
865
866 if (!android_push_event(inst, event))
867 {
868 android_event_free(event);
869 return JNI_FALSE;
870 }
871
872 WLog_DBG(TAG, "send_key_event: %" PRIu32 ", %d", scancode, flags);
873 return JNI_TRUE;
874}
875
876JNIEXPORT jboolean JNICALL
877Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event(
878 JNIEnv* env, jclass cls, jlong instance, jint keycode, jboolean down)
879{
880 ANDROID_EVENT* event;
881 freerdp* inst = (freerdp*)instance;
882 UINT16 flags = (down == JNI_TRUE) ? 0 : KBD_FLAGS_RELEASE;
883 event = (ANDROID_EVENT*)android_event_unicodekey_new(flags, keycode);
884
885 if (!event)
886 return JNI_FALSE;
887
888 if (!android_push_event(inst, event))
889 {
890 android_event_free(event);
891 return JNI_FALSE;
892 }
893
894 WLog_DBG(TAG, "send_unicodekey_event: %d", keycode);
895 return JNI_TRUE;
896}
897
898JNIEXPORT jboolean JNICALL
899Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event(
900 JNIEnv* env, jclass cls, jlong instance, jint x, jint y, jint flags)
901{
902 ANDROID_EVENT* event;
903 freerdp* inst = (freerdp*)instance;
904 event = (ANDROID_EVENT*)android_event_cursor_new(flags, x, y);
905
906 if (!event)
907 return JNI_FALSE;
908
909 if (!android_push_event(inst, event))
910 {
911 android_event_free(event);
912 return JNI_FALSE;
913 }
914
915 WLog_DBG(TAG, "send_cursor_event: (%d, %d), %d", x, y, flags);
916 return JNI_TRUE;
917}
918
919JNIEXPORT jboolean JNICALL
920Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data(JNIEnv* env,
921 jclass cls,
922 jlong instance,
923 jstring jdata)
924{
925 ANDROID_EVENT* event;
926 freerdp* inst = (freerdp*)instance;
927 const char* data = jdata != NULL ? (*env)->GetStringUTFChars(env, jdata, NULL) : NULL;
928 const size_t data_length = data ? (*env)->GetStringUTFLength(env, jdata) : 0;
929 jboolean ret = JNI_FALSE;
930 event = (ANDROID_EVENT*)android_event_clipboard_new((void*)data, data_length);
931
932 if (!event)
933 goto out_fail;
934
935 if (!android_push_event(inst, event))
936 {
937 android_event_free(event);
938 goto out_fail;
939 }
940
941 WLog_DBG(TAG, "send_clipboard_data: (%s)", data);
942 ret = JNI_TRUE;
943out_fail:
944
945 if (data)
946 (*env)->ReleaseStringUTFChars(env, jdata, data);
947
948 return ret;
949}
950
951JNIEXPORT jstring JNICALL
952Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1jni_1version(JNIEnv* env, jclass cls)
953{
954 return (*env)->NewStringUTF(env, FREERDP_JNI_VERSION);
955}
956
957JNIEXPORT jboolean JNICALL
958Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1has_1h264(JNIEnv* env, jclass cls)
959{
960 H264_CONTEXT* ctx = h264_context_new(FALSE);
961 if (!ctx)
962 return JNI_FALSE;
963 h264_context_free(ctx);
964 return JNI_TRUE;
965}
966
967JNIEXPORT jstring JNICALL
968Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1version(JNIEnv* env, jclass cls)
969{
970 return (*env)->NewStringUTF(env, freerdp_get_version_string());
971}
972
973JNIEXPORT jstring JNICALL
974Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1build_1revision(JNIEnv* env,
975 jclass cls)
976{
977 return (*env)->NewStringUTF(env, freerdp_get_build_revision());
978}
979
980JNIEXPORT jstring JNICALL
981Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1build_1config(JNIEnv* env,
982 jclass cls)
983{
984 return (*env)->NewStringUTF(env, freerdp_get_build_config());
985}
986
987static jclass gJavaActivityClass = NULL;
988
989jint JNI_OnLoad(JavaVM* vm, void* reserved)
990{
991 JNIEnv* env;
992 setlocale(LC_ALL, "");
993 WLog_DBG(TAG, "Setting up JNI environment...");
994
995 /*
996 if (freerdp_handle_signals() != 0)
997 {
998 WLog_FATAL(TAG, "Failed to register signal handler");
999 return -1;
1000 }
1001 */
1002 if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK)
1003 {
1004 WLog_FATAL(TAG, "Failed to get the environment");
1005 return -1;
1006 }
1007
1008 // Get SBCEngine activity class
1009 jclass activityClass = (*env)->FindClass(env, JAVA_LIBFREERDP_CLASS);
1010
1011 if (!activityClass)
1012 {
1013 WLog_FATAL(TAG, "failed to get %s class reference", JAVA_LIBFREERDP_CLASS);
1014 return -1;
1015 }
1016
1017 /* create global reference for class */
1018 gJavaActivityClass = (*env)->NewGlobalRef(env, activityClass);
1019 g_JavaVm = vm;
1020 return init_callback_environment(vm, env);
1021}
1022
1023void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved)
1024{
1025 JNIEnv* env;
1026 WLog_DBG(TAG, "Tearing down JNI environment...");
1027
1028 if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK)
1029 {
1030 WLog_FATAL(TAG, "Failed to get the environment");
1031 return;
1032 }
1033
1034 if (gJavaActivityClass)
1035 (*env)->DeleteGlobalRef(env, gJavaActivityClass);
1036}
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.
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