CN114510170A

CN114510170A - Component display method and display device

Info

Publication number: CN114510170A
Application number: CN202210066285.3A
Authority: CN
Inventors: 刘群山; 杨绍栋; 高斯太
Original assignee: Juhaokan Technology Co Ltd
Current assignee: Juhaokan Technology Co Ltd
Priority date: 2021-03-04
Filing date: 2022-01-20
Publication date: 2022-05-17
Anticipated expiration: 2042-01-20
Also published as: CN115022695B; CN115037970B; CN114510170B; CN115037970A; CN115037971B; CN115022695A; WO2022237603A1; CN115037971A; CN117043733A

Abstract

The application discloses a component display method and display equipment, wherein when a desktop application is started, a desktop homepage is displayed based on business data of each business module. When the component interface is displayed in the desktop homepage, the service component management module is called to acquire the component information of the service module corresponding to each service ID from the component management module and send the component information to the component display module, the component display module is called to generate the component interface based on the component data and the component interface information corresponding to each service ID, the component interface is displayed in the desktop homepage, and a plurality of widgets used for providing starting entrances of the service modules are displayed in the component interface. Therefore, when the method and the display device display the components based on the desktop component framework, the method and the display device are not limited by a system, the component information is split into the component data and the component interface information, the layout, the style and the like of each Widget displayed in the component interface can be edited in a user-defined mode, and the component interfaces with various effects are provided for users.

Description

Component display method and display device

This application claims priority to chinese patent application No. 202110264767.5, filed on 3/4/2021, the entire contents of which are incorporated herein by reference.

Technical Field

The present application relates to the field of communications technologies, and in particular, to a component display method and a display device.

Background

Display devices, such as smart televisions, may provide a user with a picture to play, such as audio, video, pictures, etc. The desktop application is configured in the display device to implement different functions based on services provided by the desktop application. In order to facilitate the user to start a certain function, different components can be generated and displayed in the desktop homepage based on different functions.

In the existing android native desktop component framework, the android system installed by display equipment can only be used for a plurality of native components provided by the system, so that the desktop component is difficult to expand or customize, and the display effect is relatively crude.

Disclosure of Invention

The application provides a component display method and display equipment, which are used for solving the problem that the traditional desktop component is poor in display effect.

In a first aspect, the present application provides a display device comprising: a display configured to present a user interface; a controller connected with the display, the controller configured to:

receiving a starting operation of a desktop application, acquiring service data of each service module provided by the desktop application, and displaying a desktop homepage in the user interface based on the service data of each service module;

when a component interface is displayed, calling a service component management module to acquire component information of a service module corresponding to each service ID from the component management module and sending the component information to the component display module, wherein the component information refers to information generated when a service module provided by desktop application registers Widget, the component information comprises component data and component interface information, the component data refers to data which needs to be displayed on the component interface by the service module represented by the service ID, and the component interface information refers to interface layout information displayed by the Widget;

and calling the component display module to generate a component interface based on the component data and the component interface information corresponding to each service ID, and displaying the component interface in a desktop homepage, wherein a plurality of widgets used for providing starting entrances of each service module are displayed in the component interface.

In a second aspect, the present application further provides a method for displaying a component, the method comprising:

In a third aspect, the present application further provides a storage medium, which may store a program, and when the program is executed, the program may implement some or all of the steps in the embodiments of the component display method provided in the present application.

According to the technical scheme, when the desktop application is started, the desktop homepage is displayed based on the service data of each service module. When the component interface is displayed in the desktop homepage, the service component management module is called to acquire the component information of the service module corresponding to each service ID from the component management module and send the component information to the component display module, the component display module is called to generate the component interface based on the component data and the component interface information corresponding to each service ID, the component interface is displayed in the desktop homepage, and a plurality of widgets used for providing starting entrances of the service modules are displayed in the component interface. Therefore, when the method and the display device display the components based on the desktop component framework, the method and the display device are not limited by a system, the component information is split into the component data and the component interface information, the layout, the style and the like of each Widget displayed in the component interface can be edited in a user-defined mode, and the component interfaces with various effects are provided for users.

Drawings

In order to more clearly explain the technical solution of the present application, the drawings needed to be used in the embodiments will be briefly described below, and it is obvious to those skilled in the art that other drawings can be obtained according to the drawings without any creative effort.

FIG. 1 illustrates a schematic diagram of an operational scenario between a smart control device and a control apparatus, in accordance with some embodiments;

fig. 2 illustrates a hardware configuration block diagram of an intelligent control device 200 according to some embodiments;

fig. 3 shows a block diagram of a hardware configuration of the control apparatus 100 according to some embodiments;

FIG. 4 illustrates a software configuration diagram in the intelligent control device 200 according to some embodiments;

FIG. 5 illustrates an architecture diagram of a desktop component frame according to some embodiments;

FIG. 6 illustrates a flow diagram of a component presentation method according to some embodiments;

FIG. 7 illustrates a schematic diagram of a system home page, according to some embodiments;

FIG. 8 illustrates a schematic diagram of a desktop home page, according to some embodiments;

FIG. 9 illustrates a schematic diagram of a component interface, according to some embodiments;

FIG. 10 illustrates a schematic diagram of player Widget data refresh in a component interface, in accordance with some embodiments;

FIG. 11 illustrates a diagram showing invalidation identification on a Widget, in accordance with some embodiments;

FIG. 12 illustrates a schematic diagram of a failure prompt interface, according to some embodiments;

FIG. 13 illustrates a schematic diagram of adding pages, in accordance with some embodiments;

FIG. 14 illustrates another schematic diagram of adding a page in accordance with some embodiments;

FIG. 15 illustrates a schematic diagram of a service menu, according to some embodiments;

FIG. 16 illustrates another schematic diagram of a service menu, according to some embodiments.

Detailed Description

To make the purpose and embodiments of the present application clearer, the following will clearly and completely describe the exemplary embodiments of the present application with reference to the attached drawings in the exemplary embodiments of the present application, and it is obvious that the described exemplary embodiments are only a part of the embodiments of the present application, and not all of the embodiments.

It should be noted that the brief descriptions of the terms in the present application are only for the convenience of understanding the embodiments described below, and are not intended to limit the embodiments of the present application. These terms should be understood in their ordinary and customary meaning unless otherwise indicated.

The terms "first," "second," "third," and the like in the description and claims of this application and in the above-described drawings are used for distinguishing between similar or analogous objects or entities and not necessarily for describing a particular sequential or chronological order, unless otherwise indicated. It is to be understood that the terms so used are interchangeable under appropriate circumstances.

The terms "comprises" and "comprising," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a product or apparatus that comprises a list of elements is not necessarily limited to all elements expressly listed, but may include other elements not expressly listed or inherent to such product or apparatus.

The term "module" refers to any known or later developed hardware, software, firmware, artificial intelligence, fuzzy logic, or combination of hardware and/or software code that is capable of performing the functionality associated with that element.

When the intelligent control device is a display device, introduction is performed based on the structure of the display device.

FIG. 1 illustrates a usage scenario of a smart control device according to some embodiments. As shown in fig. 1, the intelligent control apparatus 200 is also in data communication with a server 400, and a user can operate the intelligent control apparatus 200 through the intelligent apparatus 300 or the control device 100.

In some embodiments, the control apparatus 100 may be a remote controller, and the communication between the remote controller and the intelligent control device includes at least one of an infrared protocol communication or a bluetooth protocol communication, and other short-distance communication methods, and the intelligent control device 200 is controlled by a wireless or wired method. The user may input a user command through at least one of a button on a remote controller, a voice input, a control panel input, etc. to control the intelligent control device 200.

In some embodiments, the smart device 300 may include any of a mobile terminal, a tablet, a computer, a laptop, an AR/VR device, and the like.

In some embodiments, the smart device 300 may also be used to control the smart control device 200. For example, the smart control device 200 is controlled using an application program running on the smart device. In some embodiments, the smart device 300 and the smart control device may also be used for communication of data.

In some embodiments, the intelligent control device 200 may also be controlled in a manner other than the control apparatus 100 and the intelligent device 300, for example, the voice instruction control of the user may be directly received by a module configured inside the intelligent control device 200 to obtain the voice instruction, or may be received by a voice control apparatus provided outside the intelligent control device 200.

