Application starting control method, application starting display method, device and equipment

Abstract

The invention relates to an application starting control method, an application starting display method, an application starting display device, computer equipment, a computer readable storage medium and a computer program product, which can be applied to various scenes such as cloud technology, artificial intelligence, intelligent traffic and auxiliary driving. The application starting control method comprises the following steps: in response to an application starting event triggered for a target application, creating an original context object of the target application, and determining a system permission expected to be obtained by the target application in a starting process; if the system permission is in an unauthorized state, calling variable information of the original context object, and constructing a proxy context object corresponding to the original context object; loading an authorization request page for the system permission based on the proxy context object; and in response to an authorization operation triggered on the authorization request page, executing a starting task of the target application based on the original context object. By adopting the method, the safety can be improved.

Description

Technical Field

[0001] The present application relates to the field of computer technologies, and particularly to an application startup control method, an application startup display method, an apparatus, a computer device, a computer-readable storage medium, and a computer program product. Background Art

[0002] With the continuous development of computer technologies, various application programs with rich functions have emerged, bringing a lot of convenience to people's lives. Users can install application programs on computer devices and enjoy the functions provided by the application programs when starting them.

[0003] In traditional technologies, a computer device first creates a context object for an application program, and then completes initialization by calling the onCreate function in the context object to implement the startup task of the application program. Since system permissions may be called during the initialization process, compliance risks are brought. Therefore, there is a problem of poor security when using traditional technologies. Summary of the Invention

[0004] Based on this, it is necessary to provide an application startup control method, an application startup display method, an apparatus, a computer device, a computer-readable storage medium, and a computer program product that can improve security for the above technical problems.

[0005] In a first aspect, the present application provides an application startup control method. The method includes:

[0006] In response to an application startup event triggered for a target application, create an original context object of the target application and determine system permissions expected to be obtained by the target application during startup;

[0007] If the system permissions are in an unauthorized state, call variable information of the original context object to construct a proxy context object corresponding to the original context object;

[0008] Based on the proxy context object, load an authorization request page for the system permissions;

[0009] In response to an authorization operation triggered on the authorization request page, execute the startup task of the target application based on the original context object.

[0010] In a second aspect, the present application further provides an application startup display method. The method includes:

[0011] Display application elements of a target application;

[0012] In response to an application start event triggered for the application element, display an authorization request page for the system permissions expected to be obtained by the target application during the startup process; the authorization request page is loaded based on a proxy context object; the proxy context object is constructed by calling the variable information of the original context object of the target application when the system permissions are in an unauthorized state.

[0013] In response to an authorization operation triggered on the authorization request page, display the main page of the target application; the main page is displayed when the startup task of the target application is completed based on the original context object.

[0014] In a third aspect, the present application also provides an application startup control device. The device includes:

[0015] A system permission determination module, configured to create an original context object of the target application in response to an application start event triggered for the target application, and determine the system permissions expected to be obtained by the target application during the startup process;

[0016] A proxy construction module, configured to, if the system permissions are in an unauthorized state, call the variable information of the original context object to construct a proxy context object corresponding to the original context object;

[0017] An authorization request page loading module, configured to load an authorization request page for the system permissions based on the proxy context object;

[0018] A startup task execution module, configured to execute the startup task of the target application based on the original context object in response to an authorization operation triggered on the authorization request page.

[0019] In a fourth aspect, the present application also provides an application startup display device. The device includes:

[0020] An application element display module, configured to display the application elements of the target application;

[0021] An authorization request page display module, configured to display an authorization request page for the system permissions expected to be obtained by the target application during the startup process in response to an application start event triggered for the application element; the authorization request page is loaded based on a proxy context object; the proxy context object is constructed by calling the variable information of the original context object of the target application when the system permissions are in an unauthorized state.

[0022] A main page display module, configured to display the main page of the target application in response to an authorization operation triggered on the authorization request page; the main page is displayed when the startup task of the target application is completed based on the original context object.

[0023] In a fifth aspect, the present application also provides a computer device. The computer device includes a memory and a processor. The memory stores a computer program, and when the processor executes the computer program, the steps of the above method are implemented.

[0024] In a sixth aspect, the present application also provides a computer-readable storage medium. The computer-readable storage medium stores a computer program thereon, and when the computer program is executed by a processor, the steps of the above method are implemented.

[0025] In a seventh aspect, the present application also provides a computer program product. The computer program product includes a computer program, and when the computer program is executed by a processor, the steps of the above method are implemented.

[0026] For the above application start control method, application start display method, device, computer device, computer-readable storage medium, and computer program product, in response to an application start event triggered for a target application, an original context object of the target application is created, and the system permissions expected to be obtained by the target application during the start process are determined; if the system permissions are in an unauthorized state, the variable information of the original context object is called to construct a proxy context object corresponding to the original context object; based on the proxy context object, an authorization request page for the system permissions is loaded; in response to an authorization operation triggered on the authorization request page, the start task of the target application is executed based on the original context object. During the above application start process, based on the proxy mechanism, the proxy context object is used to replace the access to the original context object, which can provide an authorization request function for unauthorized system permissions without modifying the original context object, thereby enabling the dynamic modification of the display timing of the authorization request page for system permissions, and further ensuring that the start task of the target application is executed when the desired system permissions are authorized, avoiding compliance risks brought about by calling system permissions during the application start process, and being beneficial to improving security. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following will briefly introduce the drawings required for the description of the embodiments. Obviously, the following drawings are only some embodiments of the present application. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0028] Figure 1 It is an application environment diagram of the application start control method in an embodiment;

[0029] Figure 2 It is a schematic diagram of the implementation process of the application start control method and the application start display method in an embodiment;

[0030] Figure 3 It is a schematic flowchart of applying the startup control method in an embodiment;

[0031] Figure 4 It is a schematic overall flowchart of startup in an embodiment;

[0032] Figure 5 It is a schematic flowchart of implanting an agent context object in an embodiment;

[0033] Figure 6 It is a schematic diagram of the replacement process of the main thread task in an embodiment;

[0034] Figure 7 It is a schematic diagram of the application startup timing control process in an embodiment;

[0035] Figure 8 It is a schematic flowchart of applying the startup control method in another embodiment;

[0036] Figure 9 It is a schematic diagram of the application modules involved in the application startup control process in an embodiment;

[0037] Figure 10 It is a schematic overall flowchart of startup in another embodiment;

[0038] Figure 11 It is a schematic diagram of the recovery process of the normal application process in an embodiment;

[0039] Figure 12 It is a schematic flowchart of the application startup display method in an embodiment;

[0040] Figure 13 It is a schematic diagram of the authorization request page in an embodiment;

[0041] Figure 14 It is a schematic diagram of the authorization request sub - page in an embodiment;

[0042] Figure 15 It is a structural block diagram of the application startup control device in an embodiment;

[0043] Figure 16 It is a structural block diagram of the application startup display device in an embodiment;

[0044] Figure 17 It is an internal structure diagram of a computer device in an embodiment;

[0045] Figure 18 It is an internal structure diagram of a computer device in another embodiment. Detailed implementation manners

[0046] In order to make the objectives, technical solutions, and advantages of the present application clearer and more understandable, the present application will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0047] The application start control method and application start display method provided by the embodiments of the present application can be applied to an application environment as Figure 1 shown. Among them, the terminal 120 communicates with the server 140 through a network. The application program of the target application can be installed in the terminal 120. By responding to the application start event triggered for the target application, the application start control method of the present application is executed to complete the start task of the target application. After obtaining the operation permission, the main page of the target application can be displayed on the terminal 120, so that the main page can be used to interact with the server 140 of the target application and enjoy the functions provided by the server 140. Such functions can be, for example, instant messaging functions, audio and video playback functions, online shopping functions, and so on. The communication network can be a wired network or a wireless network. Therefore, the terminal 120 and the server 140 can be directly or indirectly connected through wired or wireless communication methods. For example, the terminal 120 can be indirectly connected to the server 140 through a wireless access point, or the terminal 120 can be directly connected to the server 140 through the Internet. The present application does not make any restrictions here. Further, the specific form of the target application is not limited in the present application, including but not limited to clients, applets, etc. installed in the terminal 120, and can also be in the form of a web page. Those skilled in the art know that the number of the above-mentioned terminals 120 can be one or more, and the present application does not limit the number and device type of the terminal 120.

[0048] Among them, the terminal 120 includes but is not limited to mobile phones, computers, intelligent voice interaction devices, smart home appliances, vehicle-mounted terminals, aircraft, etc. The embodiments of the present invention can be applied to various scenarios, including but not limited to cloud technology, artificial intelligence, intelligent transportation, assisted driving, etc. The portable wearable device can be a smart watch, a smart bracelet, a head-mounted device, etc. The server 140 can be an independent physical server, or a server cluster or distributed system composed of multiple physical servers, or a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, CDN (Content Delivery Network), and big data and artificial intelligence platforms. The data storage system can store the data that the server 140 needs to process. The data storage system can be set up separately, integrated on the server 140, or placed on the cloud or other servers.

[0049] The application startup control method and application startup display method provided by the embodiments of the present application may have the execution subject of each step as a computer device, which refers to an electronic device with data calculation, processing, and storage capabilities. Taking Figure 1 the solution implementation environment shown as an example, the application startup control method and application startup display method may be executed by the terminal 120, or may be executed by the server 140, or may be executed by the interaction and cooperation of the terminal 120 and the server 140. The embodiments of the present application do not make any limitations in this regard.

