UI error display method and system therefor

Abstract

The present disclosure relates to a user interface (UI) error display method and an apparatus therefor. Particularly, provided are: a method in which a user terminal is monitored in order to detect a UI error in the user terminal and display information related to the error; and an apparatus therefor. According to one embodiment of the present disclosure, a UI error display method can be provided, the method comprising the steps of: transmitting, to an application of a user terminal, first data for performing a first update; detecting an error in a first widget by using the tree structure of the first widget displayed on the application; performing filtering for whether the error is related to the first data; and displaying, on a manager terminal, information related to the filtered error.

Description

UI error display method and its system

[0001] The present disclosure relates to a method for displaying UI errors and an apparatus thereof. Specifically, it relates to a method and apparatus for monitoring a user terminal to detect a User Interface (UI) error in the user terminal and displaying information related to the error.

[0002] When purchasing goods through online commerce, the purchased goods are delivered to the address designated by the buyer. The purchased goods are delivered directly by a delivery employee, and this delivery constitutes the final stage of the product transaction through online commerce.

[0003] Delivery personnel can check delivery-related information through programs or applications provided on user terminals. These programs contain important delivery information, such as the delivery address, access methods, and shipping labels, playing an essential role in enabling employees to deliver products accurately.

[0004] Meanwhile, if an error occurs preventing the verification of shipping-related information on the user's device, such an error can cause significant disruptions to the product delivery process. If the error is due to a problem with a computer program or application on the user's device, a rollback or a new update can quickly resolve the issue.

[0005] Therefore, technology is required to rapidly detect errors occurring in computer programs or applications that display delivery-related information within a user terminal, to analyze whether such errors are related to the computer program or application, and to address such errors.

[0006] The aforementioned background technology is technical information that the inventor possessed for the derivation of the present disclosure or acquired during the process of deriving the present disclosure, and it cannot be considered technology that was known to the general public prior to the filing of the present disclosure.

[0007] The technical problem to be solved in some embodiments of the present disclosure is to provide a method for rapidly detecting errors related to a UI occurring in a user terminal and a computing device for performing the method.

[0008] The technical problem to be solved in some other embodiments of the present disclosure is to provide a method for rapidly analyzing whether a UI-related error occurring in a user terminal was caused by an update of the user terminal, and a computing device for performing the method.

[0009] The technical problem to be solved in some other embodiments of the present disclosure is to provide a method for comprehensively displaying information about errors and a computing device for performing the method, in order to quickly respond to errors related to a UI occurring at a user terminal.

[0010] The technical problems of the present disclosure are not limited to those mentioned above, and other unmentioned technical problems will be clearly understood by a person skilled in the art of the present disclosure from the description below.

[0011] According to one embodiment of the present disclosure, a method for displaying a UI error may be provided, comprising the steps of: transmitting first data to perform a first update to an application of a user terminal; detecting an error regarding a first widget using a tree structure of a first widget displayed in the application; filtering whether the error is related to the first data; and displaying information related to the filtered error to an administrator terminal.

[0012] In one embodiment, the step of detecting an error for the first widget may include the step of monitoring the application for a preset time starting from the transmission of the first data, and the step of detecting an error for the first widget for the preset time.

[0013] In one embodiment, the step of monitoring the application includes the step of monitoring the first widget during a first monitoring period and the step of monitoring the second widget during a second monitoring period, wherein the second widget may be a widget that is displayed in the application and is different from the first widget.

[0014] In one embodiment, the step of monitoring the application is to monitor the application of a user terminal configured among the user terminals that received the first data, and may further include the step of applying the processing for the first update to all user terminals that received the first data.

[0015] In one embodiment, the step of detecting an error for the first widget may be a step of detecting an error in which text or an image displayed on the first widget exceeds the screen of the user terminal.

[0016] In one embodiment, the step of detecting an error regarding the first widget may be a step of detecting an error in which the first widget is not displayed on the user terminal.

[0017] In one embodiment, the step of detecting an error for the first widget is a step of detecting an error in which information included in the first widget is not displayed on the user terminal,

[0018] In one embodiment, the filtering step may include the step of determining an error for the first widget as an error related to the first data by using the time when the first widget is rendered to the user terminal.

[0019] In one embodiment, the filtering step may include the step of determining an error for the first widget as an error related to the first data by using the network traffic of the application.

[0020] In one embodiment, the filtering step may include the step of determining an error for the first widget as an error related to the first data by using the battery usage of the user terminal.

[0021] In one embodiment, the filtering step may include a step of checking the number of user terminals where the error occurred, and a step of determining the error for the first widget as an error related to the first data if the number of user terminals where the error occurred exceeds a threshold value.

[0022] In one embodiment, the step of displaying on the first screen may further include the step of transmitting a notification of the filtered error to the administrator terminal.

[0023] In one embodiment, the method may further include a step of automatically rolling back the first update of the application in response to filtering for the error.

[0024] In one embodiment, in response to the display of the first screen regarding the error, the method may further include the step of receiving processing for the first update from the administrator terminal and the step of applying processing for the first update to the user terminal.

[0025] In one embodiment, the processing for the first update may be a processing that rolls back only the update for the first widget.

[0026] In one embodiment, the step of receiving processing for the first update is the step of receiving second data for performing a second update of the application, and the step of applying processing for the first update to the user terminal may be the step of transmitting the second data to the application.

[0027] FIG. 1 is a configuration diagram showing the configuration of a UI error display system according to some embodiments of the present disclosure.

[0028] Figure 2 is an example diagram specifically illustrating a user terminal of the UI error display system described with reference to Figure 1.