In some embodiments, the smart control device 200 is also in data communication with the server 400. The intelligent control device 200 may be allowed to make communication connections through a Local Area Network (LAN), a Wireless Local Area Network (WLAN), and other networks. The server 400 may provide various contents and interactions to the smart control device 200. The server 400 may be a cluster or a plurality of clusters, and may include one or more types of servers.

In some embodiments, software steps executed by one step execution agent may be migrated on demand to another step execution agent in data communication therewith for execution. Illustratively, the software steps executed by the server may be migrated to be executed on the intelligent control device in data communication therewith, and vice versa, as needed.

Fig. 2 illustrates a block diagram of a hardware configuration of the control apparatus 100 according to some embodiments. As shown in fig. 2, the control device 100 includes a controller 110, a communication interface 130, a user input/output interface 140, a memory, and a power supply. The control apparatus 100 may receive an input operation instruction from a user and convert the operation instruction into an instruction recognizable and responsive by the smart control device 200, serving as an interaction intermediary between the user and the smart control device 200.

In some embodiments, the communication interface 130 is used for external communication, and includes at least one of a WIFI chip, a bluetooth module, NFC, or an alternative module. In some embodiments, the user input/output interface 140 includes at least one of a microphone, a touchpad, a sensor, a key, or an alternative module.

Fig. 3 illustrates a hardware configuration block diagram of the intelligent control device 200 according to some embodiments. Referring to fig. 3, in some embodiments, the intelligent control apparatus 200 includes at least one of a tuning demodulator 210, a communicator 220, a detector 230, an external device interface 240, a controller 250, a display 260, an audio output interface 270, a memory, a power supply, a user interface. In some embodiments, the controller includes a central processor, a video processor, an audio processor, a graphic processor, a RAM, a ROM, a first interface to an nth interface for input/output.

In some embodiments, the display 260 includes a display screen component for displaying pictures, and a driving component for driving image display, a component for receiving image signals from the controller output, displaying video content, image content, and menu manipulation interface, and a user manipulation UI interface, etc. In some embodiments, the display 260 may be at least one of a liquid crystal display, an OLED display, and a projection display, and may also be a projection device and a projection screen.

In some embodiments, the controller 250 and the modem 210 may be located in different separate devices, that is, the modem 210 may also be located in an external device of the main device where the controller 250 is located, such as an external set-top box. In some embodiments, controller 250 controls the operation of the intelligent control device and responds to user actions through various software control programs stored in memory. The controller 250 controls the overall operation of the intelligent control device 200. For example: in response to receiving a user command for selecting a UI object to be displayed on the display 260, the controller 250 may perform an operation related to the object selected by the user command.

In some embodiments, the object may be any one of selectable objects, such as a hyperlink, an icon, or other actionable control. The operations related to the selected object are: displaying an operation connected to a hyperlink page, document, image, or the like, or performing an operation of a program corresponding to the icon.

In some embodiments the controller comprises at least one of a Central Processing Unit (CPU), a video processor, an audio processor, a Graphics Processing Unit (GPU), a RAM Random Access Memory (RAM), a ROM (Read-Only Memory), a first to nth interface for input/output, a communication Bus (Bus), and the like.

In some embodiments, a user may enter user commands on a Graphical User Interface (GUI) displayed on display 260, and the user input interface receives the user input commands through the Graphical User Interface (GUI). Alternatively, the user may input the user command by inputting a specific sound or gesture, and the user input interface receives the user input command by recognizing the sound or gesture through the sensor.

In some embodiments, a "user interface" is a media interface for interaction and information exchange between an application or operating system and a user that enables conversion between an internal form of information and a form that is acceptable to the user. A commonly used presentation form of the User Interface is a Graphical User Interface (GUI), which refers to a User Interface related to computer operations and displayed in a graphical manner. It may be an interface element such as an icon, a window, a control, etc. displayed in the display screen of the electronic device, where the control may include at least one of an icon, a button, a menu, a tab, a text box, a dialog box, a status bar, a navigation bar, a Widget, etc. visual interface elements. In some embodiments, the user interface 280 is an interface that can be used to receive control inputs (e.g., physical buttons on the body of the smart control device, or the like).

Fig. 4 illustrates a software configuration diagram in the intelligent control device 200 according to some embodiments. Referring to fig. 4, in some embodiments, the system is divided into four layers, which are an Application (Applications) layer (abbreviated as "Application layer"), an Application Framework (Application Framework) layer (abbreviated as "Framework layer"), an Android runtime (Android runtime) and system library layer (abbreviated as "system runtime library layer"), and a kernel layer from top to bottom.

In some embodiments, at least one application program runs in the application program layer, and the application programs may be windows (windows) programs carried by an operating system, system setting programs, clock programs or the like; or an application developed by a third party developer. In particular implementations, the application packages in the application layer are not limited to the above examples.

The framework layer provides an Application Programming Interface (API) and a programming framework for the application. The application framework layer includes a number of predefined functions. The application framework layer acts as a processing center that decides to let the applications in the application layer act. The application program can access the resources in the system and obtain the services of the system in execution through the API interface.

As shown in fig. 4, in some embodiments of the present application, the application framework layer includes a manager (Managers), a Provider (Content Provider), a network management system, and the like, where the manager includes at least one of the following modules: an Activity Manager (Activity Manager) is used for interacting with all activities running in the system; the Location Manager (Location Manager) is used for providing the system service or application with the access of the system Location service; a Package Manager (Package Manager) for retrieving various information related to an application Package currently installed on the device; a Notification Manager (Notification Manager) for controlling display and clearing of Notification messages; a Window Manager (Window Manager) is used to manage icons, windows, toolbars, wallpapers, and desktop components on a user interface.

In some embodiments, to enhance the user experience of the display device, applications that implement different functionality may be configured in the display device. Some applications may implement one function based on the application itself, while other applications may provide multiple services, with different services implementing different functions, i.e., such applications may implement multiple functions. For example, a desktop application is configured in the display device, and the desktop application provides a plurality of service modules to implement different functions based on the service modules provided by the desktop application. In order to facilitate the user to start a certain function, different components can be generated and displayed in the desktop homepage based on different functions.

In some embodiments, since there are many service modules in the preset operating system application configured in the display device, in order to facilitate a user to quickly start a specific service module, a shortcut of a service commonly used by the user may be generated in the form of a Widget, and the Widget is used to provide a shortcut entry for the corresponding service module. Each Widget is displayed in the component interface, that is, a user can register a commonly used function in a data center (Widget service) to add the function to the component interface, and a quick start entrance is provided for the function under the application of the preset operating system through the Widget.

In some embodiments, the display device is installed with an android system, and then when the component interface is shown in the desktop homepage, the current display device is usually implemented by adopting an android native desktop component framework, that is, the system component service widget services works at the system framework level. Each component provider application provides a provider, and the data of the component provider is exposed to the desktop application through the provider. The system component service Widgetservice automatically collects provider information of all component providers after the system is started. And the desktop application uses the Widget host to communicate with the system component service Widget service, obtains provider information of each component application, obtains component data through the provider, and adds a button or updates the displayed component. The component provider application comprises a business module provided by a third party application and a desktop application.

The component data includes information such as an Identifier (ID) of the interface component and an operation (Action) of the interface component. The ID can be customized at the provider end; but the Action can only use less than 20 fixed types, such as setting the size of characters, the color of the characters, background pictures, clicking and monitoring, and the like. That is to say, the operation update of all component interfaces is limited to less than 20 actions, and is difficult to expand and realize complex interface effects.

An interface layout file for the component is derived from the component provider application. In the desktop application, in order to be able to access the resource file in the component provider application, a context of the application needs to be created, and resource consumption is relatively high. In addition, the layout file of the components cannot have self-defined components, otherwise, the components cannot be identified in the desktop application. Therefore, the user-defined interface components cannot be used in the component layout file, and the complex interface effect is difficult to realize.

Therefore, the desktop assembly realized by the display device based on the android system is limited by the android system, and only a few native assemblies provided by the system can be used, so that the desktop assembly is difficult to expand or customize, and the display effect is relatively crude.