[0050] Taking the case where the target application is a client installed on the terminal 120 and the system permission expected to be obtained during the startup process of the target application is the sensitive data call permission as an example. In the traditional technology, a relatively common application startup process is as follows: The user clicks on the client icon of the target application, triggering an application startup event for the target application; the operating system of the terminal executes the application program startup process, creating a context object (Application Context) of the target application, denoted as the Application object; after the Application object is created, the operating system calls and executes its onCreate method; after the operating system calls the onCreate method of the Application object, a data compliance protocol confirmation page is launched; the user completes the user authorization operation on the data compliance protocol confirmation page. If the user agrees to the data compliance protocol, the main page of the target application is opened, otherwise the application is directly exited.

[0051] The problems existing in the above process at least include:

[0052] Problem 1: Since the application startup timing is fixed, when the data compliance protocol during the application startup process changes, it may lead to the obsolescence of the original application version, and it is necessary to republish the application version.

[0053] Problem 2: For some applications, there are usually several third-party libraries associated with them, and some third-party libraries must be initialized when the application starts. That is, the onCreate method contains initialization code for the third-party SDK (Software Development Kit). When the onCreate method is called, it also means that the initialization code of the third-party SDK is executed. During the SDK initialization process, system interface calls related to sensitive APIs (Application Programming Interface, which are some predefined interfaces or agreements for the connection of different components of a software system) are involved, resulting in the application executing sensitive API-related interfaces before the user agrees to the data compliance protocol, causing the data compliance detection of the target application to fail and affecting the application's listing and release.

[0054] The embodiments of the present application provide an application startup control method and an application startup display method. Figure 2 Fig. shows a schematic diagram of the implementation process of the application startup control method and the application startup display method provided by an exemplary embodiment of the present application. Among them, Figure 2 it includes a terminal 120 and a server 140. The steps of the application startup control method and the application startup display method of the embodiments of the present application are briefly described as follows:

[0055] Step 1, an application element 121 of the target application is displayed in the terminal 120.

[0056] Step 2, the user clicks on the application element 121 in the terminal 120, triggering an application startup event for the target application, causing the operating system of the terminal 120 to create an original context object of the target application and determine the system permissions expected to be obtained by the target application during startup. This system permission can be read by the terminal 120 from the system permission dynamic file of the target application, or the terminal 120 can communicate with the server 140 of the target application, and the server 140 determines it according to the application information of the target application. This application information can include, for example, the application identifier and version number, etc.

[0057] Step 3, the terminal 120 determines the current permission status of the system permission. If the current permission status is the authorized status, the startup task of the target application is executed based on the original context object; if the current permission status is the unauthorized status, a proxy context object corresponding to the original context object is constructed by calling the variable information of the original context object, and an authorization request page 122 for the system permission is loaded based on the proxy context object.

[0058] Specifically, the hook mechanism can be used. Before executing the startup task of the target application based on the original context object, it is judged whether an authorization request process for the system permission needs to be implanted according to the current permission status of the system permission. If an authorization request process for the system permission needs to be implanted, the original application startup process is hooked, and an authorization request page 122 for the system permission is loaded based on the proxy context object corresponding to the original context object. If an authorization request process for the system permission does not need to be implanted, the startup task of the target application is continued to be executed based on the original context object.

[0059] Step 4, the user triggers a feedback operation for the system permission on the authorization request page 122. If the feedback operation is an authorization operation, the terminal 120 executes the startup task of the target application based on the original context object, and when the target application completes startup, the main page 123 of the target application is displayed; if the feedback operation is a rejection operation, the terminal 120 exits the startup process of the target application.

[0060] By adopting the above application startup control method and application startup display method, based on the proxy mechanism, using the proxy context object to replace the access to the original context object, it is possible to provide an authorization request function for unauthorized system permissions without modifying the original context object. On the one hand, it can reduce the workload in the application startup control process and is beneficial to improving data processing efficiency; on the other hand, it can dynamically modify the display timing of the authorization request page for system permissions, thereby ensuring that the startup task of the target application is executed when the desired system permissions are authorized, avoiding compliance risks brought about by invoking system permissions during the application startup process, and being beneficial to improving security. Therefore, adopting the above method can improve security while ensuring data processing efficiency.

[0061] In one embodiment, as Figure 3 shown, there is provided an application startup control method, which can be executed by a computer device, and the computer device can be Figure 1 the terminal shown. In this embodiment, taking the method applied to the Figure 1 terminal as an example for description, it includes the following steps:

[0062] Step 302, in response to an application startup event triggered for a target application, create an original context object of the target application, and determine the system permissions that the target application expects to obtain during startup.

[0063] Among them, the target application is loaded on the terminal and runs on the basis of the operating system configured on the terminal. The operating system is a computer management and control program for the terminal, such as the Android operating system, the iOS operating system, or other operating systems, etc., which is not limited in the embodiments of the present application. For the sake of simplicity of description, the operating system will be abbreviated as the system hereinafter and will not be elaborated further. The context object is an abstract class used to provide a place for sharing information between different resources within the same application, that is, it provides an interface for global information about the application environment. The original context object (Application Context) of the target application refers to the context object created by the system for the target application when the application startup event is triggered, and can be understood as an instance named Application. Variables that can be globally shared in the target application, such as URLs (uniform resource locators) and shared resource files, etc., will be stored in the original context object of the target application.

[0064] The system permissions that the target application expects to obtain during the startup process refer to the system permissions required to ensure the normal startup of the target application. Such system permissions may include at least one of program running permissions and function usage permissions. Program running permissions refer to the permissions related to the running of the application program of the target application, including but not limited to one or more of self-starting permissions, notification bar permissions, background running permissions, network permissions, and floating window permissions, etc. Function usage permissions refer to the permissions related to the functions required during the startup process of the application program, including but not limited to one or more of interface call permissions, location permissions, calendar permissions, microphone permissions, album permissions, information collection permissions, and camera permissions, etc. For example, in the case where the target application is associated with a third-party library such as a mobile development platform or a mini-program development platform, the target application needs to initialize the third-party SDK during the startup process, and the system permissions that it expects to obtain may include interface call permissions or information collection permissions. Another example is that in the case where real-time advertisements are displayed during the startup process of the target application, the system permissions that it expects to obtain may include floating window permissions or pop-up window permissions. Still another example is that in the case where the entrance of a paid application program is displayed during the startup process of the target application, the permissions that it expects to obtain may include interface call permissions.

[0065] Specifically, the terminal can display the application elements of the target application, and such application elements may include at least one of virtual buttons, text, or icons. Thus, the user can trigger an application startup event for the target application by initiating a trigger operation on the application elements. Among them, the trigger operation includes but is not limited to one or more of clicking, touching, sliding, dragging, and pressing, etc. The startup detection code can be configured in the application program of the target application to detect the application startup event triggered for the target application. For example, the terminal can determine that an application startup event for the target application has been triggered when it detects that the user clicks on the application element. Further, the terminal can, in response to this application startup event, create an original context object of the target application and determine the system permissions that the target application expects to obtain during the startup process. It can be understood that determining the system permissions that are expected to be obtained during the startup process and applying for permissions before executing the startup task of the target application can effectively protect information security, enhance the protection of system permissions, and thus ensure the information security of users.

[0066] The specific manner in which the terminal creates the original context object is not unique. Exemplarily, the system can find relevant resource files based on the class path ClassPath or a specified file system path, or find a specified XML configuration file from a Web application, and complete the instantiation work of the Application Context, thereby completing the creation of the original context object for the target application.

[0067] The specific way for the terminal to determine the system permissions that the target application expects to obtain during the startup process is not unique. In one embodiment, the terminal can also interact with the server to determine the system permissions that the target application expects to obtain during the startup process. Exemplarily, the terminal can send the application information of the target application to the server, so that the server can, based on the application information, feedback to the terminal the system permissions that the target application expects to obtain during the startup process. The application information can include the application identifier, version number, etc.

[0068] In one embodiment, determining the system permissions that the target application expects to obtain during the startup process includes: obtaining the system permission dynamic file of the target application; reading from the system permission dynamic file the system permissions that the target application expects to obtain during the startup process.

[0069] Among them, the system permission dynamic file can be used to record the permission information of the system permissions that the target application needs to use in the current running state. The permission information includes at least one of, but is not limited to, the permission identifier of the system permission, the reason for use, and the usage scenario, etc. For example, when the system permission is the calendar permission, the corresponding permission description information can include, for example, "This permission is used for at least one of displaying the calendar, creating a calendar, modifying the calendar, or schedule synchronization, etc.". Another example is that when the system permission is the microphone permission, the corresponding permission description information can include, for example, "This permission is used for at least one of recording audio to implement voice chat, voice call, or live broadcast, etc.". Another example is that when the system permission is the location permission, the corresponding permission description information can include, for example, "This permission is used for at least one of obtaining the location or sending the location, etc.".

[0070] It can be understood that for the same target application, the system permissions required in different running states may be different. For example, during the application startup process, the location acquisition permission may be required to determine the main page elements matching the location according to the user's current location, so as to display the main page containing the main page elements after the startup task is completed; during the usage process after the application is started, the user may customize and update the location information, so that the target application may need to use the location sending permission to obtain the page information corresponding to the updated location information by sending the updated location information to the server.

