Decoupled UI Thread Input Processing via Event Queue
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing user interface technologies face challenges in efficiently rendering graphical user interfaces as videos and decoupling input events from their corresponding outputs, leading to responsiveness issues and inefficiencies in processing user interactions.
Innovation Solution
The implementation of a multi-layered-tree representation for graphical user interfaces, where each frame of the video corresponds to transformations, additions, or removals of layers, and the use of de-coupled computing threads to process input events independently, allowing for continuous reception and processing of subsequent inputs even if the primary thread is non-responsive.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a single computing thread processes both input event reception and output generation, then the processing flow is simple, but the system becomes non-responsive when the output generation is delayed
Solution Approach 1:
The patent divides the monolithic processing thread into two separate computing threads: a first computing thread dedicated to receiving input events and a second computing thread dedicated to generating outputs. This segmentation allows each thread to operate independently, preventing bottlenecks where one thread's delays block the other, thereby maintaining system responsiveness while keeping the overall architecture manageable.
Solution Approach 2:
The patent introduces an event queue as an intermediary data structure between the first computing thread (input reception) and the second computing thread (output generation). The event queue buffers input events, allowing the first thread to continue receiving inputs without waiting for the second thread to process them, thus decoupling the two operations and preventing responsiveness issues.
2Loss of time
If the system waits for the second thread to process each input event before accepting the next, then processing order is maintained, but input processing speed decreases
Solution Approach 1:
The patent enables continuous input processing by allowing the first computing thread to operate continuously without being blocked by the second thread's processing speed. Input events are queued for later processing, ensuring that the useful action of receiving user inputs never stops, thereby maximizing input processing speed while maintaining proper event handling sequence through the queue structure.
3Reliability
If multiple threads process input events independently, then system responsiveness is maintained, but coordinating thread communication becomes complex
Solution Approach 1:
The event queue serves as a simple intermediary mechanism that enables independent thread operation without complex coordination protocols. Threads communicate through the queue's standard operations (enqueue and dequeue), avoiding the need for complex inter-thread signaling, locking mechanisms, or synchronization primitives, thus maintaining responsiveness while keeping coordination complexity low.
Data Source
AI summary
In one embodiment, a first thread of execution on a computing device receives a user-interface input. The first thread of execution is associated with a user interface of the computing device. The first thread of execution identifies a second thread of execution on the computing device to process the user-interface input. The second thread of execution is associated with the user interface and is de-coupled from the first thread of execution. The first thread of execution sends the user-interface input to the second thread of execution. The second thread of execution also processes the user-interface input to generate a user-interface output associated with the user-interface input.