Therefore, in order to enable the display device to be independent of an android system when presenting a component interface, the application provides a brand-new desktop component framework, and any component (Widget) can be used based on the desktop component framework, and the component can be sourced from the inside of the application or from other applications. The component data sources can also be flexibly customized, and can originate from inside the application or from other applications. The desktop component framework can be used for self-defining editing of the size, layout, style (square, circular and the like) and the like of each Widget presented in the component interface, multi-level Widget menu display and Widget classification can be performed, components under a certain classification can be longitudinally added, various attributes of the components are modified and the like, and the component interface with various effects is provided for a user.

In some embodiments, a desktop component framework may be run within the application layer of FIG. 4 in order to enable a desktop homepage to be presented in the display device upon booting the display device to expose system-configured applications or installed business modules. A desktop application (JUUI application) is configured in the display device, the desktop application is an application of an application layer, and the desktop application is composed of a desktop component framework and used for presenting a desktop homepage when the display device is started.

FIG. 5 illustrates an architectural diagram of a desktop component frame according to some embodiments. Referring to fig. 5, the desktop component architecture includes a business component management module (widget manager), a component exposure module (widget container), and a HostView, a data center module (widget service), and a component management module (widget server).

The service component management module (Widget manager) is divided according to the service modules and is provided with service Identification (ID), one service component management module corresponds to one service module, and the service module management module manages and maintains the components related to the service modules. And initiating a request to a remote service module, receiving data of a data center module (Widget service), and distributing the data to different components according to the service ID. The service component management module (Widget manager) is used for managing component information, and the component information is used for recording basic information of the components, such as ID, length, width, clicking, expanding, refreshing interval and the like; the component data and the component interface information are not limited at all and can be flexibly expanded.

Component presentation Module (WidgetContainer) and HostView: and the system is responsible for adding, deleting, moving, displaying information and the like of the components. A remote service module: the remote end relative to the desktop component module can be other business modules in the desktop application or other applications. The component data is provided by the remote service module and is transmitted to the interior of the service component management module through the data center module Widgetservice. In fig. 5, service module a and application B are remote service modules.

The service module A is a service module provided by the desktop application, and the application B is an external application and is not a service application provided by the desktop application. The application B refers to a remote application installed in a software system of the display device and exposable in a desktop homepage, such as a third party application or a system preset application. And during display, the application management module in the software system acquires the installation information of the application from the system and displays the application on the desktop homepage based on the installation information. If the application also provides Widget display, the application management module registers the information of the application to Widget service, and the Widget service realizes that the Widget component corresponding to the application is displayed in a Widget panel.

The data center module (Widget service) is equivalent to the system component service and is used for butting the service component management module and the remote service module, the data sent by the remote service module is sent to the Widget service, and the Widget service is distributed to different service component management modules after primary processing is finished. The component management module (Widget Server) is used for caching the component information and the component data.

In some embodiments, in order to ensure that information such as size, layout, style and the like of each Widget displayed in a component interface is not limited by a system, a desktop component framework splits each component information for presenting the Widget, wherein the component information includes component data and component interface information, and the component data refers to data required to be displayed on the component interface by a service module represented by a service ID, such as information such as ID, click operation, expansion, refresh interval, display content and the like of the Widget; the component interface information refers to interface layout information displayed by the component, such as the length, width and other size information of the Widget.

Splitting the component data and the component interface information: the component data uses character string formats such as json and xml with good compatibility, and the data transmission is flexible and has little limit; the component interface information can be stored in the desktop application terminal or other application terminals. If the component interface information is stored in other applications, the desktop application may use a cross-process loading technique, such as a plug-in loading approach. When the cross-process loading technology is used, the final component interface information is loaded and run in the desktop application. The interface layout of the components is always loaded in the desktop application, and resources, controls and the like in the desktop application can be used at will without system limitation. On the basis, more service forms can be derived, such as a self-defined menu of components, a multi-service combination component and the like.

When the desktop component framework realizes the component interface, the information such as the size, the layout and the style of the Widget is not concerned, and the information such as the size, the layout and the style of the Widget can be customized. Because the sizes of the widgets can be different, the combined installation of the widgets in the component interface is not limited by the desktop component framework, but can be customized, and only the display of the component interface is needed.

In some embodiments, the desktop component framework manages widgets (components) according to the business modules, and one business module generates one Widget. The component data and component interface information display correspond one-to-one: the components of different service modules and the components of different service modules are not influenced, so that the independence and the cohesion of the service and the components are ensured. According to the development of the service module, more service modules can be transversely expanded, and more components can be expanded under the existing service module.

In some embodiments, the data channel of the desktop component framework is implemented flexibly: when a request is initiated to a remote service, the remote service inside the desktop application can be directly called through an interface, and the remote services in other applications can send IPC requests (socket, IPC, file, etc.). The return data of the remote service can be realized in various ways.

In some embodiments, the desktop component framework may conveniently implement dynamic components: the remote service can actively inform the desktop application according to the service requirement, and add and delete some components. Such as: and the contact application terminal adds/deletes one contact, and can actively inform the desktop application to add/delete one contact component. For another example: the application management component can actively inform the desktop application when the application is installed or uninstalled, and one application component is added or deleted.

In some embodiments, the desktop component framework can flexibly control component loading opportunities: for example, when the system is just started and the desktop application is just started, system resources are tense, and the registration of the components can be simply processed and suspended, so that the contention of the system resources is reduced, and the operation jam of the main function is avoided.

In some embodiments, the desktop application is an application installed in the application layer, and application B is also an application installed in the application layer.

In some embodiments, the desktop homepage is presented in the display device when the desktop application is launched. A plurality of service modules provided by a preset operating system, such as a signal source, a networking state, a juvenile service module, an education service module, a fitness service module and the like, are displayed in the desktop homepage. The user can register any service module which is commonly used in a data center module (Widget service) and add the service module into a component interface in a Widget form, so that the quick start is realized. The service module belongs to the service in the desktop application, and in the process of displaying any service module, a user can call out a component interface through preset operation to be displayed in a desktop homepage.

In some embodiments, information of the signal source, networking status, etc. of the service module is obtained from other applications outside the desktop application.

In some embodiments, no response component interface callouts are made during the presentation of applications other than desktop applications. Applications outside the desktop application include the far-end application that the user installed, third party application such as kiwi fruit, the Romeow, when showing the far-end application in display device's user interface, the user triggers and predetermines the operation, and the subassembly interface that can not tune out shows in the desktop homepage.

In some embodiments, the desktop homepage may be provided by a native system application or may be provided by a pre-set operating system application. In some embodiments, the desktop application may be a pre-set operating system application.

FIG. 6 illustrates a flow diagram of a component presentation method according to some embodiments. An embodiment of the present invention provides a display device, including: a display configured to present a user interface; a controller coupled to the display, the controller configured to perform the following steps when performing the component exhibition method shown in fig. 6:

s1, receiving the starting operation of the desktop application, acquiring the service data of each service module provided by the desktop application, and displaying the desktop homepage in the user interface based on the service data of each service module.

FIG. 7 illustrates a schematic diagram of a system home page, according to some embodiments; FIG. 8 illustrates a schematic diagram of a desktop home page, according to some embodiments. Referring to fig. 7, the user activates the display device, which presents a system homepage in which a desktop application (JUUI application) control icon is presented. Referring to fig. 8, the desktop application control icon is triggered, and a starting operation of the desktop application is executed to present a desktop homepage in the display device.

When the desktop homepage is displayed, the service data of each service module provided by the desktop application is acquired, the service data is used for realizing the function of the service module, the service data comprises a service ID, and the service ID is used for representing the service module. And displaying a desktop homepage in the user interface according to the service data of each service module and a preset homepage layout mode, wherein the functional contents of each service module are displayed in the desktop homepage.

In some embodiments, each service module provided by the JUUI application is displayed in the desktop homepage, and each service module can be added to the component interface in the form of Widget based on the user-defined setting so as to provide a quick entry for the service module.

The component interface is displayed in a desktop homepage, and the component interface can be synchronously displayed while the desktop homepage is displayed in a user interface of the display device when the desktop application is started; or when the desktop application is started, the desktop homepage is preferentially displayed in the user interface of the display device, and when the preset operation is generated based on the desktop homepage, the component interface is called out and displayed in the desktop homepage.

In some embodiments, the component interface is usually hidden and displayed when the display device runs, and when a user needs to quickly start a certain function (for example, a function realized by a certain service module) through the component interface, the component interface can be called out and displayed in a desktop homepage based on a preset operation, where the preset operation is that the user presses a left key of a remote controller or other preset function keys for a long time. If the user wants to start a certain function, the corresponding Widget is triggered in the component interface to directly start the function, namely, a certain service module provided by the desktop application is started.