[0071] Specifically, the terminal can store the application file of the target application, and the application file can include the system permission dynamic file. Thus, when the application start event for the target application is triggered, the terminal can read the system permissions that the target application expects to obtain during the startup process from the system permission dynamic file of the target application. Exemplarily, the terminal can use PathClassLoader to load the system permission dynamic file (auth.dex), or can obtain the system permission dynamic file from a preset local resource file, and then read the system permissions that are expected to be obtained during the startup process from the system permission dynamic file. Further, the current permission status of the system permissions can also be recorded in the system permission dynamic file. The current permission status can include the authorized status and the unauthorized status.

[0072] In this embodiment, reading the system permissions that the target application expects to obtain during the startup process from the system permission dynamic file can improve the data processing efficiency of the application startup control process.

[0073] Step 304, if the system permission is in the unauthorized state, then call the variable information of the original context object to construct a proxy context object corresponding to the original context object.

[0074] Among them, the variable information of the context object can include variable parameters and the variable values of the variable parameters. The variable parameters and the variable values are in one-to-one correspondence, and their data forms can be, for example, key-value pairs, fields and field values, etc., which are not limited here. Specifically, after determining the system permissions that the target application expects to obtain during the startup process, the terminal can further determine the current permission status of the system permissions during the startup process of the target application, that is, whether the system permissions have been authorized in the startup state of the target application. The current permission status can include the authorized status and the unauthorized status. It can be understood that if the system permission is in the authorized state, there is no need to perform the corresponding permission request operation; if the system permission is in the unauthorized state, the corresponding permission request operation needs to be performed for the system permission.

[0075] Optionally, when the target application is started for the first time on the terminal, all the system permissions it needs to use are in the unauthorized state. Optionally, when the version number of the target application is different and it is started for the first time in the next version, all the system permissions it needs to use are in the unauthorized state. That is, authorization requests need to be made for all the system permissions that are expected to be obtained. Optionally, when the version number of the target application is different and it is started for the first time in the next version, the system permissions that have been authorized in the previous version can be continued to be used. That is, only authorization requests need to be made for the newly added system permissions.

[0076] Specifically, the terminal can, based on the proxy mechanism, obtain the variable information of the original context object by calling the callback method attachBaseContext(), and construct a proxy context object corresponding to the original context. Among them, the proxy mechanism refers to providing a proxy object for a certain object, and using the proxy object to reference this object and enhance some methods. Through the proxy mechanism, using the proxy object to replace the access to the original object can provide additional functional operations without modifying the original object, thereby expanding the functions of the original object. In a specific embodiment, the terminal can use attachBaseContext to determine the hook entry corresponding to the original context object Application Context, use reflection to call and obtain the variable information of the original context object, and construct a proxy context object corresponding to the original context object.

[0077] It should be noted that in the case where the number of system permissions expected to be obtained is multiple, if all system permissions are in the authorized state, there is no need to implant the authorization request process for system permissions by constructing a proxy context object, and the startup task of the target application can be continued based on the original context object; on the contrary, if there are system permissions in the unauthorized state, it is necessary to construct a proxy context object corresponding to the original context object.

[0078] Step 306: Load the authorization request page for system permissions based on the proxy context object.

[0079] Among them, the authorization request page is a page that requests the user to obtain system permissions. The authorization request page can be a request page for one or more unauthorized system permissions. Exemplarily, the authorization request page can include permission information for system permissions and authorization request interaction elements. The specific data form of the permission information can include at least one of text form or icon form. For example, for the microphone permission, a microphone icon can be displayed, or the text information "Request to call the microphone to record audio" can be displayed; for the location permission, a positioning icon can be displayed, or the text information "Request to obtain the current location" can be displayed. The authorization request interaction element is a carrier for interaction between the user and the terminal, and specifically can include a first type of element representing "agree to authorize" and a second type of element representing "disagree to authorize". The authorization request page can be in a slidable page form. Thus, in the case where the number of unauthorized system permissions in the unauthorized state is multiple, the permission information and authorization request interaction elements for each of the multiple system permissions can be displayed on the authorization request page. The authorization request page can include authorization request sub-pages for each of the multiple unauthorized system permissions. Thus, the authorization request can be made for each system permission by sequentially displaying each authorization request sub-page.

[0080] In a specific embodiment, the system permission may refer to the information collection permission of a third-party SDK for collecting user information. In the situation of this embodiment, the authorization request page for the system permission may display content such as a "data compliance agreement" or a "disclaimer", and the description information of the third-party SDK for collecting user information, etc., so as to clearly inform the user of the information collection behavior of the third-party SDK and obtain the consent or authorization of the user. For example, the "data compliance agreement" is used to explain what specific information of the users involved in the target application, how to collect, use, store and share the personal information of the users, and the ways provided by the target application to access, update, control and protect this information, and so on.

[0081] As described above, based on the proxy mechanism, additional functional operations can be provided without modifying the original object, thereby expanding the functions of the original object. Specifically in this application, the additional functional operation provided is the authorization request operation, that is, based on the proxy context object, the authorization request page for the system permission is loaded, and an authorization request is sent to the user. Optionally, the terminal can execute the authorization request logic carried by the proxy context object by replacing the original context object with the proxy context object, and load the authorization request page for the system permission; optionally, the terminal can obtain the main thread task queue based on the original context object, and replace the tasks to be executed in the main thread task queue with the authorization page loading tasks based on the proxy context object, and then run the authorization page loading tasks to load the authorization request page for the system permission.

[0082] Step 308, in response to the authorization operation triggered on the authorization request page, execute the startup task of the target application based on the original context object.

[0083] Specifically, the user can trigger an authorization operation or a refusal authorization operation for the system permission on the authorization request page. Thus, the terminal can execute the startup task of the target application based on the original context object in response to this authorization operation. After the startup task of the target application is completed, the terminal can display the main page of the target application.

[0084] Optionally, the terminal can trigger the onCreate method of the Application Context by hooking the ActivityThread of the system, and resume the execution of the startup task based on the original context object. After the onCreate method is called, it means that the initialization process of the SDK has been completed; then, the terminal can construct a message object of the type Message.LAUNCH_MAIN, add this message to the message queue of the main thread, start the execution of the main page startup process, and display the main page of the target application. It can be understood that if the user triggers a refusal to authorize the system permission on the authorization request page, the terminal can exit the application startup control process of the target application and end the current application startup.

[0085] In a specific embodiment, an authorization request interaction element for the system permission is displayed on the authorization request page, so that the user can trigger a corresponding authorization operation or a refusal to authorize operation for the authorization request interaction element. The triggering operations include, but are not limited to, one or more of clicking, touching, swiping, dragging, and pressing.

[0086] Next, taking the case where the system permission is the information collection permission of a third-party SDK for collecting user information as an example, the overall process of the application startup of the present application will be introduced. In a specific embodiment, such as Figure 4As shown, when the user triggers an application startup event for the target application, the application startup begins, and the operating system creates the original context object of the target application. Moreover, based on the attachBaseContext method, a data compliance page, i.e., an authorization request page for information collection permissions, is implanted. Specifically, the terminal can use the attachBaseContext method to obtain the current hook entry (provided by the Application Context), and use reflection to call to construct a proxy context object corresponding to the original context object to achieve the replacement of the original context object. In the business logic of the proxy context object, the original application startup sequence (attachBaseContext - onCreate - startup of the main page) can be paused, and an authorization request page for information collection permissions can be invoked, and the corresponding process can be completed. If the authorization is not obtained, the application exits; if the authorization is obtained, the initialization logic of the third-party software development kit (SDK) in the onCreate method can be executed, and when the startup task of the target application is completed, the main page of the target application can be loaded and displayed to complete the application startup. Optionally, the task list of the main thread task can be cached in memory, and the main thread task queue can be cleared, so that the task list actively suspends and waits, and after the authorization is obtained, the proxy context object can be unloaded. After the proxy unloading is completed, the onCreate method of the original context object can be triggered through hook to execute the previously suspended task list to complete the application startup.

[0087] In the above application startup control method, in response to an application startup event triggered for the target application, the original context object of the target application is created, and the system permissions expected to be obtained by the target application during startup are determined; if the system permissions are in an unauthorized state, the variable information of the original context object is called to construct a proxy context object corresponding to the original context object; based on the proxy context object, an authorization request page for the system permissions is loaded; in response to an authorization operation triggered on the authorization request page, the startup task of the target application is executed based on the original context object. During the above application startup process, based on the proxy mechanism, using the proxy context object to replace the access to the original context object can provide an authorization request function for unauthorized system permissions without modifying the original context object. On the one hand, it can reduce the workload of the application startup control process and is beneficial to improving data processing efficiency; on the other hand, it can dynamically modify the display timing of the authorization request page for system permissions, thereby ensuring that the startup task of the target application is executed when the desired system permissions are authorized, avoiding compliance risks brought by calling system permissions during the application startup process, and being beneficial to improving security. Therefore, adopting the above method can improve security while ensuring data processing efficiency.

[0088] In one embodiment, the application startup control method further includes: querying the historical startup record of the target application; if it is determined based on the historical startup record that the target application is started for the first time, determining that the system permissions are in an unauthorized state; if it is determined based on the historical startup record that the target application is not started for the first time, obtaining the current permission state of the system permissions.