[0029] Figure 3 is an example diagram specifically illustrating the administrator terminal of the UI error display system described with reference to Figure 1.

[0030] FIG. 4 is a flowchart illustrating an exemplary method for displaying UI errors according to some embodiments of the present disclosure.

[0031] Figure 5 is a flowchart exemplarily illustrating step S200 of the UI error display method described with reference to Figure 4.

[0032] Figure 6 is an example diagram specifically illustrating the UI error display method described with reference to Figure 4.

[0033] Figure 7 is another example diagram specifically illustrating the UI error display method described with reference to Figure 4.

[0034] Figure 8 is another example diagram specifically illustrating the UI error display method described with reference to Figure 4.

[0035] FIG. 9 is a flowchart specifically illustrating a method for displaying UI errors according to some other embodiments of the present disclosure.

[0036] FIG. 10 is an exemplary hardware configuration diagram that can implement a computing device in various embodiments of the present disclosure.

[0037] Hereinafter, embodiments of the present disclosure will be described in detail with reference to the attached drawings. The advantages and features of the embodiments of the present disclosure and the methods for achieving them will become clear by referring to the embodiments described below in detail together with the attached drawings. However, the technical concept of the present disclosure is not limited to the following embodiments but can be implemented in various different forms. The following embodiments are provided merely to complete the technical concept of the present disclosure and to fully inform those skilled in the art of the scope of the present disclosure, and the technical concept of the present disclosure is defined only by the scope of the claims.

[0038] It should be noted that when assigning reference numerals to the components of each drawing, the same components are given the same reference numeral whenever possible, even if they are shown in different drawings. Furthermore, in describing the embodiments of the present disclosure, if it is determined that a detailed description of related known components or functions could obscure the essence of the matter, such detailed description is omitted.

[0039] Unless otherwise defined, all terms used in this disclosure (including technical and scientific terms) may be used in a meaning commonly understood by those skilled in the art to which the embodiments of this disclosure pertain. Additionally, terms defined in commonly used dictionaries are not to be interpreted ideally or excessively unless explicitly and specifically defined otherwise. The terms used in this disclosure are intended to describe the embodiments and are not intended to limit the embodiments of this disclosure. In this disclosure, the singular form includes the plural form unless specifically stated otherwise in the text.

[0040] Additionally, terms such as first, second, A, B, (a), (b), etc., may be used to describe the components of the embodiments of the present disclosure. These terms are intended only to distinguish the components from other components and do not limit the nature, order, or sequence of the components. Where it is stated that a component is "connected," "coupled," or "joined" to another component, it should be understood that the component may be directly connected or joined to the other component, but that another component may also be "connected," "coupled," or "joined" between each component.

[0041] First, the definitions of specific words used in the present disclosure will be explained.

[0042] The widget of the present disclosure refers to a basic component related to the configuration of a UI in a Graphic User Interface (GUI) system. For example, widgets may be provided in various forms, such as buttons, text boxes, and sliders. Furthermore, widgets may include not only components that are directly displayed in the UI, but also components related to the placement of such components. For example, widgets for centering UI elements, widgets for vertical placement, and widgets for setting detailed positions may also be included in the widgets of the present disclosure.

[0043] The tree structure of the widgets in the present disclosure refers to a structure in which widgets are arranged hierarchically in a GUI system. Each widget may have a parent widget and child widgets, and the parent widget may be displayed on the screen including the child widgets. Through the tree structure of the widgets, UI components are interconnected, and when an event related to a UI component occurs, it may operate in a manner where it is transmitted between widgets. For example, if an error occurs in a child widget, information that such an error has occurred may be transmitted to the parent widget.

[0044] The user of the present disclosure may refer to a person who checks information related to the delivery of a product using an application installed on a user terminal. For example, the user may be a delivery person responsible for the delivery of a product.

[0045] The administrator of the present disclosure may refer to a person who checks for errors related to the UI of an application installed on a user terminal through an administrator terminal. For example, the administrator may be a person who develops and manages an application.

[0046] Hereinafter, the components of the present disclosure and the method of the present disclosure will be described with reference to the drawings. First, FIG. 1 is a configuration diagram showing the configuration of a UI error display system according to some embodiments of the present disclosure, and FIG. 2 and FIG. 3 are example diagrams specifically showing the UI error display system described with reference to FIG. 1.

[0047] As illustrated in FIG. 1, the UI error display system may include at least one of a user terminal (100), a UI error management system (200), and an administrator terminal (300). Additionally, the UI error management system may include at least one component among a communication unit (201), an analysis unit (202), a generation unit (203), and a processing unit (204). Additionally, the UI error management system (200) may be included in the administrator terminal (300). Additionally, the UI error management system (200) may be included in some of the administrator terminals among a plurality of administrator terminals (300). Each component may communicate with each other via a wired or wireless network.

[0048] The user terminal (100) of the present disclosure refers to a computing device used by a user to use an application that displays information related to product delivery. For example, the user terminal (100) may be a computer, laptop, smartphone, etc. used by the user. Although only one user terminal is shown in FIG. 1 for convenience of explanation, the user terminal may be one or more computing devices used by at least one user.

[0049] For example, as illustrated in FIG. 2, the user terminal may be a plurality of user terminals. Additionally, an error related to the application UI may occur in one of the plurality of user terminals (100). The error may occur in a first widget (101) displayed in the application of the user terminal (100). An error may not occur in a second widget (102) displayed in the application of the user terminal (100). That is, an error related to the application UI may mean that an error occurs in one of the multiple widgets displayed in the application.