In some embodiments, a user may register a corresponding Widget for a certain service module at the same time when starting a desktop application. At this time, when the desktop application is started, the widgets manager of all the service modules is collected, the component information registration related to the service modules is triggered, and the registration is stored in the widgets server.

Specifically, when registering the Widget for the service module, the controller is further configured to perform the following steps:

step 101, when registering a Widget for a service module, acquiring service data of each remote service module, where the remote service module includes a service module provided by a desktop application or a third-party application.

And 102, sending the service data of each remote service module to a data center module, wherein the data center module is used for processing the service data of each remote service module.

And 103, after the service data is processed, respectively configuring a service component management module for each remote service module based on the service ID of each remote service module.

Step 104, calling the target service component management module, registering the corresponding Widget for the target remote service module, and storing the component information generated by registering the Widget and the corresponding service ID into the component management module.

Referring again to the desktop component framework shown in fig. 5, when registering a Widget for a service module, service data of at least one remote service module for component display may be obtained. The remote service module comprises a service module provided by a desktop application (such as the service module A in FIG. 5) or a third-party application (such as the application B in FIG. 5).

When the desktop application is started, the data center module (Widgetservice) is synchronously pulled up to prepare for receiving the service data of the remote service module. Therefore, when the Widget registration based on the new service module exists, the data center module receives the service data of the remote service module.

After the data center module simply processes the service data of the remote service modules, a service component management module is respectively configured for each remote service module. One remote service module corresponds to one service ID, and thus, the corresponding service component management module (widget manager) can be represented by the service ID, and one service module corresponds to one service component management module.

In order to realize the registration of the Widget, the data center module sends the service data of the target remote service module to the corresponding target service component management module, so that the target service component management module registers the corresponding Widget for the target remote service module. For example, the service data of the service module a is sent to the service component management module a for component registration, and the service data of the service module B is sent to the service component management module B for component registration.

When the target service module management module registers the target service module, the module data and the module interface information can be synchronously generated to form the module information of the target service module. For example, the component information a of the business module a includes component data a and component interface information a, and the component information B of the business module B includes component data B and component interface information B.

After the target service component management module completes component registration of the target service module, component information of the target service module needs to be further stored, and a module for storing the component information is a component management module (widget server). Therefore, after the registration is completed, the target service component management module stores the component information generated by registering the Widget for the target service module and the corresponding service ID into the component management module (Widget server). And the component management module stores the component information of the corresponding service module according to the service ID so as to distinguish and call the component information of different service modules.

The method for registering the Widget for the service module can be applied to starting of desktop application and also can be applied to the running process of the desktop application, and the registration can be realized by adopting the method as long as the condition of registering the Widget for the service module exists.

S2, when the component interface is displayed, calling the service component management module to obtain the component information of the service module corresponding to each service ID from the component management module and sending the component information to the component display module, wherein the component information refers to the information generated by the service module provided by the desktop application when the Widget is registered, the component information includes component data and component interface information, the component data refers to the data required to be displayed on the component interface by the service module represented by the service ID, and the component interface information refers to the interface layout information displayed by the Widget.

Upon launching the desktop application, a desktop homepage is presented in a user interface of the display device. In the process of displaying the desktop homepage, the component interface can be synchronously displayed or called out based on preset operation to be displayed in the desktop homepage. Then, when the component interface needs to be displayed, based on the desktop component framework shown in fig. 5, the service component management module is called to obtain the component information of the service module corresponding to each service ID from the component management module, and the component information is sent to the component display module for displaying.

The component management module stores component information of all service modules capable of performing component display, so that the component information of all the service modules needs to be displayed when a component interface needs to be presented.

When the desktop application is started, if the component registration of a new service module is not carried out, the service component management modules corresponding to different service modules acquire the historically added component information from the component management modules. That is, based on each service ID added in history, the corresponding service component management module acquires the component information of the service module corresponding to the service ID from the component management module.

When the desktop application is started, if the component registration of the new service module is performed, the newly registered component information needs to be acquired from the component management module in addition to the component information added in the query history. That is, based on each newly registered service ID, the corresponding service component management module acquires the component information of the service module corresponding to the service ID from the component management module.

After the component information of all the service modules needing to be displayed is acquired, each service component management module sends the acquired component information of the service modules to the component display module, so that the component display module completes the display of the component interface based on the component information of each service module.

In some embodiments, when the user launches the desktop application, the component interface is displayed while the desktop home page is presented in the display device, the display of the component interface may postpone the display of the desktop home page because the generation of the desktop home page and the time at which the component interface generates the acquired data may differ. At this time, in order to ensure that the data can be displayed in the component interface and avoid causing the user to mistakenly display the interface and make mistakes, the default data display component interface can be used first. For example, default data includes default pictures and default text, and a component interface is generated based on the default pictures and the default text and is displayed in time. And after the cached component information is acquired from the component management module based on the desktop component framework, replacing and displaying the component information of each service module in the component interface.

And S3, calling the component display module to generate a component interface based on the component data and the component interface information corresponding to each service ID, and displaying the component interface in a desktop homepage, wherein the component interface displays a plurality of widgets for providing the starting entrances of each service module.

After the component display module receives the component information of the corresponding business module sent by each business component management module, a component interface can be generated based on the component information of each business module and displayed in the desktop homepage. And each service module generates a corresponding Widget, is arranged on the component interface, and triggers a certain Widget, so that the service module corresponding to the Widget can be quickly started.

For this purpose, the controller generates a component interface based on the component data and the component interface information corresponding to each service ID in the execution calling component presentation module, and is further configured to perform the following steps:

step 31, calling the component display module to generate a component display frame including multiple widgets based on the component interface information corresponding to each service ID, where one service ID corresponds to one Widget.

And step 32, displaying the component data corresponding to each service ID on the corresponding Widget to form a component interface, wherein one Widget corresponds to one service module.

The component interface information in the component information is used to determine the layout and size (length and width dimensions) of the Widget corresponding to each service module, so that when the Widget corresponding to each service module is displayed in the component interface, the layout and sequencing can be performed according to the size of each Widget. The component data in the component information is used to determine the information of the corresponding service module, such as the name, icon, brief introduction content, etc. of the service module, which is displayed on each Widget.

Therefore, when the desktop component interface is displayed, the component display module determines the layout and the sequence of the widgets corresponding to each service module based on the component interface information of the service module corresponding to each service ID. After the layout and the sequencing of the widgets are finished, the component data of the service module corresponding to each service ID are respectively displayed on the corresponding widgets to form a component interface. And the service ID, the service module and the Widget are in one-to-one correspondence.

If a user wants to quickly start a certain service module provided by the desktop application, finding the Widget corresponding to the service module in the component interface, triggering the Widget, and directly accessing the homepage of the corresponding service module to realize quick start of the service module.

In some embodiments, when the Widget is displayed in the component interface, a plurality of grid nets with the same size and arranged regularly are arranged on the component interface. Different widgets occupy different numbers of grids because different widgets correspond to different component sizes.

FIG. 9 illustrates a schematic diagram of a component interface, according to some embodiments. In order to simplify the drawing, the desktop homepage portion in the actual display is not shown, and it should be noted that the component interface and the desktop homepage are two independent display modules, and the component interface can be independently set in different display modes from the desktop homepage. Referring to FIG. 9, for example, if a "My Home" component occupies 3 grids in the horizontal direction, the corresponding component size is 3 × 1; the "my applications" component occupies 2 grids in the lateral direction, and the corresponding component size is 2 × 1; the 'shortcut setup' component occupies 1 grid, and the corresponding component size is 1 × 1; the "media center" components occupy a grid, and the corresponding component sizes are 1x 1.

And splicing and sequencing the widgets according to the sizes of the respective components, so that the total number of the grids occupied by the spliced widgets in the transverse direction is the same as the total number of the transverse grids preset in the component interface, and the number of the vertical grids can be expanded in real time, namely, the total number of the transverse display grids of the component interface is unchanged, and the total number of the longitudinal display grids is changeable.