[0089] Wherein, the current permission state includes an authorized state and an unauthorized state. The historical startup record refers to the startup record information before the current startup, and may include time information and event information of the startup process, etc. The time information may include, for example, the startup start time and the startup completion time, and the event information may include record information of various events such as page display events and interface call events.

[0090] Specifically, the terminal may store a log file of the target application, and the historical startup record of the target application may be retained in the log file. Further, after determining the system permissions that the target application expects to obtain during the startup process, the terminal may query the historical startup record of the target application by accessing the log file, and further determine the current permission state of the system permissions based on the historical startup record. If it is determined based on the historical startup record that the target application is started for the first time, it indicates that the target application has not obtained authorization for the system permissions, that is, the system permissions are in an unauthorized state. If it is determined based on the historical startup record that the target application is not started for the first time, it indicates that the target application may have obtained authorization for the system permissions, and it is necessary to further obtain the current permission state of the system permissions. Exemplarily, the terminal may obtain the permission identifier of the system permissions and pass the permission identifier to the system for the system to query the current permission state of the system permissions represented by the permission identifier according to the permission identifier. It can be understood that the current permission states of the same system permissions corresponding to different applications may be the same or different. That is, the current permission state of the system permissions refers to the permission state of the system permissions during the startup process of the target application.

[0091] In the above embodiment, when the target application is started for the first time, it is determined that the system permissions are in an unauthorized state, and when the target application is not started for the first time, the current permission state of the system permissions is further obtained. On the one hand, since the system permissions are in an unauthorized state when starting for the first time, security can be ensured. On the other hand, determining the current permission state of the system permissions based on whether it is the first startup is simple, and the working efficiency of the application startup control process can be further improved.

[0092] In practical applications, the current permission status of system permissions can be represented by a status flag. In one embodiment, obtaining the current permission status of system permissions includes: obtaining the status flag of system permissions and determining the current permission status represented by the status flag. In the case of this embodiment, the application startup control method further includes: in the case where the current permission status is the unauthorized status, in response to an authorization operation triggered on the authorization request page, modifying the current permission status from the unauthorized status to the authorized status.

[0093] Among them, the status flag is used to represent the current permission status of system permissions. The specific data form of this status flag can, for example, include at least one of numbers, texts, or characters. Exemplarily, the status flag "1" can represent the authorized status, and the status flag "0" can represent the unauthorized status. In a specific implementation, the terminal can also save the correspondence between the application, system permissions, and status flags to record the current authorization status of each system permission corresponding to different applications. Specifically, the terminal can obtain the status flag of system permissions and determine the current permission status represented by the status flag. In the case where the current permission status is the authorized status, there is no need to perform the corresponding authorization request process. In the case where the current permission status is the unauthorized status, the corresponding authorization request process needs to be executed, and during the authorization request process, in response to an authorization operation triggered on the authorization request page for the system permission, the status flag of the system permission is updated, so as to modify the current permission status of the system permission from the unauthorized status to the authorized status.

[0094] In the above embodiment, using the status flag to represent the current permission status of system permissions and recording the current permission status of system permissions by managing the status flag can improve the convenience of the current permission status determination process and ensure the accuracy of the determined current permission status.

[0095] In one embodiment, the variable information includes variable parameters and the variable values of the variable parameters. In this embodiment, calling the variable information of the original context object to construct a proxy context object corresponding to the original context object includes: loading the proxy class file and constructing a proxy object of the original context object; reflecting and accessing the original context object to obtain the variable parameters of the original context object and the variable values of the variable parameters; and assigning values to the proxy object based on the variable parameters and variable values to obtain a proxy context object corresponding to the original context object.

[0096] Among them, the reflection mechanism (Java Reflection) is the ability of the Java language to dynamically (at runtime) access, detect, and modify itself. Its main function is to dynamically (at runtime) obtain the complete structural information of a class and call the methods of an object. To put it more simply, a Java program can, at runtime, create a reflection object of a class and then perform relevant operations on the class, such as obtaining and assigning values to the member variables of the object, calling the methods of the object, and determining the class to which the object belongs.

[0097] Specifically, the terminal can, based on the reflection mechanism, create a proxy context object corresponding to the original context object through reflection construction. Exemplarily, the terminal can use Class.forName to load the proxy class file (com.tencent.tmf.sdk.PrivacyAuthApp) from the dynamically loaded auth.dex file and call the newInstance method to construct an object instance, marked as proxyApp, which is the proxy object of the original context object. Then, through reflection, access the ActivityThread object held by the original context object (context), reference and obtain its member variable of type AppBindData, denoted as filed1, which is the variable parameter of the original context object. Next, through reflection, access mApplication of AppBindData (i.e., the variable value in the original context object) and obtain the member variable of type Application, marked as filed2, which is the variable value of the variable parameter obtained in the previous step. Finally, the terminal assigns values to the proxy object based on the obtained variable parameter and variable value to obtain a proxy context object corresponding to the original context object. Exemplarily, it can call filed2.set(filed, proxyApp) to assign a value to the proxy object proxyApp to obtain the proxy context object.

[0098] In the above embodiment, constructing a proxy context object corresponding to the original context object based on the no-argument constructor method can ensure the matching degree between the proxy context object and the original context object, thereby realizing function expansion without modifying the original context object, reducing the workload in the application startup control process, and being conducive to improving data processing efficiency.

[0099] In a specific embodiment, assigning values to the proxy object based on the variable parameter and variable value to obtain a proxy context object corresponding to the original context object includes: changing the access status of the variable parameter and variable value to make them in an accessible state; calling the variable parameter and variable value in the accessible state to assign values to the proxy object to obtain a proxy context object corresponding to the original context object.

[0100] In practical applications, variable parameters and variable values are defaulted to an inaccessible state. Based on this, the terminal can first change the access state of the variable parameters and variable values to make them in an accessible state. Then, the terminal can call the variable parameters and variable values in the accessible state to assign values to the proxy object, and obtain the proxy context object corresponding to the original context object. Exemplarily, the terminal can change the access modifier of the variable parameters and variable values to the accessible state, specifically, it can set the mApplication member variable of AppBindData to be accessible: field2.setAcceessEnable(true). Then, the terminal calls filed2.set(filed, proxyApp) to assign a value to the proxy object proxyApp, and obtains the proxy context object corresponding to the original context object. Changing the access state first and then calling the variable parameters and variable values in the accessible state to assign values to the proxy object can ensure the accuracy of the assignment result.

[0101] The following introduces the implantation process of the proxy context object. In a specific embodiment, such as Figure 5As shown in the figure, the present application controls and modifies the application startup timing by proxy replacing the original context object of the target application. Specifically, startup detection code can be configured in the application program of the target application to detect the application startup event triggered for the target application. And use PathClassLoader to load the dynamically downloaded (or it can also be the prefabricated local resource file) system permission dynamic file (auth.dex), and create a compliant proxy context object through reflection. The specific method can be to use Class.forName to load the proxy class file (com.tencent.tmf.sdk.PrivacyAuthApp) from the dynamically loaded auth.dex file, and call the newInstance method to construct an object instance, marked as proxyApp, that is, the proxy object corresponding to the original context object. Then, use reflection to access the ActivityThread object held by the context object (the original context object), reference and obtain its member variable of type AppBindData; then use reflection to access the mApplication object of AppBindData (corresponding to the original context object), and replace the original context object with the proxy context object generated by newInstance. Optionally, you can first use ActivityThread.getDeclearedFiled("AppBindData") to obtain the member variable of type AppBindData, denoted as filed1, which is the variable parameter of the original context object; then use AppBindData.getDeclearedFiled("mApplication") to obtain the member variable of type Application, denoted as filed2, which is the variable value of the variable parameter obtained in the previous step; then, set the mApplication member variable of AppBindData to be accessible: field2.setAcceessEnable(true), and then call filed2.set(filed, proxyApp) to assign a value to the proxy object; thus, the implantation process of the proxy context object is completed.

[0102] In one embodiment, based on the proxy context object, load the authorization request page for system permissions, including: obtaining the main thread task queue based on the original context object; replacing the task to be executed with the authorization page loading task based on the proxy context object; running the authorization page loading task to load the authorization request page for system permissions.

[0103] Among them, the main thread task queue includes at least one task to be executed. The task to be executed can include, for example, tasks such as page creation, page resource loading, page lifecycle callback, page display and rendering. The page can refer to the main page of the target application. Specifically, the terminal obtains the main thread task queue based on the original context object, replaces the task to be executed in the main thread task queue with an authorized page loading task based on the proxy context object, and loads the authorized request page for system permissions by running the authorized page loading task. It can be understood that after the authorization request process based on the authorized request page is completed, if authorization is obtained, the task to be executed in the main thread task queue can be restored to execute the startup task of the target application based on the original context object.

[0104] In this embodiment, replacing tasks for the main thread based on the original context object can implant the authorization request process without adding new threads, which is beneficial to improving the processing efficiency.

[0105] In one embodiment, replacing the task to be executed with an authorized page loading task based on the proxy context object includes: caching the task to be executed in the system memory and deleting the task to be executed in the main thread task queue; adding the authorized page loading task based on the proxy context object to the main thread task queue. In the case of this embodiment, in response to an authorization operation triggered on the authorized request page, executing the startup task of the target application based on the original context object includes: in response to an authorization operation triggered on the authorized request page, unloading the proxy context object and adding the task to be executed in the system memory to the main thread task queue; executing each task to be executed in the main thread task queue to complete the startup task of the target application.

