Application State Continuity Across Devices

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current application systems do not maintain a continuous state across multiple devices, requiring users to manually navigate and re-establish application states when switching between devices, which is disruptive and inefficient.

Innovation Solution

Implementing a method and apparatus that stores and shares the application state across devices, allowing seamless transitions by serializing and storing the current application state in a database, enabling automatic or manual restoration when switching devices or restarting, using a model-view-controller architecture and mechanisms like Savepoint for state management.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If application state is stored separately on each device, then device independence is maintained, but application continuity across devices is lost

Engineering Contradiction:
Improveapplication continuityVSAvoidstate management complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent introduces a server as an intermediary component that stores application state data centrally. When users switch between devices, the server mediates the state transfer by providing the saved state to the new device, enabling seamless continuity without direct device-to-device communication.

Inventive Principle:
Principle #24Intermediary (Mediator)

Solution Approach 2:

The system creates copies of the application state data and stores them on the server. When a user switches devices, the state is copied from the server to the new device, allowing the user to resume the application exactly where they left off without manually re-navigating.

Inventive Principle:
Principle #26Copying

2Productivity

If manual re-navigation is required when switching devices, then data storage simplicity is maintained, but user productivity decreases

Engineering Contradiction:
Improveuser efficiencyVSAvoidtime to re-establish state
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The system performs preliminary actions by automatically saving the application state to the server in the background before the user switches devices. This preliminary state capture eliminates the need for users to manually re-navigate, as the state is already prepared and waiting on the server for when they return.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The application automatically manages its own state by saving and restoring it without requiring user intervention. The system self-services the state transfer process between devices, eliminating manual re-navigation steps and improving user productivity.

Inventive Principle:
Principle #25Self-service

3Ease of operation

If application state is synchronized across devices, then seamless transitions are enabled, but system resource consumption increases

Engineering Contradiction:
Improvedevice switching easeVSAvoidenergy for state synchronization
Core Design Contradiction:
Ease of operationVSUse of energy by moving object

Solution Approach 1:

Instead of continuous synchronization, the system uses periodic action by saving the application state at specific intervals or trigger points (such as when the user actually switches devices). This reduces unnecessary energy consumption while still maintaining ease of operation when needed.

Inventive Principle:
Principle #19Periodic action

Data Source

PatentUS9634882B2Method and system for continuous application state
Publication Date: 2017.04.25 ORACLE INT CORP
  • US9634882B2 patent drawing
  • US9634882B2 patent drawing
  • US9634882B2 patent drawing

AI summary

Disclosed are methods and apparatuses to share application state across devices. This approach allows the user to switch devices and have the application on the new device share the same state as the previous device. In addition, this approach allows the user to shut down a device at a first point in time, and later be presented with the same state for the application at a second point in time on the same device when it is turned back on.