In some embodiments, if a Widget corresponding to a service module is newly added, a Widget is newly displayed on the basis of each Widget originally displayed in the component interface. If the component size of the Widget is larger and the Widget cannot be completely displayed in the transverse direction, automatically expanding one row downwards for displaying. And if a certain Widget displayed in the component interface is deleted, the vertical automatic contraction is carried out.

In some embodiments, the component interface is always loaded in the desktop application, that is, the component interface is displayed in a certain area position in the desktop homepage, and the component interface cannot be started to be displayed in other pages.

In some embodiments, if the display device directly enters the radio and television signal source when being started, such as directly playing a television program, at this time, the display device does not display a system homepage, and cannot enter a desktop homepage, that is, cannot generate a preset operation of starting a service module or a component interface, that is, cannot call out the component interface for display.

In some embodiments, when the desktop homepage is presented on the display device, if the user wants to start a different application, for example, a third-party cloud audiovisual application installed in a television, the interface of the cloud audiovisual application needs to be started after the desktop application (the JUUI application) is set as a background/revocation thread. And in the cloud audio-visual application display state, the component interface cannot be called out, and the component interface can be opened only after the desktop homepage is returned.

Therefore, according to the display device provided by the application, the desktop component framework is configured, the user-defined layout of each Widget displayed in the desktop component interface is realized through the desktop component framework, the display device is not limited by a system, rich interface effects can be realized, and the user experience is good.

In some embodiments, when data change occurs in a service module corresponding to a Widget displayed in a component interface, the displayed content of the Widget may be refreshed. The data refreshing mode comprises the step that the service module with the changed data actively informs the desktop application, and the component interface actively acquires the data change of each service module from the data center module according to a certain time interval.

In some embodiments, when the business module actively notifies the desktop application of data refresh, the controller is further configured to perform the following steps:

step 41, when the information generated by the target service module is updated, calling the data center module to acquire new component information generated by the target service module, and sending the new component information of the target service module to the target service component management module corresponding to the target service ID based on the target service ID of the target service module.

And step 42, calling the target service component management module to send the new component information corresponding to the target service ID to the component display module.

And step 43, the calling component display module determines a corresponding target Widget in the component interface based on the target service ID, and updates the information display of the target Widget based on the new component information corresponding to the target service ID, so as to update the display information in the component interface.

When the mode that the service module actively informs the desktop application to refresh the data is adopted, the target service module generating the data change actively informs the desktop application to refresh the display content corresponding to the Widget in the component interface, and at the moment, the target service module generating the data change sends the data change to a data center module (Widget service).

The data change which can be generated by the target business module comprises component data change or component interface information change, the component data change comprises information needing to be displayed or triggering operation mode change, and the component interface information change comprises style or layout change. Therefore, new component information can be generated based on the changed data of the target business module, and the new component information is actively generated to the data center module.

And after simply processing the new component information of the target service module, the data center module distributes the new component information of the target service module to a target service component management module corresponding to the target service module. At the time of distribution, a target service component management module (Widget manager) for managing the target service module component information may be determined based on the target service ID of the target service module.

In order to realize the data refreshing of the component interface, the target service component management module is called to send new component information corresponding to the target service ID to the component display module, and the component display module updates the display content corresponding to the Widget in the component interface based on the new component information. Meanwhile, in order to update the cache data in the component management module in time, the target service component management module synchronously sends the corresponding new component information to the component management module for storage based on the target service ID.

When the new component information represents that the target service module generates component data with data change, for example, the target service module is a contact application terminal, and if a user newly adds/deletes a contact at the application terminal, the changed component data is contact information. After the contact information is transmitted to the component display module based on the desktop component framework, the target Widget in the component interface is determined to be a contact component by the target service ID of the target service module. Therefore, the newly added contact information is updated to the display content of the contact component, or the deleted contact information is deleted from the contact component, so that the display information in the component interface is updated.

When the new component information represents that the target service module generates the data change, namely the component interface information, for example, the target service module is a contact application terminal, if the style of the contact component is square, the component style is changed into a circle, and then the changed component interface information is the component style. After the component style information is transmitted to the component display module based on the desktop component framework, the target Widget in the component interface is determined to be a 'contact' component by the target service ID of the target service module. Therefore, the component style of the contact component is updated from the original square shape to the circular shape, and the updating of the display information in the component interface is realized.

Therefore, when a certain service module provided in the desktop application generates data change, the service module actively informs the desktop application to update the display information in the component interface in real time, so that the dynamic component can be conveniently realized, and the component interface display effect is better.

In some embodiments, in the data refreshing by actively acquiring the changed data of the service module by using the component interface, the controller is further configured to perform the following steps:

step 51, when the component interface display information is refreshed at intervals, calling a target service component management module to acquire new component information generated by a target service module from a data center module according to a preset interval, and sending the new component information generated by the target service module to a component display module;

step 52, the calling component display module determines a corresponding target Widget in the component interface based on the target service ID, and updates the information display of the target Widget based on the new component information corresponding to the target service ID, so as to implement the interval refresh of the display information in the component interface.

When a mode that a component interface actively acquires change data of a service module to refresh the data is adopted, the component interface actively requests a target service module to return the change data, at the moment, the target service module receives the request and then sends new component information generated by the target service module to a data center module, and after simple data processing, a service component management module corresponding to the target service module (target service ID) acquires the new component information generated by the target service module from the data center module.

In order to realize data refreshing of the component interface, the target service component management module is called to send new component information corresponding to the target service ID to the component display module, and the component display module updates display content corresponding to the Widget in the component interface based on the new component information. Meanwhile, in order to update the cache data in the component management module in time, the target service component management module synchronously sends the corresponding new component information to the component management module for storage based on the target service ID.

In some embodiments, the preset interval of the component interface interval update information may be set to 30 minutes, and then the preset interval of calling the target service component management module to actively acquire the new component information of the target module is also set to 30 minutes. The preset interval may also be other values, and is not particularly limited.

Figure 10 illustrates a schematic diagram of player Widget data refresh in a component interface, in accordance with some embodiments. When the new component information represents that the target service module generates the component data with the data change, for example, the target service module is a player, and the corresponding target Widget in the component interface is a "player" component. Referring to fig. 10 (a), if the "player" component originally shows the song A, B, C, after a preset interval of 30 minutes, the target service component management module corresponding to the player actively requests the player to return the current playing information through the data center module. Referring to fig. 10 (b), if the currently playing information is song A, B, C, D, E, the presentation content of the "player" component in the component interface is changed from "song A, B, C" to "song A, B, C, D, E" to automatically present the latest playing information of the player to the user, enabling an interval refresh of the presentation information in the component interface.

Therefore, the desktop application can actively acquire the data change generated by a certain service module, and the target service component management module corresponding to the service module actively acquires the new component information of the service module according to the preset interval so as to actively update the display information in the component interface at real-time intervals, so that the dynamic component can be conveniently realized, and the component interface display effect is better.

In some embodiments, when the dynamic component is implemented, the desktop application may further change an effective state of the corresponding Widget in the component interface according to the service state of each service module, where the effective state is used to represent whether the corresponding Widget can be triggered by being clicked. For example, if a certain service module is uninstalled, in order to prompt a user that the service module cannot be quickly started through a Widget in the component interface, a failure identifier may be added to the corresponding Widget.

Specifically, when adding a failure identifier to the failed Widget, the controller is further configured to perform the following steps:

and 61, when the target service module is deleted, receiving the deletion operation of the target service module, and calling the corresponding target service component management module to send a service deletion instruction carrying the target service ID to the component display module based on the target service ID of the target service module.

And step 62, calling the component display module, and adding a failure identifier on the target Widget corresponding to the target service ID in the component interface based on the service deletion instruction, wherein the failure identifier is used for representing the Widget failure corresponding to the target service module corresponding to the target service ID.

When a certain service module is deleted, the service state of the service module changes, so that the desktop application is actively notified to update the display information corresponding to the Widget in the component interface.

If a certain service module configured in the desktop application is deleted/offline, which indicates that the desktop application does not provide the service module any more, the application management module of the display device sends the deletion/offline broadcast to the component interface, and displays the invalidation identifier on the target Widget corresponding to the service module. When the application module is deleted, the corresponding Widget in the component interface is displayed with the failure identification, and the user is informed that the corresponding Widget is failed, the corresponding service module is deleted, the corresponding service module cannot be started by triggering the Widget, and the user experience is good. Meanwhile, in order to update the cache data in the component management module in time, the target service component management module synchronously sends a corresponding service deletion instruction to the component management module based on the target service ID, so that the component management module deletes the component information of the deleted service module and updates the cache.