[0050] The UI error management system (200) of the present disclosure refers to a system for detecting errors in an application installed on a user terminal, analyzing errors, and dealing with errors using error-related information received from a user terminal. In addition, the UI error management system (200) may include at least one component among a communication unit (201), an analysis unit (202), a generation unit (203), and a processing unit (204) to perform the above-described functions.

[0051] The communication unit (201) of the present disclosure can perform all acts of exchanging information or data with the user terminal (100) and the administrator terminal (300).

[0052] For example, the communication unit (201) can transmit data to perform an update of the application, which is an application installed on the user terminal (100). Additionally, the communication unit (201) can receive a signal from the user terminal (100) indicating that an error related to a widget has occurred in the application, or information related to such an error. Additionally, the communication unit (201) can transmit a signal to monitor the application and receive information related to the error from the user terminal (100). Furthermore, the communication unit (201) can transmit a signal to rollback the application update or data to perform a new update in response to the error.

[0053] As another example, the communication unit (201) may transmit an error related to an update or information related to such error to the administrator terminal (300) to display the error related to the update on the administrator terminal (300). Additionally, the communication unit (201) may transmit a signal to the administrator terminal (300) to display a notification regarding the error related to the update. Furthermore, the communication unit (201) may receive information or a signal related to the processing of the update from the administrator terminal (300).

[0054] The analysis unit (202) of the present disclosure can perform operations necessary to generate information to be displayed on the administrator terminal (300) using information related to errors obtained from the user terminal (100).

[0055] For example, the analysis unit (202) can filter whether an error related to the UI of an application installed on a user terminal is an error related to an application update. Additionally, the analysis unit (202) can generate information to be displayed on an administrator terminal using information related to the error. Specifically, using information that an error related to an update occurred from multiple user terminals, it can generate information related to the ratio of user terminals where an error occurred among all user terminals. Additionally, the analysis unit (202) can generate information regarding the parts where errors occur in the data for performing the update.

[0056] The generating unit (203) of the present disclosure can generate a screen that is displayed on the administrator terminal (300) and displays information related to an error. For example, the generating unit (203) can generate each widget of the screen displayed on the administrator terminal (300) (e.g., a widget indicating the type of error that occurred, a widget displaying information about an update related to the error that occurred, a widget displaying a graph related to the error).

[0057] The processing unit of the present disclosure can process errors that occur in an application installed on a user terminal. Here, processing an error means disabling, removing, or changing functions related to the error that occurred in the application. Additionally, the processing unit can process errors that occur in an application installed on the user terminal by using a signal received from an administrator or data for performing a new update.

[0058] For example, the processing unit can automatically roll back the application update if an error related to the update occurs and additional pre-set conditions are satisfied. Additionally, if an error related to the update occurs and additional pre-set conditions are satisfied, the processing unit can automatically disable the error-related function by changing the state of the Feature Flag of the function related to the application error to OFF. Here, a Feature Flag refers to a technology that can dynamically control whether a specific function or code of the software is executed after the software is deployed. If the state of the Feature Flag is ON, the function is enabled, and if the state of the Feature Flag is OFF, the function can be disabled.

[0059] The administrator terminal (300) of the present disclosure refers to a computing device that provides functions for managing applications installed on a user terminal (e.g., application updates, application error display, update rollback, activation and deactivation of specific functions). For example, the administrator terminal (300) may be a computer, laptop, smartphone, etc. used by an administrator. Although only one administrator terminal is shown in FIG. 1 for convenience of explanation, the administrator terminal may be one or more computing devices used by at least one administrator.

[0060] For example, as illustrated in FIG. 3, the administrator terminal can be a computer (301) and error-related information can be displayed comprehensively. Additionally, the administrator terminal can be a smartphone (302) and error-related information can be displayed comprehensively.

[0061] It should be noted that the operations that a component of a UI error display system according to one embodiment of the present disclosure can perform are not limited to the examples described above.

[0062] Up to now, components of a UI error display system according to one embodiment of the present disclosure have been described with reference to FIGS. 1 to 3. Technical concepts that can be understood through some embodiments of the present disclosure to be described below can be applied to the UI error display system described above without separate description. Hereinafter, a UI error display method according to another embodiment of the present disclosure will be described with reference to FIGS. 4 to 9.

[0063] Meanwhile, the UI error display method according to the present embodiment may be performed by one or more computing devices. For example, the UI error display method may be generated by two or more computing devices. Some methods included in the UI error display method may be performed by a first computing device, and the remaining methods included in the UI error display method may be performed by a second computing device. For example, the computing device may be the UI error display system described with reference to FIG. 1. In the following description, the subject of a specific step / operation may be omitted, and in this case, it may be understood that the corresponding step / operation is performed by a computing device.

[0064] In addition, it should be noted that the embodiments related to the UI error display system described with reference to FIGS. 1 to 3 can naturally be applied to the UI error display method according to the present embodiment without separate mention.

[0065] FIG. 4 is a flowchart exemplarily illustrating a method for displaying UI errors according to the present embodiment.

[0066] As illustrated in FIG. 4, data for performing an update may first be transmitted to an application on a user terminal (S100). For example, the application may be an application that displays information related to the delivery of a product. Additionally, the update of the application may be an update that displays the phone number of the customer who ordered the product only on the delivery date.