[0106] Specifically, as Figure 6 shown, the tasks to be executed in the main thread task queue can include task A, task B, and task C. The terminal can cache task A, task B, and task C in the system memory and delete the tasks to be executed in the main thread task queue, making the main thread in an empty thread state. Then, add the authorized page loading task based on the proxy context object to the main thread in the empty thread state, and run the authorized page loading task in the main thread to load the authorized request page for system permissions. After obtaining authorization based on the authorized request page, the terminal can unload the proxy context object and add the tasks to be executed cached in the system memory (including task A, task B, and task C) to the main thread task queue, and execute each task to be executed in the main thread task queue to complete the startup task of the target application.

[0107] In a specific embodiment, the interruption of the application startup timing, the insertion of the self-owned process, and the recovery of the startup process can be realized by hooking the message queues of the original context object and the main thread. AsFigure 7 As shown in the figure, the terminal can detect the application startup event of the target application, obtain an instance of the initialization class (ActivityThread) through the original context object of the target application, replace the original application context through reflection and hook mechanisms, clear the current main thread task stack, cache the unfinished tasks, and pause the normal timing sequence of the application startup. Then, replace the original task stack processing Handler with a proxy Handler, and add the logic to complete its own startup in the task processor of the proxy context object to complete the replacement of the tasks to be executed in the main thread. When the task to be executed is the main page loading task, the main page startup message (Message) in the default startup process can be intercepted and replaced with the authorization request page loading task. After the processing logic of the authorization request page loading is completed, the original startup task stack (i.e., the original main thread task queue) that was cleared and replaced before is restored, and the normal startup logic continues to be executed.

[0108] In the above embodiments, caching the task to be executed in the system memory and adding the task to be executed in the system memory to the main thread task queue after obtaining authorization can relatively conveniently implement the suspension and restoration of tasks, which is beneficial to improving work efficiency.

[0109] In one embodiment, as Figure 8 shown, an application startup control method is provided. This method can be executed by a computer device, and the computer device can be Figure 1 the terminal or server shown in the figure. Taking the computer device as the terminal as an example, in this embodiment, the method includes the following steps:

[0110] Step S801, in response to the application startup event triggered for the target application, create the original context object of the target application.

[0111] Among them, the target application is loaded on the terminal and runs on the basis of the operating system configured on the terminal. Specifically, the terminal can display the application elements of the target application, so that the user can trigger the application startup event for the target application by initiating a trigger operation for the application elements. Among them, the trigger operation includes, but is not limited to, one or more of clicking, touching, sliding, dragging, and pressing. The startup detection code can be configured in the application program of the target application to detect the application startup event triggered for the target application. Further, the terminal can create the original context object of the target application in response to the application startup event. Exemplarily, the terminal can find the specified XML configuration file from the class path ClassPath, the specified file system path, or the Web application, find and load to complete the instantiation of the Application Context, thereby completing the creation of the original context object of the target application.

[0112] Step S802: Obtain the system permission dynamic file of the target application, and read the system permissions that the target application expects to obtain during the startup process from the system permission dynamic file.

[0113] Among them, the system permission dynamic file can be used to record the permission information of the system permissions required by the target application in the current running state. The permission information includes at least one of, but is not limited to, the permission identifier, the reason for use, and the usage scenario of the system permission. Specifically, the terminal may store the application file of the target application, and the application file may include the system permission dynamic file. Thus, when the application startup event for the target application is triggered, the terminal can read the system permissions that the target application expects to obtain during the startup process from the system permission dynamic file of the target application.

[0114] Step S803: Query the historical startup record of the target application.

[0115] Among them, the historical startup record refers to the startup record information before the current startup, and may include time information and event information of the startup process, etc. Specifically, the terminal may store the log file of the target application, and the historical startup record of the target application may be retained in the log file. Furthermore, after determining the system permissions that the target application expects to obtain during the startup process, the terminal can query the historical startup record of the target application by accessing the log file, and further determine the current permission state of the system permissions according to the historical startup record.

[0116] Step S804: If it is determined based on the historical startup record that the target application is starting for the first time, determine that the system permissions are in an unauthorized state.

[0117] Specifically, if it is determined based on the historical startup record that the target application is starting for the first time, it means that the target application has not obtained the authorization of the system permissions, that is, the system permissions are in an unauthorized state.

[0118] Step S805: If it is determined based on the historical startup record that the target application is not starting for the first time, obtain the status flag of the system permissions, and determine the current permission state represented by the status flag.

[0119] Among them, the current permission state includes the authorized state and the unauthorized state. If it is determined based on the historical startup record that the target application is not starting for the first time, it means that the target application may have obtained the authorization of the system permissions, and it is necessary to further obtain the current permission state of the system permissions.

[0120] Step S806: If the system permissions are in an unauthorized state, load the proxy class file and construct a proxy object of the original context object.

[0121] Specifically, if the system permission is in an unauthorized state, the terminal can create a proxy context object corresponding to the original context object through reflection construction. Exemplarily, the terminal can use Class.forName to load the proxy class file (com.tencent.tmf.sdk.PrivacyAuthApp) from the dynamically loaded auth.dex file and call the newInstance method to construct an object instance, marked as proxyApp, which is the proxy object of the original context object.

[0122] Step S807: Reflectively access the original context object to obtain the variable parameters of the original context object and the variable values of the variable parameters.

[0123] Specifically, the terminal can first obtain the variable parameters of the original context object and then further obtain the variable values of the variable parameters. Exemplarily, the terminal can reflectively access the ActivityThread object held by the original context object (context), reference and obtain its member variable of type AppBindData, denoted as filed1, which is the variable parameter of the original context object. Then, reflectively access mApplication of AppBindData (i.e., the variable value in the original context object) to obtain the member variable of type Application, marked as filed2, which is the variable value of the variable parameter obtained in the previous step.

[0124] Step S808: Change the access status of the variable parameters and variable values to make them in an accessible state.

[0125] In practical applications, the variable parameters and variable values are defaulted to an inaccessible state. Based on this, the terminal can first change the access status of the variable parameters and variable values to make them in an accessible state. Exemplarily, the terminal can change the access modifiers of the variable parameters and variable values to an accessible state. Specifically, it can set the mApplication member variable of AppBindData to be accessible: field2.setAcceessEnable(true).

[0126] Step S809: Call the variable parameters and variable values in the accessible state to assign values to the proxy object to obtain a proxy context object corresponding to the original context object.

[0127] Exemplarily, the terminal can call filed2.set(filed, proxyApp) to assign a value to the proxy object proxyApp to obtain a proxy context object corresponding to the original context object.

[0128] Step S810: Obtain the main thread task queue based on the original context object.

[0129] Among them, the main thread task queue includes at least one task to be executed. This task to be executed can include tasks such as page creation, page resource loading, page lifecycle callback, page display and rendering, etc. The page can refer to the main page of the target application.

[0130] Step S811: Cache the task to be executed in the system memory and delete the task to be executed in the main thread task queue.

[0131] Specifically, the terminal can cache the task to be executed in the system memory and delete the task to be executed in the main thread task queue to empty the current main thread task queue and suspend the original main thread tasks.

[0132] Step S812: Add the authorization page loading task based on the proxy context object to the main thread task queue.

[0133] Specifically, the terminal can add the authorization page loading task based on the proxy context object to the main thread task queue. Thus, the task to be executed in the main thread is the authorization page loading task.

[0134] Step S813: Run the authorization page loading task to load the authorization request page for system permissions.

[0135] Step S814: In response to the authorization operation triggered on the authorization request page, modify the current permission status from the unauthorized status to the authorized status.

[0136] Specifically, the terminal can complete the modification of the current permission status of the system permissions by updating the status flag.

[0137] Step S815: Unload the proxy context object and add the tasks to be executed in the system memory to the main thread task queue.

[0138] Specifically, after the authorization page loading task is completed, the terminal can unload the proxy context object and add the tasks to be executed in the system memory to the main thread task queue to resume the original main thread tasks. It can be understood that in the case where the number of un-authorized system permissions is multiple, when all system permissions have been authorized, the terminal unloads the proxy context object and resumes the original main thread tasks. If any system permission is refused authorization, the current startup process ends.

[0139] Step S816: Execute each task to be executed in the main thread task queue to complete the startup task of the target application.

[0140] Specifically, after the startup task is completed, the terminal can display the main page of the target application.

[0141] During the above application startup process, based on the proxy mechanism, using the proxy context object to replace the access to the original context object can provide an authorization request function for unauthorized system permissions without modifying the original context object. On the one hand, it can reduce the workload of the application startup control process and is beneficial to improving data processing efficiency; on the other hand, it can dynamically modify the display timing of the authorization request page for system permissions, thereby ensuring that the startup task of the target application is executed when the desired system permissions are authorized, avoiding compliance risks brought by calling system permissions during the application startup process, and being beneficial to improving security. Therefore, adopting the above method can improve security while ensuring data processing efficiency.

[0142] Next, taking the case where the system permission is the information collection permission of a third-party SDK for collecting user information as an example, the application startup control method of the present application will be introduced in detail.

[0143] In a specific embodiment, as Figure 9 shown, the application modules involved in the present application may include a third-party software development kit, a startup detection module, a proxy management module, a tag information management module, a context proxy class, and a main page proxy, etc. Among them, the startup detection module is mainly responsible for detecting the startup events of the application and the execution order of the startup, and determining the trigger conditions for the overall process of this solution; the proxy management module is responsible for managing the loading, scheduling, and unloading logic of the context proxy and the startup page proxy; the tag information management module is responsible for managing various types of tag information in compliance detection, including status tags of system permissions, proxy tags, startup page tags, startup page confirmation result tags, etc.; the context proxy class is responsible for proxying and implementing the context object of the Application, including logical packaging of the original context object, and controlling the initialization timing of the application startup page and the third-party SDK; the main page proxy is responsible for controlling the main page information loaded at the startup of the application program and the event distribution logic of the main page according to the tag information.

[0144] In a specific embodiment, as Figure 10As shown, the overall process of the solution of this application may include steps such as application startup, proxy context object implantation, authorization request page loading, proxy unloading, and logic restoration. Specifically, during the application programming process of the target application, startup detection code can be configured to detect the application startup event triggered for the target application. After the startup project is configured, when the application starts, the default callback method attachBaseContext will be called. In the callback method, the proxy management module uses the context information provided by attachBaseContext to perform a hook operation on the original context object of the current application, replacing the context information of the original context object (including the tasks to be executed in the main thread task queue); and caches the context information (for restoring the normal application loading logic in subsequent steps). After the replacement of the task information is completed, before the onCreate method of the implementation class of the original context object is executed, the proxy replacement business logic of the main page will be executed according to the status mark of the system permissions required during the startup process (that is, replacing the relevant tasks to be executed on the main page with the authorization request page loading task). The authorization status of data compliance (whether the user has agreed to the data compliance agreement) is read from the memory by using the mark information management module. If the user has not agreed to the data compliance agreement authorization, the proxy management module is triggered to implement the proxy replacement of the main page entry, replacing the original main entry page loading logic with the authorization request page loading. If the user has already agreed to the data compliance agreement, the page loading logic replacement will not be executed. After obtaining the data compliance authorization, the main page proxy synchronizes the authorization result to the proxy management module by sending a local broadcast. The proxy context performs proxy unloading according to the authorization result, reads the cached original context information from the memory, and replaces the proxy context object through hook. After the proxy unloading is completed, the onCreate method of the Application is triggered by hooking the system's ActivityThread, and the normal application startup timing logic begins to be restored.

[0145] In a specific embodiment, such as Figure 11As shown, the recovery process of the normal application process includes steps such as reading the original context information, reflection replacement, rebinding the original context object, executing the startup task, and loading the main page. Specifically, the terminal can read the context information of the cached original context object from the memory, and obtain the ActivityThread instance from the proxy context object. Then, using the reflection mechanism, access the makeApplication method of the proxy context instance object to be replaced (reset the timing of the application startup process); use the original context information to replace the currently bound proxy context instance object in the ActivityThread (refer to the context object replacement method). After the context instance object is replaced, use the reflection mechanism again to call the onCeate method of the original context object. After the onCreate method is called, it means that the initialization process of the third-party SDK has been completed. Then, construct a message object of type Message.LAUNCH_MAIN, and use the Handler to add this message to the message queue of the main thread, start the startup process of the main page, and display the main page of the target application after the application startup is completed.

[0146] By adopting the technical solution of this application, it is possible to customize the timing of the application startup process and add the required business logic before the application executes the initialization operation. For the application scenario of data compliance, it is possible to dynamically modify the display timing of the data compliance protocol page to ensure that the initialization of the third-party SDK in the application is after agreeing to the data compliance protocol, without affecting the data compliance during the application runtime.

[0147] On the other hand, this application also provides an application startup display method.

[0148] In one embodiment, as Figure 12 shown, an application startup display method is provided. This method can be executed by a computer device, and the computer device can be the Figure 1 terminal shown. In this embodiment, taking this method applied to the Figure 1 terminal as an example for description, it includes the following steps:

[0149] Step S1202, display the application elements of the target application.

[0150] Among them, the application elements can include at least one of virtual buttons, text, or icons. Specifically, the terminal can display the application elements of the target application on its display interface.

[0151] Step S1204, in response to an application startup event triggered for the application elements, display an authorization request page for the system permissions expected to be obtained by the target application during the startup process.

[0152] Among them, the authorization request page is loaded based on the proxy context object; the proxy context object is constructed by calling the variable information of the original context object of the target application when the system permission is in an unauthorized state. For the specific definitions of the proxy context object, the original context object, and the system permission, please refer to the above, and will not be elaborated here. The authorization request page is a page that points to the user's request to obtain system permissions. The authorization request page can be a request page for one or more unauthorized system permissions. Exemplarily, the authorization request page can include permission information for system permissions and authorization request interaction elements. The specific data form of the permission information can include at least one of text form or icon form. For example, for the microphone permission, a microphone icon can be displayed, or the text information "Request to call the microphone to record audio" can be displayed; for the location permission, a location icon can be displayed, or the text information "Request to obtain the current location" can be displayed. The authorization request interaction elements can include a first type of element representing "agree to authorize" and a second type of element representing "refuse to authorize". The authorization request page can be in a slidable page form. Thus, when the number of unauthorized system permissions in the unauthorized state is multiple, the permission information and authorization request interaction elements for each of the multiple system permissions can be displayed on the authorization request page. The authorization request page can include authorization request sub-pages for each of the multiple unauthorized system permissions. Thus, the authorization request can be made for each system permission respectively by sequentially displaying each authorization request sub-page.

[0153] Specifically, the user can trigger an application start event for the target application by initiating a trigger operation on the application element. The trigger operation includes, but is not limited to, one or more of clicking, touching, sliding, dragging, and pressing. The application program of the target application can be configured with start detection code to detect the application start event triggered for the target application. For example, the terminal can determine that the application start event for the target application is triggered when it detects that the user clicks the application element. Further, the terminal can create the original context object of the target application in response to the application start event and determine the system permissions that the target application expects to obtain during startup. Then, when the system permission is in an unauthorized state, the authorization request page for the system permission is displayed.

[0154] Step S1206, in response to the authorization operation triggered on the authorization request page, display the main page of the target application.

[0155] Among them, the main page is displayed when the startup task of the target application is completed based on the original context object. Specifically, the user can trigger an authorization operation or a refusal of authorization for system permissions on the authorization request page. Thus, the terminal can, in response to the authorization operation, execute the startup task of the target application based on the original context object. After the startup task of the target application is completed, the terminal can display the main page of the target application.

[0156] The above application startup display method displays the application elements of the target application; in response to an application startup event triggered for the application elements, it displays an authorization request page for the system permissions expected to be obtained during the startup of the target application; in response to an authorization operation triggered on the authorization request page, it displays the main page of the target application. Among them, the authorization request page is loaded based on the proxy context object; the proxy context object is constructed by calling the variable information of the original context object of the target application when the system permissions are in an unauthorized state; the main page is displayed when the startup task of the target application is completed based on the original context object. During the above application startup process, based on the proxy mechanism, the proxy context object is used to replace the access to the original context object, which can provide an authorization request function for unauthorized system permissions without modifying the original context object. On the one hand, it can reduce the workload of the application startup control process and is conducive to improving data processing efficiency; on the other hand, it can dynamically modify the display timing of the authorization request page for system permissions, and then ensure that the startup task of the target application is executed when the desired system permissions are authorized, avoiding compliance risks brought by calling system permissions during the application startup process and being conducive to improving security. Therefore, adopting the above method can improve security while ensuring data processing efficiency.

[0157] In one embodiment, an authorization request interaction element for system permissions is displayed on the authorization request page. In the case of this embodiment, in response to an authorization operation triggered on the authorization request page, displaying the main page of the target application includes: in response to an authorization operation triggered for the authorization request interaction element, displaying the main page of the target application.

[0158] Among them, the authorization request interaction element may include a first type of element representing "agree to authorize" and a second type of element representing "refuse to authorize". Taking the case where the system permission refers to the information collection permission of a third-party SDK for collecting user information as an example, such as Figure 13As shown, the terminal can display an authorization request page for information collection permissions. The authorization request page includes the relevant content of the "Data Compliance Agreement" and two types of authorization request interaction elements. Among them, the first type of element 131 corresponds to the virtual button of "Agree", and the second type of element 132 corresponds to the virtual button of "Disagree". Specifically, the user can trigger an authorization operation for the first type of element, so that the terminal responds to the authorization operation, executes the startup task of the target application, and displays the main page of the target application when the startup task is completed.

[0159] Optionally, the terminal can also display an authorization request interaction element and determine whether the user agrees to authorize based on different types of trigger operations performed by the user on the authorization request interaction element. For example, clicking on the authorization request interaction element represents agreeing to authorize, and double-clicking on the authorization request interaction element represents refusing to authorize; another example is that long-pressing the authorization request interaction element represents agreeing to authorize, and tapping the authorization request interaction element represents refusing to authorize; yet another example is that dragging the authorization request interaction element to a specified position represents agreeing to authorize, otherwise it represents refusing to authorize, and so on.

[0160] It should be noted that in other embodiments, the terminal can also determine whether the user agrees to authorize based on different types of trigger operations performed by the user on the authorization request page. In this case, the authorization request interaction element is not necessary, and the terminal can display prompt information for different types of trigger operations, such as "Swipe left to represent agreement, swipe right to represent disagreement", "Click to represent agreement, double-click to represent disagreement", and so on.