Failure means unavailability. Failure of a business module refers to whether an application is available, e.g., if the application, while present in the display device, is not available due to policy reasons, whether it is offline or no longer maintained in the background. Conversely, active means an available state.

When the target service module is deleted, the service state of the target service module changes, and then the new component information representation component data of the target service module changes, at this time, the component data means that the target service module is unavailable, that is, the triggering operation cannot be executed.

After the target service module generates new component information, the desktop application is actively informed, that is, the new component information is sent to the data center module, and after the data center module simply processes the new component information of the target service module, the new component information of the target service module is distributed to the target service component management module corresponding to the target service module. At the time of distribution, a target service component management module (Widget manager) for managing the target service module component information may be determined based on the target service ID of the target service module.

And based on the new component information, calling a target service component management module corresponding to the target service ID to send a service deletion instruction carrying the target service ID to the component display module. In order to realize the data refreshing of the component interface, the component display module adds a failure identifier on the target Widget corresponding to the target service ID in the component interface based on the service deletion instruction, wherein the failure identifier is used for representing the Widget failure corresponding to the target service module corresponding to the target service ID.

Figure 11 illustrates a schematic diagram showing invalidation identification on a Widget, according to some embodiments. Referring to fig. 11, if the service module unloaded by the user is an on-the-fly listening module, after the service deletion instruction of the media center is transmitted to the component display module based on the desktop component framework, the target service ID of the target service module determines that the target Widget in the component interface is an "on-the-fly listening" component. And finally, displaying a failure identifier, such as a 'failed' identifier in the figure, on the Widget corresponding to the listening-along-with-mind service in the component interface.

Therefore, when a certain service module provided in the desktop application is deleted, the service module actively informs the desktop application to update the display information in the component interface in real time, so that the dynamic component can be conveniently realized, and the component interface display effect is better.

In some embodiments, after the component interface is displayed on the desktop homepage, when the user sees that a Widget showing a failure identifier exists in the component interface, if the user triggers the failure Widget, a failure prompt interface pops up in the current interface.

Specifically, when the Widget control with the failure identifier is triggered, the controller is further configured to:

step 71, receiving a trigger operation on the target Widget with the invalidation identifier displayed in the component interface, not executing a starting process of a target service module corresponding to the target Widget, and presenting an invalidation prompting interface with a deletion button displayed in a desktop homepage.

And 72, receiving a trigger operation on the delete button, and deleting the target Widget in the component interface.

When the target Widget with the failure identifier is displayed in the user trigger component interface, the target service module corresponding to the target Widget cannot be started. Therefore, when the target Widget with the failure identifier is triggered in the component interface, the action of starting the target service module corresponding to the target Widget is not executed any more.

And in order to inform the user that the target service module corresponding to the current target Widget cannot be started, a failure prompt interface pops up in the desktop homepage.

FIG. 12 illustrates a schematic diagram of a failure prompt interface, according to some embodiments. Referring to fig. 12, when the user triggers the "media center" Widget that has been disabled, a failure prompt interface is presented in the current user interface. And a deleting button, a canceling button and a replacing control display area are displayed in the failure prompt interface. And the delete button is used for deleting the invalid Widget, and the cancel button is used for closing the invalid prompt interface. And the replacement control display area is used for displaying other widgets which are recommended by the system and can be displayed. If the user clicks the delete button, the target Widget in the component interface can be deleted, that is, the Widget of the 'media center' is deleted.

In some embodiments, the component interface is located in the desktop homepage, and then when the failed target Widget is triggered based on the component interface, the failure prompt interface is provided by the component interface, namely, the component presentation module controls the presentation. The popped failure prompt interface is displayed on the upper layer of the component interface, which is equivalent to the failure prompt interface displayed on the upper layer of the desktop homepage. The display of the failure prompt interface does not affect the original display structure of the desktop homepage, namely, the position of each service displayed in the desktop homepage cannot be adjusted, and the failure prompt interface is displayed in a suspension mode.

In some embodiments, when the recommended Widget recommended by the system is displayed in the Widget display area, the recommended Widget is generated based on the attribute parameter of the target Widget with the failure identifier, and the attribute parameter is Widget (Widget) information. When a user registers a Widget based on a service application, information such as an icon, a size, a service type, an application to which the user belongs, and the like generated when the user registers the service Widget is stored in a component management module (Widget). Accordingly, the attribute parameters of the target Widget may be obtained from a component management module (Widget server). The attribute parameters comprise control size, service type, application and the like. The recommended Widget control refers to a control with the same characteristics as the target Widget, and is used for being displayed in the original position of the deleted target Widget control in a triggering replacement mode based on the user.

The replacement control display area in the failure prompt interface can be displayed below the delete button, if the display bit threshold value which can be displayed in the replacement control display area can be 6, the replacement control display area displays 6 recommended Widget controls at most, the display bits which can be displayed in the replacement control display area can also be other numbers, and the replacement control display area can be adjusted according to the actual application condition.

Because the widgets of different widgets have different sizes, the Widget recommended by the system can be displayed to the original position of the deleted target Widget conveniently, and widgets with the same size can be searched based on the size of the deleted Widget. And based on the fact that the user can start the widgets with similar characteristics at the same position, the widgets which can be alternatively displayed can be recommended for the user based on the service type or the application which the user belongs to as the attribute parameter. That is to say, the recommended Widget control having the same characteristics as the target Widget refers to a Widget having at least one characteristic, which is the same in Widget size, similar in service type, and the same in belonging application.

In some embodiments, the desktop component framework can implement multi-level menu expansion of a Widget in a component interface, classify each service module provided by the desktop application according to service requirements, divide services belonging to the same type into the same class, and configure a total Widget in the component interface for the class. When a certain service under the total Widget needs to be triggered, the total Widget can be triggered, a secondary service menu is popped up in the component interface, and menu items corresponding to the services belonging to the same type are displayed in the secondary service menu. And then a certain menu item is triggered based on the secondary service menu, so that the corresponding service can be quickly started.

To this end, when the desktop component framework is classified based on the type of each business module, the controller is further configured to perform the following steps:

step 81, when a Widget group is added to the component interface, receiving a trigger operation on an adding button displayed in the component interface, switching an adding page to be displayed in the user interface, displaying a Widget group list and a component preview area in the adding page, wherein the service types of service modules to which the widgets belong in the same Widget group are the same, and the component preview area displays the widgets corresponding to the Widget group.

And step 82, receiving the trigger operation of the target Widget group in the Widget group list, and displaying the Widget corresponding to the target Widget group in the component preview area.

And step 83, receiving a trigger operation on the target Widget in the component preview area, and adding the target Widget corresponding to the target Widget group into the component interface.

The user can add the Widget based on the component interface, at this time, an adding button (as shown in fig. 9) is displayed at the bottommost part of the component interface, the adding button is triggered, an adding page is generated, and the adding page is displayed in the user interface in a switching manner.

FIG. 13 illustrates a schematic diagram of adding pages, according to some embodiments. Referring to fig. 13, a page is added to show a Widget grouping list and a component preview area, where the Widget grouping list shows names of a plurality of Widget groupings, and a Widget grouping includes widgets having service modules of the same service type, that is, service modules of the same service type are classified; the component preview area displays the widgets of all the service modules corresponding to the Widget groups, and the display content of the component preview area is changed along with the change of the clicked target Widget groups in the Widget group list.

In some embodiments, the add page and component interface are generated by a component presentation module and the desktop homepage is generated by an application management module of the system configuration. In the interface shown in fig. 7, the display window of the desktop application is located on the system homepage, and when the desktop application is triggered, the desktop homepage pops up and is displayed on the upper layer of the system homepage. When the component interface needs to be called out, a user presses the left key of the remote controller for a long time, and the component interface is called out and displayed in a desktop homepage. One possible display mode of the component interface is to pop up the desktop homepage from the left side of the display and extrude the desktop homepage to the right, and a vacant space is reserved on the left side of the desktop homepage for displaying the component interface. At this time, the right display content of the desktop homepage disappears from the display, and is displayed in the state shown in fig. 8; and if the display of the Widget panel is canceled, the whole desktop homepage moves leftwards and restores the original state.