[0067] Next, an error regarding the widget can be detected by utilizing the tree structure of the widget displayed in the application (S200). For example, the phone number of a customer who ordered a product may not be displayed on the application. Additionally, the widget displaying the customer's phone number can use the tree structure to transmit to the parent widget that the customer's phone number is not displayed. The parent widget can recognize the fact that the customer's phone number is not displayed as an error and transmit it to the UI error management system. Additionally, the UI error management system can transmit a signal to the user terminal to check whether an error has occurred, and in response to such a signal, the application on the user terminal can generate a signal indicating that an error has occurred in which the customer's phone number is not displayed. The user terminal can transmit a signal indicating that an error has occurred to the UI error management system. That is, the detection of an error may mean the case where the UI error management system receives a signal indicating that an error has occurred.

[0068] Next, errors can be filtered to determine whether they are related to data for performing an update (hereinafter referred to as update data) (S300). Here, filtering means filtering only errors related to update data among errors related to update data and errors not related to update data.

[0069] For example, an update may be performed on an application to display the phone number of a customer who ordered a product only on the product's delivery date. If the application incorrectly recognizes the delivery date and the customer's phone number is not displayed, it can be said that an error related to the update data has occurred. On the other hand, if the customer who ordered the product simply did not enter their number and the customer's phone number is not displayed, it can be said that an error unrelated to the update data has occurred. In such cases, the error caused by the customer not entering a phone number cannot pass through filtering, whereas the error caused by the application incorrectly recognizing the delivery date and the customer's phone number not being displayed can pass through filtering.

[0070] Next, information related to filtered errors may be displayed on the administrator terminal (S400). Here, the information related to the error may include the type of error, updates related to the error, functions related to the error, the ID of the user terminal where the error occurred, the number of user terminals where the error occurred, the ratio of user terminals where the error occurred, whether product delivery was delayed at the user terminal where the error occurred, the ratio of user terminals where product delivery was delayed due to the error, and the geographical location of the user terminal where the error occurred. That is, the information related to the error may include not only the raw data related to the error transmitted from the user terminal, but also all data processed from such raw data.

[0071] In one embodiment, information related to errors may be displayed on an administrator terminal in the form of a dashboard. Here, a dashboard refers to an interface organized to allow various data to be visually grasped at a glance. For example, as illustrated in FIG. 3, the administrator terminal may comprehensively display information related to errors on a single screen. Specifically, along with the type of error, the number of user terminals where the error occurred may be displayed as a graph. Additionally, the location of the user terminal where the error occurred may be displayed in the form of a map. Furthermore, the rate of product delivery delays caused by the error may be displayed as a graph. Additionally, information regarding update data related to the error may be displayed in the form of a table.

[0072] In one embodiment, information regarding errors determined to be related to an update may be displayed first on the administrator terminal, and information regarding errors determined not to be related to an update may be displayed later on the administrator terminal. For example, on the first screen after an application displaying error information is executed, a screen regarding errors determined to be related to an update may be displayed. Subsequently, after a preset time has elapsed, a screen regarding errors determined not to be related to an update may be displayed. As another example, after a screen regarding errors determined to be related to an update is displayed, a screen regarding errors determined not to be related to an update may be displayed by a preset administrator action.

[0073] Next, in response to filtering for errors, the update of the application on the user terminal may be rolled back (S500). Here, rolling back the update may include cases where the update is automatically rolled back by the UI error management system when a pre-set condition is satisfied. For example, if an error related to update data occurs in 80% or more of the updated user terminals, the UI error management system may automatically roll back the update for all updated user terminals.

[0074] This UI error display method automatically detects UI errors in real time and can quickly analyze whether the error is related to an update. Therefore, when an error occurs, the method can immediately provide administrators with information related to the error, enabling them to quickly recognize and respond to the problem. As a result, UI errors can be resolved proactively before a large number of users experience inconvenience. In other words, the user experience is significantly improved, and user trust in the application can be maintained.

[0075] Meanwhile, the process of continuously monitoring UI errors can consume significant computational resources of the user terminal and the UI error management system. Therefore, an efficient technology is required to prevent performance degradation or resource waste of the user terminal and the UI error management system. Below, with reference to FIGS. 5 and 6, a specific example of step S200 of the UI error display method will be described.

[0076] FIG. 5 is a flowchart exemplarily illustrating step S200 of the UI error display method described with reference to FIG. 4. As illustrated in FIG. 5, the step (S200) of detecting an error for a first widget may include the following steps.

[0077] First, the application can be monitored for a preset period starting from the transmission of update data (S210). Here, monitoring of the application may refer to the process of checking the status of the application at regular time intervals and exchanging signals to detect errors or abnormal behavior. Next, an error regarding the first widget can be detected for a preset period (S220).

[0078] In one embodiment, the monitoring period may differ for each widget displayed in the application. Specifically, a first widget may be monitored during a first monitoring period, and a second widget may be monitored during a second monitoring period. For example, widgets whose state can change through interaction with a user (e.g., checkbox, switch, text field, slider) may be monitored for a long period after an update, while widgets whose state cannot be changed (e.g., text, icon, image) may be monitored for a short period after an update.

[0079] This embodiment enables efficient management of resources for user terminals or UI error management systems by performing monitoring for different periods depending on the characteristics and importance of each widget. In other words, it prevents unnecessary resource waste and allows for the effective detection of UI errors with minimal resources. Consequently, this embodiment can achieve overall resource optimization by performing intensive monitoring on important UI elements and intermittent monitoring on less important elements.

[0080] In one embodiment, only the applications of some user terminals may be monitored. Specifically, among the user terminals that received update data, the applications of pre-configured user terminals may be monitored. Subsequently, if an error is detected as a result of the monitoring and processing of an update related to the error is determined, the processing of the update may be applied to all user terminals that received update data.