[0161] In the above embodiments, the authorization request page displays the authorization request interaction element for system permissions. The terminal responds to the authorization operation triggered on the authorization request interaction element and displays the main page of the target application, which can improve the interaction convenience between the user and the terminal and enhance the user experience.

[0162] In one embodiment, the number of unauthorized system permissions in the unauthorized state is multiple; the authorization request page includes an authorization request sub-page corresponding to each unauthorized system permission. In the case of this embodiment, responding to the authorization operation triggered on the authorization request page and displaying the main page of the target application includes: displaying the authorization request sub-page for any unauthorized system permission; responding to the authorization operation triggered on the authorization request sub-page, changing the current permission status of the unauthorized system permission to the authorized state, and returning to the step of displaying the authorization request sub-page for any unauthorized system permission; and when all system permissions are in the authorized state, displaying the main page of the target application.

[0163] Specifically, when there are multiple unauthorized system permissions in the unauthorized state, the terminal can interact with the user separately by sequentially displaying the authorization request sub-pages of each unauthorized system permission, obtain the authorization of each unauthorized system permission one by one, and then, when the authorization of all system permissions is obtained, execute the startup task of the target application based on the original context object, and after the startup task is completed, display the main page of the target application.

[0164] In practical applications, as Figure 14 shown, the terminal can first display the authorization request sub-page for any unauthorized system permission, and when the authorization for this unauthorized system permission is obtained, change the current permission status of this unauthorized system permission to the authorized state and close this authorization request sub-page. Then, select any one from the remaining unauthorized system permissions to display the corresponding authorization request sub-page for the next round of interaction until all system permissions are in the authorized state. Further, as Figure 14 shown, the number of system permissions currently in the unauthorized state can also be displayed in the authorization request sub-page, such as "There are still A permissions waiting for authorization currently". Optionally, when the user triggers a rejection authorization operation for any system permission, the terminal can end the startup of the target application, or can also display the authorization request page for this system permission again to prompt the user for a second confirmation, and end the startup of the target application when the authorization operation is triggered for the second time.

[0165] In the above embodiments, when there are multiple unauthorized system permissions in the unauthorized state, by sequentially displaying the corresponding authorization request sub-pages of each unauthorized system permission to obtain authorization, it can ensure that the user is fully aware of the permission application situation of the target application, which is beneficial to further ensuring security.

[0166] It should be understood that although the steps in the flowcharts involved in the above-described embodiments are displayed sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless there is a clear description in this article, the execution of these steps has no strict order limit, and these steps can be executed in other orders. Moreover, at least a part of the steps in the flowcharts involved in the above-described embodiments may include multiple steps or multiple stages, and these steps or stages are not necessarily executed at the same time, but can be executed at different times, and the execution order of these steps or stages is not necessarily sequential, but can be executed alternately or alternately with at least a part of other steps or steps or stages in other steps.

[0167] Based on the same inventive concept, an embodiment of the present application further provides an application startup control device for implementing the above-mentioned application startup control method. The solution provided by this device for solving problems is similar to the solution described in the above method. Therefore, the specific limitations in one or more embodiments of the application startup control device provided below can refer to the limitations on the application startup control method in the foregoing, and will not be repeated here.

[0168] In one embodiment, as Figure 15 shown, an application startup control device is provided, including: a system permission determination module 1502, a proxy construction module 1504, an authorization request page loading module 1506, and a startup task execution module 1508, where:

[0169] The system permission determination module 1502 is configured to, in response to an application startup event triggered for a target application, create an original context object of the target application, and determine the system permissions that the target application expects to obtain during startup;

[0170] The proxy construction module 1504 is configured to, if the system permissions are in an unauthorized state, call the variable information of the original context object to construct a proxy context object corresponding to the original context object;

[0171] The authorization request page loading module 1506 is configured to load an authorization request page for the system permissions based on the proxy context object;

[0172] The startup task execution module 1508 is configured to, in response to an authorization operation triggered on the authorization request page, execute the startup task of the target application based on the original context object.

[0173] In one embodiment, the system permission determination module 1502 is specifically configured to: obtain the system permission dynamic file of the target application; read the system permissions that the target application expects to obtain during startup from the system permission dynamic file.

[0174] In one embodiment, the application startup control device further includes a permission status determination module, configured to: query the historical startup record of the target application; if it is determined based on the historical startup record that the target application is starting for the first time, determine that the system permissions are in an unauthorized state; if it is determined based on the historical startup record that the target application is not starting for the first time, obtain the current permission status of the system permissions; the current permission status includes an authorized state and an unauthorized state.

[0175] In one embodiment, the permission status determination module is specifically configured to: obtain the status flag of the system permission and determine the current permission status represented by the status flag. In the case of this embodiment, the application start control device further includes a status update module, configured to, when the current permission status is the unauthorized status, in response to an authorization operation triggered on the authorization request page, modify the current permission status from the unauthorized status to the authorized status.

[0176] In one embodiment, the variable information includes variable parameters and the variable values of the variable parameters. In the case of this embodiment, the proxy construction module 1504 includes: a proxy object construction unit, configured to load a proxy class file and construct a proxy object of the original context object; a variable information acquisition unit, configured to reflectively access the original context object and obtain the variable parameters of the original context object and the variable values of the variable parameters; an object assignment unit, configured to assign values to the proxy object based on the variable parameters and the variable values to obtain a proxy context object corresponding to the original context object.

[0177] In one embodiment, the object assignment unit is specifically configured to: change the access status of the variable parameters and the variable values to make the variable parameters and the variable values in an accessible state; call the variable parameters and the variable values in the accessible state to assign values to the proxy object to obtain a proxy context object corresponding to the original context object.

[0178] In one embodiment, the authorization request page loading module 1506 includes: a main thread task queue acquisition unit, configured to obtain the main thread task queue based on the original context object; the main thread task queue includes at least one task to be executed; a task replacement unit, configured to replace the task to be executed with an authorization page loading task based on the proxy context object; a page loading unit, configured to run the authorization page loading task to load an authorization request page for the system permission.

[0179] In one embodiment, the page loading unit is specifically configured to: cache the task to be executed in the system memory and delete the task to be executed in the main thread task queue; add the authorization page loading task based on the proxy context object to the main thread task queue. In the case of this embodiment, the start task execution module 1508 is specifically configured to: in response to an authorization operation triggered on the authorization request page, unload the proxy context object and add the task to be executed in the system memory to the main thread task queue; execute each task to be executed in the main thread task queue to complete the start task of the target application.

[0180] Each module in the above application startup control device can be implemented in whole or in part by software, hardware, or a combination thereof. Each of the above modules can be embedded in or independent of the processor in the computer device in the form of hardware, or stored in the memory of the computer device in the form of software, so that the processor can call and execute the operations corresponding to each of the above modules.

[0181] Based on the same inventive concept, an embodiment of the present application also provides an application startup display device for implementing the above-mentioned application startup display method. The solution provided by this device to solve the problem is similar to the solution described in the above method. Therefore, the specific limitations in one or more embodiments of the application startup display device provided below can refer to the limitations on the application startup display method in the above text, and will not be repeated here.

[0182] In one embodiment, as Figure 16 shown, an application startup display device is provided, including: an application element display module 1602, an authorization request page display module 1604, and a main page display module 1606, where:

[0183] The application element display module 1602 is used to display the application elements of the target application;

[0184] The authorization request page display module 1604 is used to display an authorization request page for the system permissions expected to be obtained during the startup process of the target application in response to an application startup event triggered for the application element; the authorization request page is loaded based on a proxy context object; the proxy context object is constructed by calling the variable information of the original context object of the target application when the system permissions are in an unauthorized state;

[0185] The main page display module 1606 is used to display the main page of the target application in response to an authorization operation triggered on the authorization request page; the main page is displayed when the startup task of the target application is completed based on the original context object.

[0186] In one embodiment, an authorization request interaction element for the system permissions is displayed on the authorization request page. In this case, the main page display module 1606 is specifically used to: display the main page of the target application in response to an authorization operation triggered for the authorization request interaction element.

[0187] In one embodiment, the number of unauthorized system permissions in the unauthorized state is multiple; the authorization request page includes authorization request sub-pages corresponding to each unauthorized system permission. In the case of this embodiment, the main page display module 1606 is specifically configured to: display the authorization request sub-page for any one of the unauthorized system permissions; in response to an authorization operation triggered on the authorization request sub-page, change the current permission state of the unauthorized system permission to the authorized state, and return to the step of displaying the authorization request sub-page for any one of the unauthorized system permissions; and in the case where all system permissions are in the authorized state, display the main page of the target application.

[0188] Each module in the above application startup display device can be implemented in whole or in part by software, hardware, and their combination. Each of the above modules can be embedded in the processor of the computer device in hardware form or be independent of it, or can be stored in the memory of the computer device in software form so that the processor can call and execute the operations corresponding to each of the above modules.

[0189] In one embodiment, a computer device is provided. The computer device can be a server, and its internal structure diagram can be as Figure 17 shown. The computer device includes a processor, a memory, an input / output interface (Input / Output, abbreviated as I / O), and a communication interface. Among them, the processor, the memory, and the input / output interface are connected through a system bus, and the communication interface is connected to the system bus through the input / output interface. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The database of the computer device is used to store the data involved in the implementation process of the above method. The input / output interface of the computer device is used to exchange information between the processor and external devices. The communication interface of the computer device is used to communicate with external terminals through a network connection. When the computer program is executed by the processor, it implements an application startup display method and an application startup control method.