In some embodiments, the component interface is located in a desktop homepage, then when an add button is triggered based on the component interface, the add page is provided by the component interface, i.e., the presentation is controlled by the component presentation module. The popped added page is displayed on the upper layer of the component interface, which is equivalent to the upper layer displayed on the homepage of the desktop. The added page is displayed on the upper layer of the desktop homepage in an overlaying mode, so that the display of the added page does not influence the original display structure of the desktop homepage, namely, the position of each service displayed in the desktop homepage cannot be adjusted.

In some embodiments, if the user triggers the target Widget group, for example, the kid zone, it may be determined that the service modules belonging to the same service type and corresponding to the target Widget group (kid zone) may be "kid mode", "kid classroom", "learning report", and the like, and then the widgets of the service modules corresponding to the target Widget group, for example, "kid mode" Widget, "kid classroom" Widget, "learning report" Widget, and the like, need to be displayed in the component preview area. Each service Widget can have different component sizes, so that a user can select and add a Widget with a target component size to a component interface.

In some embodiments, when the add-on page is displayed, the service component management module obtains, from the component management module, component information and a service type of each service module of the corresponding pre-registered Widget based on each service ID, where the component information refers to information generated by the service module provided by the desktop application when the Widget is registered, the component information includes component data and component interface information, the component data refers to data that the service module represented by the service ID needs to be displayed on a component interface, and the component interface information refers to interface layout information displayed by the Widget.

And grouping the service modules based on the service types, calling the component display module to generate a Widget grouping list for the service modules with the same service types, and displaying the Widgets corresponding to each service module with the same service types in the component preview area. When a user triggers any target Widget group in the Widget group list, displaying each Widget corresponding to the target Widget group in the component preview area; and when another target Widget group is switched and triggered, each Widget corresponding to the newly triggered target Widget group is switched and displayed in the component preview area.

In some embodiments, if a user adds at least one Widget to a component interface in a certain group, when the add page is displayed, the service component management module counts the service types of the service modules which have been added with the Widget to the component interface at the previous time, and calculates the number of the service modules which have been added with the Widget to the component interface in the same service type based on the added service types. When the Widget grouping list is displayed, the added number is displayed on the display entry where the Widget grouping corresponding to the service type is located, for example, the added number of widgets in the "media center" Widget grouping in fig. 13 is 1.

And if the Widget of each service module under the juvenile special area group is required to be displayed in the component interface by the user, directly triggering the target Widget in the component preview area, and adding the Widget of the juvenile mode into the component interface if the Widget of the juvenile mode is triggered.

At this time, in order to add the widgets of each service module in the target Widget group in the component interface, the triggered target Widget determines a target service ID, and calls a target service component management module corresponding to the target service ID to store the component information of the target Widget into the component management module, so as to facilitate subsequent component display.

FIG. 14 illustrates another schematic diagram of adding a page according to some embodiments. Referring to fig. 14, when the user triggers that the target Widget group in the add page is "application", it may be determined that service modules corresponding to the target Widget group (application specific area) are all services of an application type, and may be "cloud audio-visual small tv", "CIBN coolaoet", "cloud audio-visual aurora", "galaxy kiwi", and the like. Then, in the component preview area, a fixed Widget of the target Widget group and widgets of each service module corresponding to the target Widget group need to be displayed, for example, the fixed Widget is a "my application (1x 1)" Widget, "my application (2x 1)" Widget, or a "my application (2x 2)" Widget; the widgets corresponding to the target Widget grouping can be 'cloud audio-visual small television' Widget, 'CIBN coolao' Widget, 'cloud audio-visual aurora' Widget, 'Galaxy kiwi' Widget and the like.

A fixed Widget of a target Widget group (e.g., an application group) includes different component sizes, and widgets of different component sizes execute different triggering processes, for example, if the component size is 1x1, when a corresponding "application" group Widget is triggered, a user interface may jump to my application page, where my application page shows applications of the same application type, and the application is shown in a menu item form and is no longer shown in a Widget form; if the component size is 2x1 or 2x2, when the corresponding application grouping Widget is triggered, a classification menu of my application is presented on the upper layer of the current component interface, and each application installed by the system and having the same application type is presented in the classification menu of my application, and the application is presented in the form of a menu item and is not presented in the form of Widget any more.

In some embodiments, if a user wants to add a Widget group corresponding to the same service type to a component interface, so as to simultaneously view service modules (e.g., all applications) installed in the system through the component interface, the user may click a fixed Widget of a target Widget group in a component preview area, such as a "my applications (2x 1)" Widget; if a user wants to add a Widget of a certain service module into the component interface so as to directly start the certain service module based on the component interface, the Widget of each service module in the component preview area can be clicked, such as a "cloud audio-visual small television" Widget, "CIBN cool meo" Widget, "cloud audio-visual polar light" Widget, "silver river kiwi" Widget, and the like.

Therefore, when the desktop component is displayed based on the desktop component framework, the display device provided by the application can customize the width and the height, the layout and the style of the component, click skipping, multilevel menu expansion and the like according to the service requirements, the display effect of the component interface is better, and the user experience is good.

In some embodiments, when a user triggers a target Widget corresponding to a target Widget group based on a component interface, a secondary classification menu may be popped up in a current component interface to display all service modules belonging to service types corresponding to the target Widget group. To this end, the controller is further configured to perform the steps of:

step 91, when triggering the target Widget corresponding to the target Widget group, receiving a triggering operation on the target Widget corresponding to the target service module in the component interface, and if the component size of the target Widget meets a preset size, calling the target service component management module to obtain menu item information corresponding to each service module in the target Widget group from the component management module, and sending the menu item information to the component display module.

And step 92, calling the component display module to generate a service menu based on the menu item information corresponding to each service module, and displaying the service menu in the component interface, wherein the service menu displays the service menu item corresponding to each service module in the target Widget group.

When a user needs to trigger a target Widget corresponding to a target Widget group, whether the component size of the target Widget in a user trigger component interface meets a preset size is judged, wherein the preset size is a component size which is not 1x 1. If the component size of the target Widget is 1x1, the preset size is not satisfied, and therefore, the user interface jumps to the main page of the target Widget grouping. For example, when a target Widget corresponding to "application" is triggered, if the component size of the Widget is 1x1, the user interface jumps to my application page, and the my application page shows applications that are also of the application type, and the application is shown in the form of a menu item and is not shown in the form of a Widget any more.

If the component size of the target Widget is 2x1 or 2x2, the preset size is met, and therefore, a classification menu, i.e., a service menu, corresponding to the target Widget group can be popped out from the component interface. At this time, the target service component management module corresponding to each service module in the target Widget grouping is called to acquire the menu item information corresponding to each service module in the corresponding target Widget grouping from the component management module, and the menu item information is sent to the component display module.

And when all the service menu items under the classification of the target service module are displayed, the component display module generates a service menu based on the menu item information corresponding to each service module. The service menu is a secondary menu relative to the component interface, and the service menu item corresponding to each service module in the target Widget group is displayed in the service menu, and the mode of generating the service menu may refer to the mode of generating the component interface based on the component information of each service module provided by the desktop application in the foregoing embodiment, which is not described herein again.

For example, if the triggered "application" group Widget has a component size of 2x1 or 2x2, a classification menu of "my application" is presented at the upper layer of the current component interface, and each application of the same application type installed by the system is presented in the classification menu of "my application", and the application is presented in the form of a menu item.

FIG. 15 illustrates a schematic diagram of a service menu, according to some embodiments. Referring to fig. 9 and fig. 15, if the user triggers the "my application (2x 1)" Widget corresponding to the target Widget group (my application) based on the component interface, a service menu pops up in the current component interface, and menu items of all applications under the category of the "my application" are displayed in the service menu, such as a "cloud audio-visual small television" menu item, a "CIBN cat" menu item, a "cloud audio-visual polar light" menu item, a "bank river kiwi fruit" menu item, and the like. The user can directly start the corresponding application by triggering any menu item.

FIG. 16 illustrates another schematic diagram of a service menu, according to some embodiments. Referring to fig. 9 and 16, if the user triggers an "AI Camera" Widget corresponding to a target Widget group (AI Camera) based on a component interface, a service menu pops up in the current component interface, and menu items of all applications under the "AI Camera" category, such as a "magic mirror" menu item, a "video call" menu item, an "AI fitness" menu item, a "small aggregation at home" menu item, are displayed in the service menu. The user can directly start the corresponding business module by triggering any menu item, and the corresponding business homepage is switched and displayed.