[0081] For example, as illustrated in 6, among the updated user terminals, the application of the first user terminal (110) may perform monitoring, while the application of the second user terminal (120) may not perform monitoring. Here, the first user terminal may be a user terminal with insufficient computing power, and the second user terminal may be a user terminal with sufficient computing power. Additionally, the first user terminal may be a user terminal located in a geographical location related to the updated function, and the second user terminal may be a user terminal located in a geographical location unrelated to the updated function.

[0082] These embodiments allow for more effective detection of problematic errors that may occur in user terminals by conducting monitoring while considering the characteristics of the user terminal. As a result, the user terminal or UI error management system can quickly and accurately identify UI errors while minimizing resources for UI error display methods.

[0083] Meanwhile, not all errors occurring in widgets prevent the user, or the delivery person, from proceeding with product delivery. It may be more efficient to promptly handle only errors directly related to delivery. Therefore, referring to Fig. 7, we will explain the critical UI errors that require priority attention. Since these errors have a substantial impact on the delivery process, a rapid response may be necessary.

[0084] FIG. 7 is an exemplary illustration showing an error that can be detected by a UI error display system according to some embodiments of the present disclosure. FIG. 7 shows a normal display screen (100a) of an application and a screen (100b) of an application where an error has occurred.

[0085] In one embodiment, detecting an error regarding a widget may involve detecting an error where information contained in the widget is not displayed on the user terminal. Here, not being displayed on the user terminal may mean that the widget is displayed, but all or part of the data containing the widget is not displayed.

[0086] For example, as illustrated in FIG. 7, the first widget may be a widget that displays the requests of a customer who has ordered a product. Here, the first widget that is displayed normally may display the customer's requests exactly as they are (101a). Conversely, in the case of the first widget that has an error, the first widget may be displayed on the user terminal, but the specific customer requests may not be displayed on the user terminal (102a). In the event of such an error, the delivery person may not be able to recognize the customer's requests, and problems may occur during the product delivery process.

[0087] As another example, as illustrated in FIG. 7, the first widget may be a widget that displays the method of entry and exit to the delivery location. Here, the first widget that is normally displayed may display the common entrance password as the method of entry and exit when the user terminal is located near the delivery address (103a). Conversely, in the case of the first widget that has an error, the location of the user terminal is not confirmed, so the common entrance password may not be displayed even if the user terminal is located near the delivery address (103b). In the event of such an error, the delivery person may not be able to recognize the method of entry and exit, and a delay in product delivery may occur.

[0088] In one embodiment, detecting an error for a widget may involve detecting an error where text or an image displayed on the widget exceeds the screen of the user terminal.

[0089] For example, as illustrated in FIG. 7, the first widget may be a widget that displays the shipping address of a product. Here, the first widget that is displayed normally may display the shipping address text with line breaks (104a). Conversely, the first widget that has an error may display only a part of the shipping address because line breaks are not applied to the shipping address text (104b). If such an error occurs, the delivery person may be unable to verify the shipping address, and thus the delivery of the product may be delayed.

[0090] In one embodiment, detecting an error regarding a widget may involve detecting an error where the widget is not displayed on the screen of a user terminal. Here, the error where the widget is not displayed on the screen of a user terminal may refer to an error where all or part of the widget that should be displayed in the application of the user terminal is not displayed on the user terminal.

[0091] For example, as illustrated in FIG. 7, the first widget may be a widget that displays a customer's phone number when delivery is impossible. Here, the first widget that is normally displayed may display the customer's phone number only when delivery is impossible (105a). Conversely, in the case of the first widget that has an error, the first widget itself may not be displayed due to a conflict between widgets caused by an application update (105b).

[0092] It should be noted that errors regarding the widgets of the present disclosure are not limited to the examples described above. Errors regarding the widgets may include all errors related to the widgets displayed in the application.

[0093] On the other hand, not all errors related to widgets are update-related. Update-related errors can be properly addressed by rolling back the update or performing a new update. Therefore, technology to filter update-related errors is required. Below, I will explain the filtering of update-related errors.

[0094] In one embodiment, the step of filtering whether an error is related to update data (hereinafter referred to as the filtering step) may be a step of determining whether an error regarding a widget is an error related to update data by using the time when the widget is rendered to a user terminal.

[0095] Specifically, filtering using the time it takes for a widget to be rendered on a user terminal may involve measuring the time it takes for a widget to be rendered on a user terminal and determining that if the rendering time exceeds a threshold, it is an error related to an update.

[0096] For example, as illustrated in FIG. 7, the first widget may be a widget that displays a customer's request (101a). Here, an error with the widget may be that the first widget is displayed, but the specific text of the customer's request (e.g., please place it in front of the door) is not displayed (101b).

[0097] These errors can occur due to two types of causes. First, the customer may not have entered a request, so the customer's request text may not be displayed. In this case, the time it takes for the widget to render may not differ significantly from the normal case (101a). Second, the customer may have entered a request, but the customer's request text may not be displayed because the widget tree associated with the first widget is excessively large. In this case, the time it takes for the widget itself to render may also differ significantly from the normal case (101a). Therefore, the error regarding the detected widget, along with the time it takes for the widget to render, can be used to filter whether the error is related to an update.

[0098] In one embodiment, the filtering step may be a step of determining whether an error for a widget is an error related to update data using the network traffic of the application.

[0099] Specifically, filtering using the application's network traffic may involve measuring the application's network traffic and determining that if the application's network traffic exceeds a threshold, it is an error related to an update.

[0100] For example, the first widget may be a widget that displays a map image representing a delivery address. An error regarding the widget may be an error where the map image representing the delivery address does not appear (hereinafter referred to as an image error). The image error may occur due to unstable network conditions, regardless of the application update. Through filtering, such an image error may be determined not to be an error related to the update.

[0101] Additionally, image errors may occur when the map image representing the delivery address is not displayed because the route settings are incorrect due to an application update. Such image errors can be determined as update-related errors through filtering.

[0102] Network traffic may be the distinguishing factor between the two cases. For example, if an image is not displayed due to a routing error, the application may continuously send image load requests. Furthermore, these continuous image load requests can lead to an abnormal increase in network traffic. On the other hand, if the image is not displayed due to network instability, the application may not continuously send image load requests. In other words, network traffic increases abnormally in the case of errors related to updates, whereas it may not increase abnormally in the case of errors unrelated to updates.

[0103] Therefore, by detecting errors in the widget and measuring network traffic, it is possible to filter whether the error is related to an update.

[0104] In one embodiment, the filtering step may be a step of determining whether an error regarding a widget is an error related to update data using the battery usage of the user terminal.

[0105] Specifically, filtering using the battery usage of a user terminal may involve measuring the battery usage of the user terminal and determining that an error related to an update occurs if the application's network traffic exceeds a threshold value.

[0106] For example, as illustrated in FIG. 7, the first widget may be a widget that displays customer information. An error regarding the widget may be an error where the first widget itself is not displayed.

[0107] This error may occur when the information displayed on the first widget is incorrectly configured due to an update, causing an excessive amount of information to attempt to be displayed and the first widget to fail to display properly. Additionally, in this situation, as an excessive amount of information attempts to be displayed, the user terminal may also perform an excessive amount of computation. Furthermore, as an excessive amount of computation is performed, the battery usage of the user terminal may increase significantly compared to the normal case (105a). In other words, the battery usage of the user terminal may increase due to an error related to the update.

[0108] Meanwhile, this error may occur when the widget is not rendered due to insufficient memory of the user terminal, regardless of the update. Additionally, in this situation, since the user terminal does not perform additional calculations, the battery usage of the user terminal may not increase significantly compared to the normal case (105a).

[0109] Therefore, by detecting errors regarding the widget and measuring the battery usage of the user terminal, it is possible to filter whether the error is related to an update.

[0110] In one embodiment, the filtering step may be a step of determining whether an error for a widget is an error related to update data by using the number or ratio of user terminals where an error occurred.

[0111] Specifically, the filtering step may include a step of checking the number of user terminals with errors among user terminals with the updated application installed, and a step of determining that if the number of user terminals with errors exceeds a threshold, the error regarding the widget is an error related to the update data.

[0112] For example, errors related to widgets may occur depending on the performance of the user terminal (e.g., processing speed, memory capacity). If errors related to widgets occur only on some user terminals with very low performance, the errors may not be determined to be caused by an update. On the other hand, if errors related to widgets occur on a pre-configured ratio or a pre-configured number of user terminals regardless of performance, the errors related to widgets may be determined to be caused by an update.

[0113] Therefore, in addition to detecting errors regarding the widget, by measuring the number of user terminals where errors regarding the widget occurred, it is possible to filter whether the error is related to an update.

[0114] Up to this point, the step of filtering errors for a widget has been described. It should be noted that the filtering step of the present disclosure is not limited to the examples described above. Furthermore, errors for a widget may be filtered by using multiple factors in combination, rather than just one of the factors measured in the examples described above (e.g., widget rendering time, application network traffic, user terminal battery usage).

[0115] A UI error display method including these filtering steps enables administrators to respond quickly to errors by prioritizing the display of errors that can be promptly addressed through update rollbacks or new updates.

[0116] Meanwhile, even if an error regarding a widget is displayed on the administrator terminal in the form of a dashboard, the administrator may not be aware of the error until they check the dashboard. Therefore, there is a need for a technology that notifies the administrator that an error regarding the widget has occurred before they check the dashboard. Below, with reference to FIG. 8, a UI error display method that delivers a notification when an error regarding a widget occurs will be explained.

[0117] In one embodiment, the step of displaying information related to filtered errors on an administrator terminal may further include the step of transmitting a notification regarding the filtered errors to the administrator terminal. Here, the notification regarding the errors may include all forms of notifications that an administrator can perceive through the administrator terminal.

[0118] For example, as illustrated in FIG. 8, a notification of an error (311) can be displayed on the administrator terminal (303) via a messenger and delivered to the administrator. Additionally, a notification of an error (312) can be displayed on the administrator terminal (304) and delivered to the administrator via a smartphone lock screen preview. Furthermore, the notification of an error may include some information about the error (e.g., type of error, time the error occurred, update related to the error).

[0119] Through these notifications, administrators can quickly identify errors in the widgets. Furthermore, administrators can respond rapidly to such errors. Additionally, administrators can efficiently resolve errors by receiving priority access to important information related to the error (e.g., type of error, time of occurrence, related updates).

[0120] Meanwhile, the method for resolving errors regarding widgets is not necessarily limited to rolling back the update. Rolling back the entire update can be inefficient, as it reverts even error-free functions or widgets to a previous state. Additionally, rolling back the entire update can take a long time. Therefore, with reference to FIG. 9, I will explain other solutions that can be used in addition to rolling back the update. However, regarding the UI error display method that includes processing methods other than rolling back the update, I will focus on the differences from FIG. 4.

[0121] First, after information related to filtered errors is displayed on the administrator terminal (S400), processing for the update can be received from the administrator terminal (S600). Here, processing for the update may include whether to roll back the entire update, roll back only some updates related to the error, or perform a new update. Additionally, rollback may mean changing the application to the same state as before the update. Furthermore, rollback may mean disabling certain functions or widgets to return the application to the same state as before the update.

[0122] For example, an administrator can view information related to errors displayed on the administrator terminal (e.g., some widgets not displayed) and input data to perform a new update (e.g., removing undisplayed widgets).

[0123] Next, processing for the received update can be applied to the user terminal (S700). Here, applying processing for the update to the user terminal may include transmitting a signal to change the application to a state prior to the update, transmitting a signal to disable some functions of the application, and transmitting data to perform a new update to the application.

[0124] For example, if an administrator inputs data to perform a new update, the UI error management system can transmit the data to perform the new update to the user terminal. Subsequently, the user terminal can use the received data to update the application (e.g., remove a non-displayable widget).

[0125] In one embodiment, the processing for the update may be a process that rolls back only the update for the widget where a filtered error occurred. For example, in an application on a user terminal, an update was performed to include a function that displays the main entrance password only when the user is close to the delivery address, but an error may occur with respect to the widget that displays the main entrance password. In such a case, the UI error management system may send a signal to the user terminal to roll back only the function that displays the main entrance password when the user is close to the delivery address.

[0126] In one embodiment, the step of receiving processing for an update may be a step of receiving data for performing a new update. Additionally, the step of applying processing for an update to a user terminal may be a step of transmitting data for performing a new update to an application on the user terminal.

[0127] So far, the step of applying update processing among the UI error display methods has been specifically explained. It should be noted that update processing is not limited to the examples described above. Furthermore, update processing may not only be applied uniformly to all user terminals but may also be applied differently for each user terminal. For example, first update processing may be applied to applications on at least one first user terminal, and second update processing may be applied to applications on at least one second user terminal.

[0128] In addition, the UI error management system can roll back application updates and subsequently perform new updates by receiving data from the administrator. Furthermore, the UI error management system can roll back all application updates and subsequently apply updates only to parts of the application unrelated to errors by receiving data from the administrator.

[0129] In addition, some functions or widgets related to the aforementioned error may include not only the function or widget where the error occurred, but also functions or widgets for which an additional error may occur if rolled back to such function or widget.

[0130] A UI error display method and a system according to several embodiments of the present disclosure have been described so far. Such a UI error display method can rapidly detect errors, rapidly analyze whether the error is related to an update, and improve the speed of response to the error.

[0131] In other words, through the UI error display method according to the embodiment of the present disclosure, the mean time to detect (MTD), which represents the average time elapsed from the point at which system performance degradation occurs until the moment the failure is recognized, and the mean time to repair (MTTR), which represents the average time required to restore the system to a normal operating state, can be reduced. Furthermore, the UI error display method can help an administrator quickly identify and respond to errors by comprehensively displaying information regarding errors to the administrator. Additionally, the UI error display method can prioritize the resolution of errors related to product delivery by monitoring only some user terminals and filtering only specific errors. Consequently, the UI error display method can prevent delays in the user's work process by enabling the resolution of UI errors before a large number of users experience inconvenience due to the errors.

[0132] The effects according to the technical concept of the present disclosure are not limited to those mentioned above, and other unmentioned effects will be clearly understood by a person skilled in the art from the content of the present disclosure.

[0133] Hereinafter, the hardware configuration of an exemplary computing device according to some embodiments of the present disclosure will be described with reference to FIG. 10. The computing device may be a user terminal (100), a UI error management system (200), or an administrator terminal (300) as described with reference to FIG. 1.

[0134] A computing device (1000) according to the present embodiment may include one or more processors (1100), a system bus (1600), a communication interface (1200), a memory (1400) for loading a computer program (1500) executed by the processor (1100), and a storage (1300) for storing the computer program (1500). Only components related to the embodiments of the present disclosure are illustrated in FIG. 10.

[0135] The processor (1100) controls the overall operation of each component of the computing device (1000). The processor (1100) may be configured to include at least one of a CPU (Central Processing Unit), MPU (Micro Processor Unit), MCU (Micro Controller Unit), GPU (Graphic Processing Unit), or any form of processor well known in the art of the present disclosure. Additionally, the processor (1100) may perform operations for at least one application or program for executing a method / operation according to various embodiments of the present disclosure. The computing device (1000) may have two or more processors.

[0136] The memory (1400) stores various contents, commands and / or information. The memory (1400) may load one or more programs (1500) from the storage (1300) to execute methods / operations according to various embodiments of the present disclosure. An example of the memory (1400) may be RAM, but is not limited thereto. The system bus (1600) provides communication functions between components of the computing device (1000).

[0137] The system bus (1600) can be implemented as various types of buses, such as an address bus, a data bus, and a control bus. The communication interface (1200) supports wired and wireless internet communication of the computing device (1000). The communication interface (1200) may also support various communication methods other than internet communication. To this end, the communication interface (1200) may be configured to include a communication module well known in the art of the present disclosure. The storage (1300) may store one or more computer programs (1500) non-temporarily. The storage (1300) may be configured to include non-volatile memory such as flash memory, a hard disk, a removable disk, or any type of computer-readable recording medium well known in the art to which the present disclosure belongs.

[0138] A computer program (1500) may include one or more instructions in which methods / operations according to various embodiments of the present disclosure are implemented. When the computer program (1500) is loaded into memory (1400), a processor (1100) may perform methods / operations according to various embodiments of the present disclosure by executing the one or more instructions.

[0139] A computer program (1500) may include instructions for performing steps such as transmitting first data to perform a first update to an application of a user terminal, detecting an error in the first widget using a tree structure of the first widget displayed in the application, filtering whether the error is related to the first data, and displaying information related to the filtered error on the screen of an administrator terminal.

[0140] Although operations are depicted in a specific order in the drawings of this disclosure, it should not be understood that the operations must necessarily be executed in the specific order depicted or in a sequential order, or that all depicted operations must be executed to obtain the desired result. In certain situations, multitasking and parallel processing may be advantageous. Furthermore, the separation of the various configurations in the embodiments described above should not be understood as necessarily required, and it should be understood that the described program components and systems can generally be integrated together into a single software product or packaged into multiple software products.

[0141] Although embodiments of this specification have been described above with reference to the attached drawings, those skilled in the art will understand that the embodiments of this specification may be implemented in other specific forms without altering the technical concept or essential features thereof. Therefore, the embodiments described above should be understood as illustrative in all respects and not restrictive. The scope of protection of this disclosure shall be interpreted by the claims below, and all technical concepts within the equivalent scope shall be interpreted as being included within the scope of rights of the technical concepts defined by this disclosure.

[0142] [Explanation of the symbol]

[0143] 100: User terminal

[0144] 101, 101a, 101b, 102, 102a, 102b, 103a, 103b, 104a, 104b, 105a, 105b: Widgets displayed in applications on the user terminal

[0145] 200: UI Error Management System

[0146] 201: Communications Department

[0147] 202: Analysis Department

[0148] 203: Generation section

[0149] 204: Processing unit

[0150] 300: Administrator Terminal

[0151] 301, 302, 303, 304: Administrator terminal screen

[0152] 311, 312: Widgets displayed on the administrator terminal

[0153] 1000: Computing device

[0154] 1100: Processor

[0155] 1200: Communication interface

[0156] 1300: Memory

[0157] 1400: Storage

[0158] 1500: Computer program

[0159] S100, S200, S210, S220, S300, S400, S500, S600, S700: Step

Claims

1. In a method performed by a computing device, A step of transmitting first data to perform a first update to an application of a user terminal; A step of detecting an error regarding the first widget using the tree structure of the first widget displayed in the application; A step of filtering whether the above error is related to the first data; and A step including displaying information related to the above-mentioned filtered errors on an administrator terminal, How to display UI errors.

2. In Paragraph 1, The step of detecting an error regarding the first widget is, A step of monitoring the application for a preset time starting from the transmission of the first data; and A step comprising detecting an error for the first widget during the aforementioned preset time, How to display UI errors.

3. In Paragraph 2, The step of monitoring the above application is, A step of monitoring the first widget during a first monitoring period; and During the second monitoring period, the step of monitoring the second widget is included, The second widget is displayed in the application and is a widget different from the first widget, How to display UI errors.

4. In Paragraph 2, The step of monitoring the above application is, The step of monitoring the application of a user terminal that has been configured among the user terminals that received the first data, and A method further comprising the step of applying the processing for the first update to all user terminals that have received the first data. How to display UI errors.

5. In Paragraph 1, The step of detecting an error regarding the first widget is, A step of detecting an error in which text or an image displayed on the first widget exceeds the screen of the user terminal, How to display UI errors.

6. In Paragraph 1, The step of detecting an error regarding the first widget is, A step of detecting an error in which the first widget is not displayed on the user terminal, How to display UI errors.

7. In Paragraph 1, The step of detecting an error regarding the first widget is, A step of detecting an error in which information included in the first widget is not displayed on the user terminal, How to display UI errors.

8. In Paragraph 1, The above filtering step is, A step comprising determining an error for the first widget as an error related to the first data by utilizing the time at which the first widget is rendered on the user terminal, How to display UI errors.

9. In Paragraph 1, The above filtering step is, A step comprising determining an error for the first widget as an error related to the first data using network traffic of the above application, How to display UI errors.

10. In Paragraph 1, The above filtering step is, A step comprising determining an error for the first widget as an error related to the first data using the battery usage of the user terminal, How to display UI errors.

11. In Paragraph 1, The above filtering step is, A step of checking the number of user terminals where the above error occurred; If the number of user terminals where the above error occurred exceeds a threshold value, the step of determining the error for the first widget as an error related to the first data is included. How to display UI errors.

12. In Paragraph 1, The step of displaying on the first screen above is, A method further comprising the step of transmitting a notification of the filtered error to the administrator terminal. How to display UI errors.

13. In Paragraph 1, A method further comprising the step of automatically rolling back the first update of the application in response to filtering for the above error. How to display UI errors.

14. In Paragraph 1, A step of receiving processing for the first update from the administrator terminal in response to the display of the first screen regarding the above error; and A method comprising the step of applying processing for the first update to the user terminal. How to display UI errors.

15. In Paragraph 14, The processing for the above first update is, A process that rolls back only the update for the first widget above, How to display UI errors.

16. In Paragraph 14, The step of receiving input for processing the above-mentioned first update is, The step of receiving second data to perform a second update of the above application, and The step of applying the processing for the first update above to the user terminal is, The step of transmitting second data to the above application, UI error display device.

17. One or more processors; and It includes memory for storing computer programs executed by one or more of the above processors, and The above computer program causes the processor, A step of transmitting first data to perform a first update to an application of a user terminal; A step of detecting an error regarding the first widget using the tree structure of the first widget of the user terminal; A step of filtering whether the above error is related to the first data; and Instructions including the step of displaying information related to the filtered error above on the screen of the administrator terminal. UI error display system.

Images