[0190] In one embodiment, a computer device is provided. The computer device can be a terminal, and its internal structure diagram can be as Figure 18As shown in the figure. The computer device includes a processor, a memory, an input / output interface, a communication interface, a display unit, and an input device. Among them, the processor, the memory, and the input / output interface are connected through a system bus, and the communication interface, the display unit, and the input device are connected to the system bus through the input / output interface. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The input / output interface of the computer device is used to exchange information between the processor and external devices. The communication interface of the computer device is used to communicate with external terminals in a wired or wireless manner, and the wireless manner can be implemented through WIFI, a mobile cellular network, NFC (Near Field Communication), or other technologies. When the computer program is executed by the processor, it implements an application startup control method and an application startup display method. The display unit of the computer device is used to form a visually visible picture, which can be a display screen, a projection device, or a virtual reality imaging device. The display screen can be a liquid crystal display screen or an electronic ink display screen. The input device of the computer device can be a touch layer covering the display screen, or a button, a trackball, or a touchpad provided on the computer device housing, or an external keyboard, touchpad, or mouse, etc.

[0191] Those skilled in the art can understand that Figure 17 the structure shown in Fig. 5 or Fig. 18 is only a block diagram of some structures related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than those shown in the figure, or combine some components, or have different component arrangements.

[0192] In one embodiment, a computer device is provided, including a memory and a processor. A computer program is stored in the memory, and when the processor executes the computer program, the steps of the above method are implemented.

[0193] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by the processor, the steps of the above method are implemented.

[0194] In one embodiment, a computer program product is provided, including a computer program. When the computer program is executed by the processor, the steps of the above method are implemented.

[0195] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use, and processing of relevant data need to comply with the relevant laws, regulations, and standards of the relevant regions and areas. Moreover, the object can choose not to authorize the object information and relevant data, or can refuse or can conveniently refuse to push information, etc.

[0196] In this application, during the process of collecting and processing relevant data in practical applications, the informed consent or separate consent of the personal information subject should be obtained strictly in accordance with the requirements of relevant regional laws and regulations, and subsequent data use and processing behaviors should be carried out within the scope authorized by laws, regulations, and the personal information subject.

[0197] Those of ordinary skill in the art can understand that all or part of the processes in the methods of the above embodiments can be completed by instructing relevant hardware through a computer program. The computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above methods. Among them, any reference to a memory, database, or other medium used in the embodiments provided in the present application can include at least one of non-volatile and volatile memories. Non-volatile memories can include read-only memory (ROM), magnetic tapes, floppy disks, flash memories, optical memories, high-density embedded non-volatile memories, resistive random access memories (ReRAM), magnetoresistive random access memories (MRAM), ferroelectric random access memories (FRAM), phase change memories (PCM), graphene memories, etc. Volatile memories can include random access memory (RAM) or external cache memories, etc. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc. The databases involved in the embodiments provided in the present application can include at least one of relational databases and non-relational databases. Non-relational databases can include distributed databases based on blockchain, etc., without limitation. The processors involved in the embodiments provided in the present application can be general-purpose processors, central processors, graphics processors, digital signal processors, programmable logic devices, data processing logics based on quantum computing, etc., without limitation.

[0198] The technical features of the above embodiments can be combined arbitrarily. For the sake of concise description, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, it should be considered as the scope described in this specification.

[0199] The above-described embodiments only represent several implementation manners of the present application. The description is relatively specific and detailed, but it should not be construed as a limitation on the patent scope of the present application. It should be noted that for those of ordinary skill in the art, without departing from the concept of the present application, several modifications and improvements can still be made, and these all belong to the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the appended claims.

Claims

1. A method for controlling application startup, characterized in that, The method includes: In response to an application start event triggered for a target application, creating an original context object of the target application and determining system permissions that the target application expects to obtain during startup; If the system permissions are in an unauthorized state, then call the variable information of the original context object to construct a proxy context object corresponding to the original context object; Based on the proxy context object, load an authorization request page for the system permissions; In response to an authorization operation triggered on the authorization request page, execute the startup task of the target application based on the original context object.

2. The method according to claim 1, wherein The determining the system permissions that the target application expects to obtain during startup includes: Obtain the system permissions dynamic file of the target application; Read from the system permissions dynamic file the system permissions that the target application expects to obtain during startup.

3. The method according to claim 1, wherein The method further includes: Query the historical startup record of the target application; If it is determined based on the historical startup record that the target application is starting for the first time, then determine that the system permissions are in an unauthorized state; If it is determined based on the historical startup record that the target application is not starting for the first time, then obtain the current permission state of the system permissions; the current permission state includes an authorized state and an unauthorized state.

4. The method according to claim 3, wherein The obtaining the current permission state of the system permissions includes: Obtain the status flag of the system permissions and determine the current permission state represented by the status flag; The method further includes: In the case where the current permission state is an unauthorized state, in response to an authorization operation triggered on the authorization request page, modify the current permission state from the unauthorized state to the authorized state.

5. The method according to claim 1, wherein The variable information includes variable parameters and the variable values of the variable parameters; The calling the variable information of the original context object to construct a proxy context object corresponding to the original context object includes: Load a proxy class file and construct a proxy object of the original context object; Reflectively access the original context object to obtain the variable parameters of the original context object and the variable values of the variable parameters; Assign values to the proxy object based on the variable parameters and the variable values to obtain a proxy context object corresponding to the original context object.

6. The method according to claim 5, wherein The assigning values to the proxy object based on the variable parameters and the variable values to obtain a proxy context object corresponding to the original context object includes: Change the access status of the variable parameters and the variable values so that the variable parameters and the variable values are in an accessible state; Call the variable parameters and the variable values in the accessible state to assign values to the proxy object to obtain a proxy context object corresponding to the original context object.

7. The method according to claim 1, wherein The loading an authorization request page for the system permissions based on the proxy context object includes: Obtain the main thread task queue based on the original context object; at least one task to be executed is included in the main thread task queue; Replace the task to be executed with an authorization page loading task based on the proxy context object; Run the authorization page loading task to load an authorization request page for the system permissions.

8. The method according to claim 7, wherein The replacing the to-be-executed task with an authorization page loading task based on the proxy context object includes: Caching the to-be-executed task in the system memory and deleting the to-be-executed task in the main thread task queue; Adding an authorization page loading task based on the proxy context object to the main thread task queue; The responding to an authorization operation triggered on the authorization request page and executing the startup task of the target application based on the original context object includes: Responding to an authorization operation triggered on the authorization request page, unloading the proxy context object, and adding the to-be-executed task in the system memory to the main thread task queue; Executing each of the to-be-executed tasks in the main thread task queue to complete the startup task of the target application.

9. A method for application startup display, characterized in that, The method includes: Displaying application elements of a target application; Responding to an application startup event triggered for the application elements and displaying an authorization request page for system permissions expected to be obtained by the target application during startup; the authorization request page is loaded based on a proxy context object; the proxy context object is constructed by calling variable information of an original context object of the target application when the system permissions are in an unauthorized state; Responding to an authorization operation triggered on the authorization request page and displaying the main page of the target application; the main page is displayed when the startup task of the target application is completed based on the original context object.

10. The method according to claim 9, characterized in that, An authorization request interaction element for the system permissions is displayed on the authorization request page; The responding to an authorization operation triggered on the authorization request page and displaying the main page of the target application includes: Responding to an authorization operation triggered for the authorization request interaction element and displaying the main page of the target application.

11. The method according to claim 9, wherein The number of unauthorized system permissions in the unauthorized state is multiple; the authorization request page includes an authorization request sub-page corresponding to each of the unauthorized system permissions; The responding to an authorization operation triggered on the authorization request page and displaying the main page of the target application includes: Displaying an authorization request sub-page for any one of the unauthorized system permissions; Responding to an authorization operation triggered on the authorization request sub-page, changing the current permission state of the unauthorized system permission to the authorized state, and returning to the step of displaying the authorization request sub-page for any one of the unauthorized system permissions; Displaying the main page of the target application when all the system permissions are in the authorized state.

12. An application startup control device, characterized in that, The device includes: A system permission determination module, configured to respond to an application startup event triggered for a target application, create an original context object of the target application, and determine system permissions expected to be obtained by the target application during startup; A proxy construction module, configured to, if the system permissions are in the unauthorized state, call variable information of the original context object to construct a proxy context object corresponding to the original context object; An authorization request page loading module, configured to load an authorization request page for the system permissions based on the proxy context object; A start task execution module, configured to execute a start task of the target application based on the original context object in response to an authorization operation triggered on the authorization request page.

13. An application startup display device, characterized in that, The device includes: An application element display module, configured to display application elements of a target application; An authorization request page display module, configured to display an authorization request page for system permissions that the target application expects to obtain during startup in response to an application startup event triggered for the application elements; the authorization request page is loaded based on a proxy context object; the proxy context object is constructed by invoking variable information of the original context object of the target application when the system permissions are in an unauthorized state; A main page display module, configured to display the main page of the target application in response to an authorization operation triggered on the authorization request page; the main page is displayed when the start task of the target application is completed based on the original context object.

14. A computer device, comprising a memory and a processor, the memory storing a computer program, characterized in that, When the processor executes the computer program, the steps of the method according to any one of claims 1 to 11 are implemented.

15. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 11 are implemented.

16. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 11 are implemented.

Images