In some embodiments, the component interface is located in the desktop homepage, and then when the target Widget grouping is triggered based on the component interface, a service menu pops up and is displayed on the upper layer of the component interface, and the service menu is provided by the component interface, namely, the component presentation module controls presentation. The service menu is displayed on the upper layer of the component interface in a floating layer mode, so that the display of the service menu does not influence the original display structures of the component interface and the desktop homepage, namely, the positions of the services originally displayed in the component interface and the desktop homepage cannot be adjusted.

In some embodiments, referring to fig. 9 again, an editing button and an alignment button are also displayed in the component interface, and the editing button is triggered to modify any Widget displayed in the component interface, such as modifying a property; and triggering the alignment button, and aligning and arranging all widgets displayed in the component interface.

In some embodiments, in the component interface display process, no matter the target service module generates data change in any one of the above described manners, when the component interface is required to refresh the interface display content, the change data of the target service module is returned, or when the target service module actively refreshes the data, the change data is sent to the data center module, and after the data center module receives and simply processes the change data, the change data is distributed to the corresponding target service component management module according to the target service ID. And after receiving the data, the target service component management module distributes the data to the corresponding Widget according to the target service ID. And after receiving the data, the component display module displays the change data on the target Widget so as to update the display information of the component interface.

Therefore, when the desktop component is displayed based on the desktop component framework, the display device provided by the application can classify all the service modules provided by the desktop application according to different types, and all the services under the same classification belong to the same type. Thus, a large number of classes can be expanded laterally indefinitely, each class managing its own components.

FIG. 6 illustrates a flow diagram of a component presentation method according to some embodiments. Referring to fig. 6, an embodiment of the present invention provides a component display method, including:

s1, receiving a starting operation of the desktop application, acquiring service data of each service module provided by the desktop application, and displaying a desktop homepage in the user interface based on the service data of each service module;

s2, when the component interface is displayed, calling a service component management module to acquire component information of a service module corresponding to each service ID from the component management module and sending the component information to the component display module, wherein the component information refers to information generated when a service module provided by desktop application registers Widget, the component information includes component data and component interface information, the component data refers to data required to be displayed on the component interface by the service module represented by the service ID, and the component interface information refers to interface layout information displayed by the Widget;

In specific implementation, the present invention further provides a storage medium, where the storage medium may store a program, and the program may include some or all of the steps in each embodiment of the component display method provided in the present invention when executed. The storage medium may be a magnetic disk, an optical disk, a read-only memory (ROM) or a Random Access Memory (RAM).

Those skilled in the art will readily appreciate that the techniques of the embodiments of the present invention may be implemented as software plus a required general purpose hardware platform. Based on such understanding, the technical solutions in the embodiments of the present invention may be embodied in the form of software products, which may be stored in storage media, such as ROM/RAM, magnetic disk, optical disk, etc., or in the form of portions that contribute to the prior art.

The same and similar parts in the various embodiments in this specification may be referred to each other. In particular, as for the embodiment of the component display method, since it is substantially similar to the embodiment of the display device, the description is simple, and the relevant points can be referred to the description in the embodiment of the display device.

Finally, it should be noted that: the above embodiments are only used for illustrating the technical solutions of the present application, and not for limiting the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present application.

The foregoing description, for purposes of explanation, has been presented in conjunction with specific embodiments. However, the illustrative discussions above are not intended to be exhaustive or to limit the embodiments to the precise forms disclosed above. Many modifications and variations are possible in light of the above teaching. The embodiments were chosen and described in order to best explain the principles and the practical application, to thereby enable others skilled in the art to best utilize the embodiments and various embodiments with various modifications as are suited to the particular use contemplated.

Claims

1. A display device, comprising:

a display configured to present a user interface;

a controller connected with the display, the controller configured to:

when an assembly interface is displayed, calling a service assembly management module to acquire assembly information of a service module corresponding to each service ID from the assembly management module and sending the assembly information to the assembly display module, wherein the assembly information refers to information generated when the service module provided by the desktop application registers the Widget, the assembly information comprises assembly data and assembly interface information, the assembly data refers to data which needs to be displayed on the assembly interface by the service module represented by the service ID, and the assembly interface information refers to interface layout information displayed by the Widget;

2. The display device according to claim 1, wherein the controller, in executing the invoking the component exposure module, generates a component interface based on the component data and component interface information corresponding to each service ID, and is further configured to:

calling the component display module to generate a component display frame comprising a plurality of widgets based on the component interface information corresponding to each service ID, wherein one service ID corresponds to one Widget;

and displaying the component data corresponding to each service ID on the corresponding Widget to form a component interface, wherein one Widget corresponds to one service module.

3. The display device of claim 1, wherein the controller is further configured to:

when registering a Widget for a service module, acquiring service data of each remote service module, wherein the remote service module comprises a service module provided by a desktop application or a third-party application;

sending the service data of each remote service module to a data center module, wherein the data center module is used for processing the service data of each remote service module;

after the service data is processed, respectively configuring a service component management module for each service module based on the service ID of each service module;

calling a target service component management module, registering the corresponding Widget for the target service module, and storing component information generated by registering the Widget and the corresponding service ID into the component management module.

4. The display device of claim 3, wherein the controller is further configured to:

when a target service module generates information updating, calling a data center module to acquire new component information generated by the target service module, and sending the new component information of the target service module to a target service component management module corresponding to the target service ID based on the target service ID of the target service module;

calling the target service component management module to send new component information corresponding to the target service ID to a component display module;

and calling the component display module to determine the corresponding target Widget in the component interface based on the target service ID, and updating the information display of the target Widget based on the new component information corresponding to the target service ID to realize the updating of the display information in the component interface.

5. The display device of claim 3, wherein the controller is further configured to:

when component interface display information is refreshed at intervals, calling the target service component management module to acquire new component information generated by a target service module from the data center module according to a preset interval, and sending the new component information generated by the target service module to a component display module;

and calling the component display module to determine the corresponding target Widget in the component interface based on the target service ID, and updating the information display of the target Widget based on the new component information corresponding to the target service ID to realize the interval refresh of the display information in the component interface.

6. The display device of claim 1, wherein the controller is further configured to:

when a target service module is deleted, receiving a deletion operation of the target service module, and calling a corresponding target service component management module to send a service deletion instruction carrying a target service ID to a component display module based on the target service ID of the target service module;

and calling the component display module, and adding a failure identifier on the target Widget corresponding to the target service ID in the component interface based on the service deletion instruction, wherein the failure identifier is used for representing the Widget failure corresponding to the target service module corresponding to the target service ID.

7. The display device of claim 6, wherein the controller is further configured to:

receiving a trigger operation of a target Widget with a failure identifier displayed in the component interface, not executing a starting process of a target service module corresponding to the target Widget, and presenting a failure prompt interface with a deletion button displayed in the desktop homepage;

and receiving the trigger operation of the deleting button, and deleting the target Widget in the component interface.

8. The display device of claim 1, wherein the controller is further configured to:

when a Widget group is added into a component interface, receiving a trigger operation of an adding button displayed in the component interface, switching an adding page to be displayed in a user interface, wherein a Widget group list and a component preview area are displayed in the adding page, the service types of service modules of the widgets belonging to the same Widget group are the same, and the component preview area displays the widgets corresponding to the Widget group;

receiving a trigger operation of a target Widget group in the Widget group list, and displaying a Widget corresponding to the target Widget group in the component preview area;

and receiving a trigger operation on the target Widget in the component preview area, and adding the target Widget corresponding to the target Widget group into a component interface.

9. The display device of claim 8, wherein the controller is further configured to:

when a target Widget corresponding to the target Widget group is triggered, receiving triggering operation of the target Widget in the component interface, if the component size of the target Widget meets a preset size, calling the target service component management module to acquire menu item information corresponding to each service module in the target Widget group from the component management module, and sending the menu item information to the component display module;

and calling the component display module to generate a service menu based on the menu item information corresponding to each service module, and displaying the service menu in a component interface, wherein the service menu displays the service menu item corresponding to each service module in the target Widget group.

10. A method of component display, the method comprising: