Persistent Web Plug-in State Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Web plug-ins are only page persistent, leading to loss of complex multimedia applications when users navigate away and return, resulting in a diminished user experience due to re-initialization and computational overhead.
Innovation Solution
Implementing persistent plug-ins that preserve the content state in memory, allowing plug-in instances to remain loaded and resume seamlessly without re-initialization when users return to the original page, using a persistence indicator and dormancy management to store and retrieve the state.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If plug-ins are made page persistent to enable navigation between pages, then user can access different web pages, but plug-in content is lost and re-initialization is required when returning to a page
Solution Approach 1:
The plug-in saves its current state to shared memory before the user navigates away, and restores this state when the user returns to the page. This preliminary state preservation action eliminates the need for re-initialization and maintains the plug-in content across page navigations.
2Quantity of substance
If plug-ins are closed when user navigates to another page to free resources, then memory and computational resources are freed, but plug-in state is lost and must be re-initialized
Solution Approach 1:
The plug-in creates a copy of its state in shared memory before closing. When the user returns to the page, this state copy is restored to the plug-in instance, allowing the plug-in to resume operation with its content intact without requiring re-initialization.
Solution Approach 2:
The plug-in performs the state-saving action before closing when the user navigates away, ensuring that the state information is preserved in shared memory. This preliminary action allows the plug-in to be quickly restored to its previous state when the user returns, minimizing resource consumption while preserving information.
3Reliability
If state-saving code is added to applications to preserve plug-in state, then plug-in state can be maintained across navigations, but implementation burden is placed on application developers
Solution Approach 1:
The plug-in automatically saves its own state to shared memory and manages its own restoration when the user returns to a page. This self-service mechanism eliminates the need for developers to implement custom state-saving code, reducing implementation complexity while maintaining state persistence.
Solution Approach 2:
The state-saving mechanism is implemented at the plug-in level rather than the application level, making it universally applicable to all plug-ins. This multi-functional approach allows any plug-in to benefit from state persistence without requiring application-specific implementation, thereby reducing overall system complexity.
Data Source
AI summary
Persistent plug-ins are described in a web browser. The browser displays various plug-in instances on a current page, where a plug-in instance is made up of a plug-in player running within the current page and playing content viewable by the user. When a page is changed, a command is issued to close the current page with all of its plug-in instances. If there is a persistence indicator associated with a plug-in instance, the current content state is preserved in memory. If the user desires to return to the original web page or any other page that references the persistent plug-in instance, the plug-in player searches the memory for the current content state and plays the content to return the display of the plug-in instance at the same content state as when the user last left the plug-in instance.