FreeRDP
Loading...
Searching...
No Matches
android_event.c
1
12
13#include <freerdp/config.h>
14
15#include <winpr/crt.h>
16
17#include <freerdp/freerdp.h>
18#include <freerdp/client.h>
19#include <freerdp/input.h>
20#include <freerdp/log.h>
21
22#define TAG CLIENT_TAG("android")
23
24#include "android_freerdp.h"
25#include "android_cliprdr.h"
26
27/* Merges a pure move into a pure move still waiting at the tail of the queue */
28WINPR_ATTR_NODISCARD
29static BOOL android_coalesce_cursor_move(ANDROID_EVENT_QUEUE* queue, const ANDROID_EVENT* event)
30{
31 WINPR_ASSERT(queue);
32 WINPR_ASSERT(event);
33
34 if ((queue->count < 1) || (event->type != EVENT_TYPE_CURSOR))
35 return FALSE;
36
37 const ANDROID_EVENT_CURSOR* cursor = (const ANDROID_EVENT_CURSOR*)event;
38 if (cursor->flags != PTR_FLAGS_MOVE)
39 return FALSE;
40
41 ANDROID_EVENT* last = queue->events[queue->count - 1];
42 if (!last || (last->type != EVENT_TYPE_CURSOR))
43 return FALSE;
44
45 ANDROID_EVENT_CURSOR* lastCursor = (ANDROID_EVENT_CURSOR*)last;
46 if (lastCursor->flags != PTR_FLAGS_MOVE)
47 return FALSE;
48
49 lastCursor->x = cursor->x;
50 lastCursor->y = cursor->y;
51 return TRUE;
52}
53
54BOOL android_push_event(freerdp* inst, ANDROID_EVENT* event)
55{
56 if (!inst || !inst->context || !event)
57 return FALSE;
58
59 androidContext* aCtx = (androidContext*)inst->context;
60 ANDROID_EVENT_QUEUE* queue = aCtx->event_queue;
61 if (!queue)
62 return FALSE;
63
64 EnterCriticalSection(&queue->lock);
65
66 if (android_coalesce_cursor_move(queue, event))
67 {
68 /* the queued move is still pending, no need to signal */
69 LeaveCriticalSection(&queue->lock);
70 android_event_free(event);
71 return TRUE;
72 }
73
74 if (queue->count >= queue->size)
75 {
76 size_t new_size = queue->size;
77 do
78 {
79 if (new_size >= SIZE_MAX - 128ull)
80 {
81 LeaveCriticalSection(&queue->lock);
82 return FALSE;
83 }
84
85 new_size += 128ull;
86 } while (new_size <= queue->count);
87 void* new_events = realloc((void*)queue->events, sizeof(ANDROID_EVENT*) * new_size);
88
89 if (!new_events)
90 {
91 LeaveCriticalSection(&queue->lock);
92 return FALSE;
93 }
94
95 queue->events = (ANDROID_EVENT**)new_events;
96 queue->size = new_size;
97 }
98
99 queue->events[queue->count++] = event;
100 LeaveCriticalSection(&queue->lock);
101
102 /* the queue owns the event now, the caller must not free it */
103 if (!SetEvent(queue->isSet))
104 WLog_WARN(TAG, "SetEvent failed");
105 return TRUE;
106}
107
108WINPR_ATTR_NODISCARD
109static ANDROID_EVENT* android_pop_event(ANDROID_EVENT_QUEUE* queue)
110{
111 ANDROID_EVENT* event = nullptr;
112
113 WINPR_ASSERT(queue);
114
115 if (queue->count < 1)
116 return nullptr;
117
118 event = queue->events[0];
119 (queue->count)--;
120
121 for (size_t i = 0; i < queue->count; i++)
122 {
123 queue->events[i] = queue->events[i + 1];
124 }
125
126 return event;
127}
128
129WINPR_ATTR_NODISCARD
130static BOOL android_process_event(ANDROID_EVENT_QUEUE* queue, freerdp* inst)
131{
132 rdpContext* context;
133
134 WINPR_ASSERT(queue);
135 WINPR_ASSERT(inst);
136
137 context = inst->context;
138 WINPR_ASSERT(context);
139
140 for (;;)
141 {
142 BOOL rc = FALSE;
143 androidContext* afc = (androidContext*)context;
144
145 EnterCriticalSection(&queue->lock);
146 ANDROID_EVENT* event = android_pop_event(queue);
147 LeaveCriticalSection(&queue->lock);
148
149 if (!event)
150 break;
151
152 switch (event->type)
153 {
154 case EVENT_TYPE_KEY:
155 {
156 ANDROID_EVENT_KEY* key_event = (ANDROID_EVENT_KEY*)event;
157
158 rc = freerdp_input_send_keyboard_event(context->input, key_event->flags,
159 key_event->scancode);
160 }
161 break;
162
163 case EVENT_TYPE_KEY_UNICODE:
164 {
165 ANDROID_EVENT_KEY* key_event = (ANDROID_EVENT_KEY*)event;
166
167 rc = freerdp_input_send_unicode_keyboard_event(context->input, key_event->flags,
168 key_event->scancode);
169 }
170 break;
171
172 case EVENT_TYPE_KEY_AS_UNICODE:
173 {
175
176 /* The Java side still sends key combinations as virtual keys, so for now no Ctrl,
177 * Alt or Win is in the mask here. */
178 rc = freerdp_client_send_key_as_unicode(&afc->common, key_event->flags,
179 key_event->str, key_event->scancode,
180 key_event->modmask);
181 }
182 break;
183
184 case EVENT_TYPE_CURSOR:
185 {
186 ANDROID_EVENT_CURSOR* cursor_event = (ANDROID_EVENT_CURSOR*)event;
187
188 rc = freerdp_input_send_mouse_event(context->input, cursor_event->flags,
189 cursor_event->x, cursor_event->y);
190 }
191 break;
192
193 case EVENT_TYPE_CLIPBOARD:
194 {
195 ANDROID_EVENT_CLIPBOARD* clipboard_event = (ANDROID_EVENT_CLIPBOARD*)event;
196 const char* mimeType = clipboard_event->mimeType;
197 UINT32 formatId = ClipboardRegisterFormat(afc->clipboard, mimeType);
198 UINT32 size = clipboard_event->data_length;
199
200 if (size)
201 ClipboardSetData(afc->clipboard, formatId, clipboard_event->data, size);
202 else
203 ClipboardEmpty(afc->clipboard);
204
205 rc = (android_cliprdr_send_client_format_list(afc->cliprdr) == CHANNEL_RC_OK);
206 }
207 break;
208
209 case EVENT_TYPE_DISCONNECT:
210 default:
211 break;
212 }
213
214 android_event_free(event);
215
216 if (!rc)
217 return FALSE;
218 }
219
220 return TRUE;
221}
222
223HANDLE android_get_handle(freerdp* inst)
224{
225 androidContext* aCtx;
226
227 if (!inst || !inst->context)
228 return nullptr;
229
230 aCtx = (androidContext*)inst->context;
231
232 if (!aCtx->event_queue || !aCtx->event_queue->isSet)
233 return nullptr;
234
235 return aCtx->event_queue->isSet;
236}
237
238BOOL android_check_handle(freerdp* inst)
239{
240 androidContext* aCtx;
241
242 if (!inst || !inst->context)
243 return FALSE;
244
245 aCtx = (androidContext*)inst->context;
246
247 if (!aCtx->event_queue || !aCtx->event_queue->isSet)
248 return FALSE;
249
250 if (WaitForSingleObject(aCtx->event_queue->isSet, 0) == WAIT_OBJECT_0)
251 {
252 if (!ResetEvent(aCtx->event_queue->isSet))
253 return FALSE;
254
255 if (!android_process_event(aCtx->event_queue, inst))
256 return FALSE;
257 }
258
259 return TRUE;
260}
261
262ANDROID_EVENT_KEY* android_event_key_new(int flags, UINT16 scancode)
263{
264 ANDROID_EVENT_KEY* event = (ANDROID_EVENT_KEY*)calloc(1, sizeof(ANDROID_EVENT_KEY));
265
266 if (!event)
267 return nullptr;
268
269 event->type = EVENT_TYPE_KEY;
270 event->flags = flags;
271 event->scancode = scancode;
272 return event;
273}
274
275static void android_event_key_free(ANDROID_EVENT_KEY* event)
276{
277 free(event);
278}
279
280ANDROID_EVENT_KEY* android_event_unicodekey_new(UINT16 flags, UINT16 key)
281{
282 ANDROID_EVENT_KEY* event;
283 event = (ANDROID_EVENT_KEY*)calloc(1, sizeof(ANDROID_EVENT_KEY));
284
285 if (!event)
286 return nullptr;
287
288 event->type = EVENT_TYPE_KEY_UNICODE;
289 event->flags = flags;
290 event->scancode = key;
291 return event;
292}
293
294static void android_event_unicodekey_free(ANDROID_EVENT_KEY* event)
295{
296 free(event);
297}
298
299ANDROID_EVENT_KEY_AS_UNICODE* android_event_key_as_unicode_new(UINT16 flags, UINT32 scancode,
300 const WCHAR* wstr, size_t wlen,
301 UINT32 modmask)
302{
305
306 if (!event)
307 return nullptr;
308
309 event->type = EVENT_TYPE_KEY_AS_UNICODE;
310 event->flags = flags;
311 event->scancode = scancode;
312 event->modmask = modmask;
313
314 /* One character, at most a surrogate pair, fits str. Anything else leaves it empty, which
315 * tells freerdp_client_send_key_as_unicode to send the scancode. */
316 if (wstr && (wlen > 0) && (wlen <= 2) &&
317 (ConvertWCharNToUtf8(wstr, wlen, event->str, ARRAYSIZE(event->str)) < 0))
318 memset(event->str, 0, sizeof(event->str));
319 return event;
320}
321
322static void android_event_key_as_unicode_free(ANDROID_EVENT_KEY_AS_UNICODE* event)
323{
324 free(event);
325}
326
327ANDROID_EVENT_CURSOR* android_event_cursor_new(UINT16 flags, UINT16 x, UINT16 y)
328{
330 event = (ANDROID_EVENT_CURSOR*)calloc(1, sizeof(ANDROID_EVENT_CURSOR));
331
332 if (!event)
333 return nullptr;
334
335 event->type = EVENT_TYPE_CURSOR;
336 event->x = x;
337 event->y = y;
338 event->flags = flags;
339 return event;
340}
341
342static void android_event_cursor_free(ANDROID_EVENT_CURSOR* event)
343{
344 free(event);
345}
346
347ANDROID_EVENT* android_event_disconnect_new(void)
348{
349 ANDROID_EVENT* event;
350 event = (ANDROID_EVENT*)calloc(1, sizeof(ANDROID_EVENT));
351
352 if (!event)
353 return nullptr;
354
355 event->type = EVENT_TYPE_DISCONNECT;
356 return event;
357}
358
359static void android_event_disconnect_free(ANDROID_EVENT* event)
360{
361 free(event);
362}
363
364ANDROID_EVENT_CLIPBOARD* android_event_clipboard_new(const void* data, size_t data_length,
365 const char* mimeType)
366{
368 event = (ANDROID_EVENT_CLIPBOARD*)calloc(1, sizeof(ANDROID_EVENT_CLIPBOARD));
369
370 if (!event)
371 return nullptr;
372
373 event->type = EVENT_TYPE_CLIPBOARD;
374 event->mimeType = mimeType ? _strdup(mimeType) : nullptr;
375
376 if (mimeType && !event->mimeType)
377 {
378 free(event);
379 return nullptr;
380 }
381
382 if (data && data_length > 0)
383 {
384 const BOOL isText = !mimeType || strcmp(mimeType, "text/plain;charset=utf-8") == 0;
385 /* Text data needs a null terminator; image data is stored as-is. */
386 event->data = isText ? calloc(data_length + 1, sizeof(char)) : malloc(data_length);
387
388 if (!event->data)
389 {
390 free(event->mimeType);
391 free(event);
392 return nullptr;
393 }
394
395 memcpy(event->data, data, data_length);
396 event->data_length = isText ? data_length + 1 : data_length;
397 }
398
399 return event;
400}
401
402static void android_event_clipboard_free(ANDROID_EVENT_CLIPBOARD* event)
403{
404 if (event)
405 {
406 free(event->data);
407 free(event->mimeType);
408 free(event);
409 }
410}
411
412BOOL android_event_queue_init(freerdp* inst)
413{
414 androidContext* aCtx = (androidContext*)inst->context;
415 ANDROID_EVENT_QUEUE* queue;
416 queue = (ANDROID_EVENT_QUEUE*)calloc(1, sizeof(ANDROID_EVENT_QUEUE));
417
418 if (!queue)
419 {
420 WLog_ERR(TAG, "android_event_queue_init: memory allocation failed");
421 return FALSE;
422 }
423
424 queue->size = 16;
425 queue->count = 0;
426 queue->isSet = CreateEventA(nullptr, TRUE, FALSE, nullptr);
427
428 if (!queue->isSet)
429 {
430 free(queue);
431 return FALSE;
432 }
433
434 queue->events = (ANDROID_EVENT**)calloc(queue->size, sizeof(ANDROID_EVENT*));
435
436 if (!queue->events)
437 {
438 WLog_ERR(TAG, "android_event_queue_init: memory allocation failed");
439 if (!CloseHandle(queue->isSet))
440 WLog_WARN(TAG, "CloseHandle failed");
441 free(queue);
442 return FALSE;
443 }
444
445 if (!InitializeCriticalSectionAndSpinCount(&queue->lock, 4000))
446 {
447 WLog_ERR(TAG, "android_event_queue_init: failed to initialize lock");
448 free((void*)queue->events);
449 if (!CloseHandle(queue->isSet))
450 WLog_WARN(TAG, "CloseHandle failed");
451 free(queue);
452 return FALSE;
453 }
454
455 aCtx->event_queue = queue;
456 return TRUE;
457}
458
459void android_event_queue_uninit(freerdp* inst)
460{
461 androidContext* aCtx;
462 ANDROID_EVENT_QUEUE* queue;
463
464 if (!inst || !inst->context)
465 return;
466
467 aCtx = (androidContext*)inst->context;
468 queue = aCtx->event_queue;
469
470 if (queue)
471 {
472 aCtx->event_queue = nullptr;
473
474 if (queue->isSet)
475 {
476 if (!CloseHandle(queue->isSet))
477 WLog_WARN(TAG, "CloseHandle failed");
478 queue->isSet = nullptr;
479 }
480
481 if (queue->events)
482 {
483 for (size_t i = 0; i < queue->count; i++)
484 android_event_free(queue->events[i]);
485 free((void*)queue->events);
486 queue->events = nullptr;
487 queue->size = 0;
488 queue->count = 0;
489 }
490
491 DeleteCriticalSection(&queue->lock);
492 free(queue);
493 }
494}
495
496void android_event_free(ANDROID_EVENT* event)
497{
498 if (!event)
499 return;
500
501 switch (event->type)
502 {
503 case EVENT_TYPE_KEY:
504 android_event_key_free((ANDROID_EVENT_KEY*)event);
505 break;
506
507 case EVENT_TYPE_KEY_UNICODE:
508 android_event_unicodekey_free((ANDROID_EVENT_KEY*)event);
509 break;
510
511 case EVENT_TYPE_KEY_AS_UNICODE:
512 android_event_key_as_unicode_free((ANDROID_EVENT_KEY_AS_UNICODE*)event);
513 break;
514
515 case EVENT_TYPE_CURSOR:
516 android_event_cursor_free((ANDROID_EVENT_CURSOR*)event);
517 break;
518
519 case EVENT_TYPE_DISCONNECT:
520 android_event_disconnect_free((ANDROID_EVENT*)event);
521 break;
522
523 case EVENT_TYPE_CLIPBOARD:
524 android_event_clipboard_free((ANDROID_EVENT_CLIPBOARD*)event);
525 break;
526
527 default:
528 break;
529 }
530}