Target application calling methods, devices, and readable computer storage media
By generating structured intents and using intent mapping tables to determine path types and perform security checks, the problem of low operational efficiency and security risks in existing automotive diagnostic equipment is solved, enabling efficient and secure application invocation and routing distribution.
Patent Information
- Application Number
- CN202611190497.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-06
- Publication Date
- 2026-11-17
AI Technical Summary
Existing automotive diagnostic equipment is inefficient, requiring repair personnel to manually locate target settings or apps step by step, resulting in low diagnostic efficiency and the risk of network outages. Furthermore, it lacks a unified intent parsing and security verification mechanism, posing risks of unauthorized interface calls and illegal address access.
By generating structured intents, using intent mapping tables to determine path types and retrieve sub-tables, extracting target system interface identifiers, performing security checks, and constructing execution parameter packets, unified route distribution and security management are achieved.
It improves the consistency and maintainability of routing logic, effectively avoids the risks of unauthorized interface calls and illegal external address access, and improves the operational efficiency and security of diagnostic equipment.
Smart Images

Figure CN123114570A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of vehicle diagnostic technology, specifically to a target application invocation method, a vehicle diagnostic device, and a readable computer storage medium. Background Technology
[0002] In the daily use of automotive diagnostic equipment, in addition to performing professional diagnostic operations, repair personnel often have diverse equipment usage needs, such as adjusting screen brightness to adapt to the ambient light in the workshop, turning on a flashlight to illuminate the chassis, starting an oscilloscope to acquire waveforms, opening a browser to search for information, or using external tool apps, etc.
[0003] The inventors of this application discovered during their research that existing methods for operating diagnostic equipment require maintenance personnel to manually exit the diagnostic interface, enter the system settings or app list, and then gradually locate the target setting or app and click to execute. This method is inefficient in workshop settings, as maintenance personnel with gloves find it difficult to operate small icons, and disconnections can occur during multi-step diagnostic tasks, severely impacting diagnostic efficiency. Summary of the Invention
[0004] In view of the above problems, embodiments of this application provide a target application invocation method, a vehicle diagnostic device, and a readable computer storage medium to solve the above-mentioned technical problems existing in the prior art.
[0005] According to one aspect of the embodiments of this application, a method for invoking a target application is proposed, comprising: Obtain the invocation instruction and generate a structured intent based on the invocation instruction. The structured intent includes an intent identifier and slot key-value pairs. The execution path type and the corresponding mapping sub-table are determined in the preset intent mapping table based on the intent identifier. Based on the intent identifier and the slot key-value pair, extract the target system interface identifier from the mapping sub-table; The target system interface identifier is verified according to the execution path type; When the target system interface identifier verification passes, an execution parameter package is constructed based on the target system interface identifier; The target application is invoked according to the execution parameter package.
[0006] Preferably, in some embodiments, the intent mapping table includes a system settings mapping sub-table, an application call mapping sub-table, and a site redirection mapping sub-table; the execution path type includes system settings type, application call type, and site redirection type. The step of determining the execution path type and the corresponding mapping sub-table in a preset intent mapping table based on the intent identifier includes: Based on the intent identifier, the system settings mapping sub-table, the application call mapping sub-table, and the site jump mapping sub-table are searched one by one; When the system settings mapping sub-table matches the intent identifier, the execution path type is determined to be a system settings class, and the system settings mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type; When the application call mapping sub-table matches the intent identifier, the execution path type is determined to be an application call class, and the application call mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type; When the site redirection mapping sub-table matches the intent identifier, the execution path type is determined to be a site redirection type, and the site redirection mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type; If the intent identifier is not matched in the system settings mapping sub-table, the application call mapping sub-table, or the site redirection mapping sub-table, an unrecognized operation result is returned.
[0007] Preferably, in some embodiments, extracting the target system interface identifier from the mapping sub-table based on the intent identifier and the slot key-value pair includes: When the execution path type is system settings type, the target system interface identifier is extracted from the system settings mapping sub-table, and the parameters in the slot key-value pair are converted according to the preset parameter type based on the device's allowed range; When the execution path type is an application call class and the target system interface identifier is a self-developed application, a deep link template is extracted from the application call mapping sub-table, the functional module parameters in the slot key-value pair are filled into the deep link template, a deep link identifier is constructed, and the deep link identifier is used as the target system interface identifier. When the execution path type is a site redirection type, and the slot key-value pair contains a search term, the search term is encoded and filled into the address template in the site redirection mapping sub-table to construct a URL (Uniform Resource Locator) address, and the URL address is used as the target system interface identifier.
[0008] Preferably, in some embodiments, the method further includes: The deep link template shares parameterized routing fields with the vehicle functional domain navigation agent; When the functional module parameters require multi-step navigation, the vehicle functional domain navigation agent continues to process the interface instruction sequence after the deep link identifier jump.
[0009] Preferably, in some embodiments, the step of verifying the target system interface identifier according to the execution path type includes: When the execution path type is a system setting type, the target system interface identifier is compared with the executable system interface whitelist. If the target system interface identifier is not in the executable system interface whitelist, the verification is deemed to have failed. When the execution path type is an application call class, the application package name corresponding to the target system interface identifier is matched with the package name whitelist. If the application package name is not in the package name whitelist, the verification is deemed to fail. When the execution path type is a site redirection type, the domain name corresponding to the target system interface identifier is compared with the domain name whitelist. If the domain name is not in the domain name whitelist, the verification is deemed to have failed, and access is prohibited using URL addresses that are not part of the Hypertext Transfer Protocol or the Hypertext Transfer Security Protocol.
[0010] Preferably, in some embodiments, the execution parameter package includes an operation type and a target system interface identifier; The step of constructing the execution parameter package based on the target system interface identifier includes: When the execution path type is system setting type, the execution parameter package is constructed. The operation type in the execution parameter package is system setting, and the set value of the target system interface identifier is a value converted according to the preset parameter type. When the execution path type is an application call class, the execution parameter package is constructed. The operation type in the execution parameter package is application startup, and the target system interface identifier is the target application package name, an optional interface class name, or a deep link identifier. When the execution path type is a site redirection type, the execution parameter package is constructed, wherein the operation type in the execution parameter package is "open link" and the target system interface identifier is a Hypertext Transfer Security Protocol address.
[0011] Preferably, in some embodiments, the step of obtaining the invocation instruction and generating a structured intent based on the invocation instruction includes: Domain label recognition is performed on the invocation command; When the domain tag of the invocation instruction matches the system settings class, the structured intent is generated directly from the invocation instruction via a fast path. When the domain tag of the invocation instruction does not match the system settings class, the structured intent is generated by sequentially performing query preprocessing, semantic understanding, and task planning on the invocation instruction via the slow path.
[0012] Preferably, in some embodiments, the target application is invoked according to the execution parameter package, and the method further includes: If the call to the target application fails based on the execution parameter package, a fallback response is returned.
[0013] According to another aspect of the embodiments of this application, a vehicle diagnostic device is provided, including a processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other through the communication bus; The memory is used to store at least one program that causes the processor to perform the operation of the target application invocation method described in the above embodiments.
[0014] According to a third aspect of the embodiments of this application, a readable computer storage medium is provided, wherein the storage medium stores at least one program, which, when run on a vehicle diagnostic device, causes the vehicle diagnostic device to execute the target application invocation method described in the above embodiments.
[0015] In summary, this application's embodiments employ a unified routing and distribution mechanism based on intent identifiers. This mechanism searches through three mapping sub-tables one by one and determines the execution path type based on the hit result. The routing logic for the entire link from user intent to application call is centrally managed in the intent mapping table, eliminating the coupling problem of scattered maintenance of mapping logic by various modules. This allows the intent parsing results of the three types of operations to be accurately distributed to the corresponding sub-tables through a unified entry point, improving the consistency and maintainability of the routing logic. Furthermore, by employing a mechanism that compares and verifies the target system interface identifier using a whitelist based on different execution path types, targeted security checks are performed on the target interface identifier before constructing the execution parameter package. This achieves end-to-end security control of the call chain, effectively avoiding the risks of unauthorized interface calls and illegal external address access.
[0016] The above description is merely an overview of the technical solutions of the embodiments of this application. In order to better understand the technical means of the embodiments of this application and to implement them in accordance with the contents of the specification, and to make the above and other objects, features and advantages of the embodiments of this application more obvious and understandable, specific implementation methods of this application are described below. Attached Figure Description
[0017] The accompanying drawings are for illustrative purposes only and are not intended to limit the scope of this application. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings: Figure 1 The diagram illustrates the runtime architecture of the target application invocation method proposed in this embodiment. Figure 2 A flowchart of the target application invocation method proposed in an embodiment of this application is shown; Figure 3 This illustrates the mapping process from semantic understanding results to execution paths proposed in an embodiment of this application; Figure 4 This paper illustrates a schematic diagram of the target system interface identifier security verification process proposed in an embodiment of this application. Figure 5 This application illustrates a diagram showing the call relationship between a self-developed app and an embodiment of the application. Figure 6 This paper presents a schematic diagram of the overall flow of the target application invocation method proposed in an embodiment of this application; Figure 7 A schematic diagram of the vehicle diagnostic device structure proposed in an embodiment of this application is shown. Detailed Implementation
[0018] Exemplary embodiments of the present application will now be described in more detail with reference to the accompanying drawings. Although exemplary embodiments of the present application are shown in the drawings, it should be understood that the present application may be implemented in various forms and should not be limited to the embodiments set forth herein.
[0019] In existing automotive diagnostic equipment, some devices provide simple voice command support, but they usually only cover a limited number of preset commands (such as "turn on the flashlight"), cannot understand variations of natural language expressions (such as "turn on the lights" or "turn the lights up"), and cannot handle commands that require parameterization (such as "adjust the brightness to 80%)." Furthermore, they lack complete mapping and execution capabilities for app launches and website access.
[0020] Besides the methods mentioned above, hard-coded rules can also be used, binding fixed NLP terms to system operations through front-end hard coding. However, this method has a limited number of rules, requires code changes for adding new operation types, is difficult to maintain, and cannot cover the diverse needs of diagnostic scenarios (such as launching a self-developed tool app or quickly accessing diagnostic result-related websites). Some implementations treat "system settings," "app launch," and "site access" as front-end logic, implementing them independently. This disconnects them from the overall multi-agent orchestration system (the diagnostic orchestration server connects semantic understanding, task planning, and agents), making it impossible to use a unified intent understanding, context memory, security verification, and degradation protection mechanism.
[0021] The applicant also found that in the above implementation methods, different types of operation targets (such as system settings, application startup, or site redirection) differ significantly in interface specifications, parameter formats, and execution semantics. Existing solutions lack a unified routing and distribution mechanism for path types, resulting in the mapping logic between intent parsing results and target interfaces being scattered across various modules, making it difficult to reuse and maintain. Furthermore, existing solutions lack a security verification step for target interface identifiers during the conversion of intent parsing results into system call parameters, posing a risk of calling unauthorized system interfaces, launching unauthorized application packages, or accessing illegal external addresses. This makes it difficult to meet security control requirements in a restricted in-vehicle execution environment, posing a security risk.
[0022] In view of this, embodiments of this application propose a method for invoking a target application, a vehicle diagnostic device, and a readable computer storage medium. By parsing the natural language invoking command input by the user, a structured intent is generated. Based on the structured intent and driven by an awareness identifier, the execution path type and mapping sub-table are determined by retrieving from the intent mapping table. Furthermore, the target system interface identifier is extracted from the mapping sub-table based on the structured intent, achieving unified routing and distribution of user invoking commands and improving the consistency and maintainability of the routing logic. Simultaneously, to enhance the security of system calls, embodiments of this application also perform security verification on the target system interface identifier. A targeted security review of the target interface identifier is conducted before constructing the execution parameter package, effectively avoiding the risks of unauthorized interface calls and illegal external address access.
[0023] like Figure 1 The diagram shown is an operational architecture diagram of an embodiment of this application. The target application invocation method proposed in this embodiment runs in a multi-Agent orchestration system. This system consists of two main logical partitions: the client side and the diagnostic orchestration server side. The system application agent serves as the core functional node, responsible for routing, verifying, and constructing execution parameters for structured intents.
[0024] The following are Figure 1 The logical partitions and data flow directions shown are described in detail to clarify the link position of the embodiments of this application in the overall architecture.
[0025] Please refer to Figure 1The client side comprises two sub-parts: a diagnostic app and a system layer. These two parts work together to receive user commands and execute final system calls. The diagnostic app serves as the interaction entry point between the user and the multi-agent orchestration system. It receives user voice or touch commands and sends requests to the diagnostic orchestration server via a long connection or equivalent communication channel. Simultaneously, as a client implementation of the Model Context Protocol (MCP) tool, the diagnostic app responds to MCP tool call commands issued by the diagnostic orchestration server, forwards execution parameter packets to the system layer for processing, and sends the execution results returned by the system layer back to the diagnostic orchestration server. The system layer is the underlying execution component on the client side, directly interacting with the system service interfaces of the in-vehicle operating system. It undertakes the actual system call execution responsibilities, including system API calls (for system setting operations), application startup Intent triggers (for application call operations), and URL openings (for site redirection operations). The execution results of the system layer are collected by the diagnostic app and sent back to the orchestration server, completing the execution loop. After the execution parameter package is sent to the diagnostic app via a long-lived connection or equivalent channel between the diagnostic orchestration server and the client, the diagnostic app calls the corresponding system interface at the system layer (system API, Intent, or URL to open the interface) to complete the actual system call operation. The system layer returns the execution result to the diagnostic app, which then sends the execution result back to the system application agent via the communication channel. The agent summarizes the execution results, constructs the final response, and returns it to the user via the orchestration server.
[0026] The diagnostic orchestration server logically unifies functions such as communication access and authentication, rate limiting, fast and slow path orchestration, and agent scheduling. At the engineering deployment level, these functions can be deployed layered on independent physical nodes or co-located within the same service process as needed. This application does not mechanically limit the physical deployment form; the following description is based on logical functions. Specifically, the communication access and authentication stage is responsible for authenticating and verifying permissions of long connections or equivalent channels established by clients, ensuring that only authorized diagnostic app instances can access the orchestration service. The rate limiting stage constrains the request frequency per unit time to prevent high-concurrency calls from overloading downstream agents and the system layer. The fast and slow path orchestration stage routes high-frequency system setting intents to fast paths and application call and site redirection intents to slow paths based on the domain label recognition results of the call instructions.
[0027] The system uses an Agent as the core execution node, undertaking the full responsibilities of maintaining the intent mapping table, routing execution paths, performing path-by-path security checks, and constructing execution parameters within the multi-Agent orchestration system. The Agent internally maintains the intent mapping table, which is loaded into memory from the configuration file during Agent initialization and accessed at runtime. After receiving a structured intent routed from the orchestration server, the Agent sequentially performs the following steps: determining the execution path type, extracting the target system interface identifier, performing path-by-path security checks, and constructing the execution parameter packet. The constructed execution parameter packet is then encapsulated using the MCP protocol and sent to the diagnostic orchestration server, which forwards it to the diagnostic APP for execution via the communication channel between the client and server.
[0028] exist Figure 1 In the process, when the system application agent detects a failure in the execution loop of the target application call, it triggers a fallback path and bypasses the large model fallback module. The large model generates a natural language fallback response based on the original call instruction and the failure context, which is then orchestrated by the server and returned to the user. This ensures that the user can still receive clear natural language feedback in the event of a call failure, rather than a state of no response.
[0029] based on Figure 1 The multi-agent orchestration system shown in this application illustrates the target application invocation method proposed in this embodiment. Figure 2 As shown, the method includes: Step S100: Obtain the invocation instruction and generate a structured intent based on the invocation instruction. The structured intent includes an intent identifier and slot key-value pairs. After receiving a call instruction from a repair technician, the diagnostic app performs semantic processing on the instruction and outputs a structured intent. The call instruction can be natural language input from the user, such as "Turn up the brightness a little" or "Open Chrome and check P0171," etc. After being processed by voice recognition or text input, it is reported to the diagnostic orchestration server via a server-side communication connection.
[0030] The structured intent is a standardized semantic representation of the original invocation command. Its data structure contains at least two core fields: Intent ID and Slot Key-Value pairs. The Intent ID is a unique semantic encoding of the user's operation purpose, such as "OPEN_NAVIGATION", "SET_VOLUME", "OPEN_URL", etc., which is predefined by the intent parsing module during offline training and dynamically matched at runtime. The Slot Key-Value pairs carry parameter information in the invocation command, such as the target application name, functional module, numerical parameters, or search terms, and are stored in key-value pair format to support subsequent path branching processing.
[0031] Step S200: Determine the execution path type and the corresponding mapping sub-table in the preset intent mapping table according to the intent identifier; The intent mapping table is the core data structure of this application embodiment. It is loaded into memory by the configuration file during system initialization and accessed in read-only mode. The execution path types include system settings, application calls, and site redirects. The intent mapping table is divided into three sub-tables based on the execution path type: a system settings sub-table, an application call sub-table, and a site redirection sub-table. The intent identifier sets in these three sub-tables are mutually exclusive, ensuring unique routing results. The system sequentially searches the three sub-tables based on the intent identifier, determining the execution path type and valid mapping sub-table based on the match result; if none of the three sub-tables are matched, an unrecognized operation result is returned.
[0032] Figure 3 This illustrates the classification and mapping process from semantic understanding results to three types of execution paths. Figure 3 In the middle, the left side shows the structured semantic results, including: domain, action intent, and slots; the middle section contains three sub-mapping tables: system settings mapping sub-table (action -> system interface and parameter type), application call mapping sub-table (target application alias -> package name and optional interface), and site redirection mapping sub-table (site alias -> address template); the right side shows three types of execution paths: system settings, application call, and site redirection, with the action name, target application alias, and site alias triggering matching in their respective sub-tables. Figure 3 In the diagram, a one-way arrow from left to right indicates a match-derivative relationship.
[0033] Tables 1, 2, and 3 below show the example data structures of the system settings mapping sub-table, application call mapping sub-table, and site redirection mapping sub-table, respectively.
[0034] Table 1
[0035] Table 1 shows the structure of the system settings mapping sub-table. The intent identifier corresponds to the action name; that is, the intent identifier corresponds to system-level configuration changes, such as `set_brightness` (brightness), `set_volume` (volume), `toggle_flashlight` (flashlight), `toggle_wifi` (Wi-Fi), `toggle_bluetooth` (Bluetooth), etc.; the execution method corresponds to the target system interface identifier, such as calling Android system APIs (e.g., `Settings.System.putInt`, `AudioManager.setStreamVolume`, etc.). The device allowed range is used to limit the type and range of parameters.
[0036] Table 2
[0037] Table 2 shows the structure of the application call mapping sub-table. The intent corresponds to the start / stop / switch of the APP, such as open_app (open the application) and close_app (close the application). The execution method is to construct AndroidIntent through the target application alias and initiate the call through startActivity / startService. For functional modules within a self-developed APP, the interface class name or Deep Link parameter can be attached.
[0038] Table 3
[0039] Table 3 shows the structure of the site redirection mapping sub-table. The intent corresponds to opening the target URL in the browser or WebView, such as open_website (open website) or web_search (web search). The execution method is to convert the target site identifier or search term slot into a compliant URL and open it through ACTION_VIEW Intent or a specified WebView.
[0040] Based on the above settings, when determining the execution path type and mapping sub-table according to the intent identifier, the system settings mapping sub-table, the application call mapping sub-table, and the site jump mapping sub-table are searched one by one according to the intent identifier.
[0041] When searching the sub-tables, a hash lookup is first performed in the system settings mapping sub-table using the intent identifier as the key. If no match is found, a hash lookup is performed in the application call mapping sub-table. If still no match is found, a hash lookup is performed in the site redirect mapping sub-table. The search terminates once any sub-table is found. The search order is designed based on a comprehensive consideration of operation frequency and security priority: system settings operations directly affect the device hardware status and are placed first for priority control; application call operations are next; site redirect operations involve external network access and are placed last to ensure that the external address resolution process is triggered only after the first two categories have failed to find a match.
[0042] When the system settings mapping sub-table matches the intent identifier, the execution path type is determined to be a system settings class, and the system settings mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type.
[0043] When the application call mapping sub-table matches the intent identifier, the execution path type is determined to be an application call class, and the application call mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type.
[0044] When the site redirection mapping sub-table matches the intent identifier, the execution path type is determined to be a site redirection type, and the site redirection mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type.
[0045] When the intent identifier is not matched in the system settings mapping sub-table, the application call mapping sub-table, and the site redirection mapping sub-table, an unrecognized operation result is returned to the diagnostic orchestration server. The diagnostic orchestration server then triggers a fallback response strategy, such as providing the user with a "current operation is not supported" message. At the same time, the unmatched intent identifier is recorded for reference in subsequent operation iterations.
[0046] As can be seen from the above, in this embodiment, since the intent identifier sets of the three mapping sub-tables are mutually exclusive, and the table-by-table retrieval order is fixed and terminates upon any hit, the routing result is unique and deterministic, eliminating the possibility of ambiguous hits of intent identifiers across multiple sub-tables. Centralized configuration management of the three sub-tables allows adding new intent entries to only require adding configuration items to the corresponding sub-table, without modifying the business logic code, significantly improving the scalability and maintainability of the routing rules. The degradation handling strategy when all sub-tables are not hit ensures the integrity of the user experience in unknown intent scenarios.
[0047] Step S300: Extract the target system interface identifier from the mapping sub-table based on the intent identifier and the slot key-value pair; After determining the execution path type and its corresponding mapping sub-table, the system extracts the target system interface identifier from the mapping sub-table, using the intent identifier as the primary key and the slot key-value pairs as auxiliary parameters. The target system interface identifier is a string or identifier used to identify a specific system API, indicating which specific system API the system application agent needs to call to execute the user's requested operation. The extraction logic for the target system interface identifier differs for different execution path types: for system settings, the system settings mapping sub-table is directly retrieved, and the slot parameters are converted according to the device's allowed range; for application invocation, a deep link identifier is constructed using a deep link template when the target is a self-developed application; for site redirection, the search terms are encoded and filled into the address template to construct a Hypertext Transfer Security Protocol (HTTP) address.
[0048] The inventors of this application discovered during their research that, when extracting target system interface identifiers, they encounter three types of execution paths with significant differences in interface representation and parameter semantics: interface parameters for system settings need to be converted from user semantic space (e.g., percentages) to device hardware space (e.g., level integer values); application call types require precise functional module-level jumps to self-developed applications via deep link templates, rather than simply launching the application's main interface; and site jump types require encoding of search terms containing special characters to construct valid addresses. If a unified extraction logic is used for these three types of paths, it cannot meet the differentiated requirements of each path in terms of interface parameter format and security construction.
[0049] In view of this, the embodiments of this application further refine step S300, specifically including: When the execution path type is system settings type, the target system interface identifier is extracted from the system settings mapping sub-table, and the parameters in the slot key-value pair are converted according to the preset parameter type based on the device's allowed range; In addition to the mapping relationship between intent identifier and system interface identifier, each record in the system settings mapping sub-table (such as Table 1) also stores the parameter type descriptor and device allowed range corresponding to that interface, so as to verify the parameter type and parameter range. The parameter type descriptor defines the data type (integer, floating point, enumeration, etc.) and unit conversion rules of the parameter; the device allowed range defines the legal value range of the parameter, for example, the device allowed range for the volume parameter is [0, 15].
[0050] Because a parameter conversion mechanism is used for system settings, the parameter values (such as percentages) entered by the user in the semantic space can be accurately mapped to legal integer values within the range allowed by the device hardware. This ensures the compliance of the interface parameter format and prevents the risk of writing out-of-bounds parameters into the device registers through clamping operations.
[0051] When the execution path type is an application call class and the target system interface identifier is a self-developed application, a deep link template is extracted from the application call mapping sub-table, the functional module parameters in the slot key-value pair are filled into the deep link template, a deep link identifier is constructed, and the deep link identifier is used as the target system interface identifier.
[0052] In the application call mapping sub-table, records for self-developed applications store parameterized deep link templates in addition to the application package name. The system extracts functional module parameters from slot key-value pairs, binds parameters according to the field names of the template placeholders, and obtains the complete deep link identifier after replacement, which is then used as the target system interface identifier. Because a deep link template parameter binding mechanism is used for application call classes, the system can directly route user intents to specific functional interfaces of the target application, rather than just launching the application's main interface, thus improving the accuracy of intent execution.
[0053] When the execution path type is a site redirection type, and the slot key-value pair contains a search term, the search term is encoded and filled into the address template in the site redirection mapping sub-table to construct a URL address, and the URL address is used as the target system interface identifier.
[0054] Each record in the site redirection mapping sub-table stores the mapping relationship between the intent identifier and the address template. The address template is a Hypertext Transfer Protocol (HTTP) URL template containing query parameter placeholders, such as "https: / / search.example.com / search?q=\{query\}". When the slot key-value pair contains a search term, the system performs percent encoding on the search term, fills the corresponding placeholder in the address template with the encoded search term, constructs a complete HTTP URL, and uses it as the target system interface identifier. Percent encoding is necessary because search terms may contain Chinese characters, spaces, or special symbols. Directly concatenating these into the address template would result in an invalid address format and pose an injection risk.
[0055] By employing percent-encoding and address template filling mechanisms for site redirects, special characters in search terms are securely escaped, constructing a valid Hypertext Transfer Security Protocol (HTTP) address. This provides a standardized input for subsequent domain whitelist verification, effectively preventing address injection risks.
[0056] Step S400: Verify the target system interface identifier according to the execution path type; Based on the determined execution path type, select the corresponding whitelist to perform security verification on the target system interface identifier to prevent unauthorized calls to interfaces or access to illegal addresses.
[0057] Because different execution path types have fundamental differences in the representation of interface identifiers and security threat models, a uniform verification strategy cannot specifically address the security risks of each path. Therefore, in this embodiment, the three types of paths are verified against independent whitelists: system settings are verified against the whitelist of executable system interfaces; application calls are verified against the whitelist of package names; and site redirects are verified against the whitelist of domain names, with additional mandatory protocol type checks.
[0058] like Figure 4 The diagram illustrates a hierarchical verification method for the target system interface identifier according to an embodiment of this application. It aims to address the control requirements for differentiated security threats along various paths by combining a path-by-path independent whitelist with mandatory protocol checks.
[0059] Specifically, such as Figure 4 As shown, step S400 further includes: Step S401: Determine the operation type and select different verification paths and methods for different operation types.
[0060] Step S402: Execute the path type as system settings; When the execution path type is a system settings type, the target system interface identifier is compared with the executable system interface whitelist. If the target system interface identifier is not in the executable system interface whitelist, the verification is deemed to have failed.
[0061] When the execution path type is system settings, an API whitelist check is performed first. This involves checking the whitelist of executable system interfaces and listing the system settings items that are allowed to be changed (such as brightness, volume, flashlight, etc.). System APIs not on the whitelist are not executed. The executable system interface whitelist is pre-stored in a read-only storage partition at the time of system shipment and supports updates via OTA firmware upgrades. The whitelist content is stored as a hash set of interface identifiers to improve comparison efficiency. During verification, the system calculates the hash value of the target system interface identifier and performs a member lookup in the whitelist hash set. If the target system interface identifier is not in the whitelist set, the verification fails, a security audit log is recorded, and an "interface unauthorized" error code is returned to the upper-layer module. By explicitly enumerating all allowed interface identifiers in the whitelist, the system implements minimum permission control for system settings operations. If the API whitelist check passes, the parameter range check continues; otherwise, the process jumps to step S405 and returns a security denial.
[0062] After passing the API whitelist check, the parameter range is checked, and a valid range is set for numerical parameters (such as brightness and volume values). If a parameter is out of range, it is truncated to the boundary value and the user is notified.
[0063] After passing the parameter range check, a sensitive API interception check is performed. For sensitive system APIs (such as factory mode settings, security policy changes, etc.), regardless of the user's expression, they are not mapped or executed, and the process directly proceeds to step S405. These sensitive APIs are explicitly excluded from the whitelist to ensure that they will not be accidentally manipulated due to user requests. If the verification passes, proceed to step S406; otherwise, proceed to step S405.
[0064] Step S403: The execution path type is application call class; When the execution path type is an application call class, the application package name corresponding to the target system interface identifier is matched with the package name whitelist. If the application package name is not in the package name whitelist, the verification is deemed to fail.
[0065] When the execution path type is an application call class, a package name whitelist check is performed first, with application call class verification controlled by the application package name. When the target system interface identifier is an application package name, a direct string matching is performed in the package name whitelist. When the target system interface identifier is a deep link identifier, the system first parses the corresponding application package name (i.e., the registered package name corresponding to the scheme or host of the deep link URI) from the deep link identifier, and then performs a package name whitelist comparison. If the application package name is not in the package name whitelist, the verification fails, and the process jumps to step S405, prohibiting the application's startup request and recording a security audit log. The package name whitelist is a list of pre-installed and security-reviewed application package names pre-configured by the vehicle OEM during the system integration phase and is maintained synchronously with OTA updates to ensure the continuous consistency of the whitelist with the in-vehicle application ecosystem.
[0066] After passing the package name whitelist check, a critical process protection check is performed. For example, closing critical system services (such as the diagnostic core process and network services) is not allowed. The list of critical processes is also maintained in the whitelist, and any request to close these critical processes will be rejected. If the critical process protection check fails, proceed to step S405.
[0067] If the critical process protection verification passes, the self-developed APP will be verified, and the use of deep_link will be restricted. The use of DeepLink or interface paths is limited to the self-developed APP (which can be distinguished by the self-developed identifier). If the verification passes, proceed to step S406; otherwise, proceed to step S405.
[0068] Step S404: Execute the path type as site redirection; When the execution path type is a site redirection type, the domain name corresponding to the target system interface identifier is compared with the domain name whitelist. If the domain name is not in the domain name whitelist, the verification is deemed to have failed, and access to addresses that are not part of the Hypertext Transfer Protocol or the Hypertext Transfer Security Protocol is prohibited.
[0069] When the execution path type is a site redirection type, firstly, the domain name part is extracted from the target system interface identifier, and exact matching or subdomain wildcard matching is performed in the domain name whitelist. If the domain name is not in the whitelist, the verification is determined to fail, and the process proceeds to step S405.
[0070] Secondly, a mandatory check is performed on the address protocol type, allowing only Hypertext Transfer Protocol (HTTP) and Hypertext Transfer Security Protocol (HTTPS) addresses to pass through. Other protocol types (such as file: / / , ftp: / / , javascript: / / , etc.) are strictly prohibited from accessing the address to prevent protocol injection attacks. If the check fails, proceed to step S405.
[0071] Finally, the search term encoding is checked to prevent injection and ensure search term security. If the check passes, proceed to step S406; otherwise, proceed to step S405.
[0072] Step S405: Return to security denial; If any of the security checks for the above execution path types fails, a security rejection will be returned, and a rejection and orchestration degradation prompt will be displayed.
[0073] Step S406: Perform the operation; Once all the security checks for the above execution path types pass, the execution node will be entered.
[0074] The above embodiments construct an end-to-end security defense through three independent verification mechanisms: system-level whitelist verification prevents unauthorized manipulation of hardware status; application call-level package name whitelist verification prevents the launch of non-pre-installed or unreviewed applications; and the combination of site redirection-level domain name whitelist and mandatory protocol checks prevents in-vehicle browsers from being redirected to malicious external addresses or subjected to protocol injection attacks. Since each verification is based on an independent whitelist, centralized configuration and management of the whitelists allow security policy updates to be made without modifying business logic, effectively separating security policies from execution logic and improving the maintainability and scalability of security control.
[0075] Step S500: When the target system interface identifier verification passes, construct an execution parameter packet based on the target system interface identifier; After successful verification, the system constructs an execution parameter package according to a preset format based on the execution path type and the target system interface identifier. This execution parameter package is a standardized invocation carrier for downstream executors, and its structure includes at least an operation type field and a target system interface identifier field. This standardized encapsulation of the execution parameter package allows downstream executors to distribute execution only according to the operation type field, without needing to be aware of intent parsing details, thus decoupling the semantic processing layer from the underlying invocation execution layer.
[0076] When the execution path type is a system settings class, the execution parameter package is constructed. In the execution parameter package, the operation type is system settings, and the target system interface identifier is set to a value converted according to a preset parameter type. The structure of the system settings class execution parameter package is: operationType: "SYSTEM_SETTING", interfaceId: <system interface identifier>, value: v_target, where the operationType field is fixed at "SYSTEM_SETTING", the interfaceId field is the target system interface identifier extracted from the system settings mapping sub-table, and the value field is the target parameter value. After receiving this execution parameter package, the downstream executor calls the corresponding system settings service interface and passes in the value field value to complete the writing of system parameters.
[0077] When the execution path type is an application call class, the execution parameter package is constructed. The execution parameter package contains the operation type "application launch," the target system interface identifier "target application package name," and an optional interface class name or deep link identifier. The structure of the application call class execution parameter package is: operationType: "APP_LAUNCH", packageName: <application package name>, activityName: <optional interface class name>, deepLink: <optional deep link identifier>. For direct launch of third-party applications, the execution parameter package includes packageName and an optional activityName; for deep link calls of self-developed applications, the execution parameter package includes packageName and deepLink fields, and the application launch interface routes the application to the corresponding functional interface based on the deepLink field.
[0078] When the execution path type is a site redirection type, the execution parameter package is constructed. The operation type in the execution parameter package is "Open Link," and the target system interface identifier is a Hypertext Transfer Protocol (HTTP) address. The structure of the site redirection type execution parameter package is: operationType: "OPEN_URL", url: <HTTP address>. After receiving this execution parameter package, the downstream executor calls the link open interface of the in-vehicle WebView component or the system browser application, and passes in the url field value to complete the redirection to the external site.
[0079] The above approach, by adopting a standardized structure that includes an operation type field in the execution parameter package, allows downstream executors to select the processing branch based solely on the enumerated value of the operationType field. They do not need to be aware of the details of upstream intent parsing, path routing, or interface identifier construction. This achieves interface decoupling between the intent semantic processing layer and the underlying system call execution layer, reducing the overall maintenance cost and change risk of the system.
[0080] Step S600: Invoke the target application according to the execution parameter package; The system application agent submits the execution parameter package to the diagnostic app, which then distributes the call request to the corresponding system service interface based on the operation type field: system settings calls the system settings service interface; application calls the application startup interface; site redirections call the in-vehicle browser or WebView component to open the link. If the call fails, a fallback response mechanism is triggered. In summary, this application's embodiments employ a unified routing and distribution mechanism based on intent identifiers. This mechanism searches through three mapping sub-tables one by one and determines the execution path type based on the hit result. The routing logic for the entire link from user intent to application call is centrally managed in the intent mapping table, eliminating the coupling problem of scattered maintenance of mapping logic by various modules. This allows the intent parsing results of the three types of operations to be accurately distributed to the corresponding sub-tables through a unified entry point, improving the consistency and maintainability of the routing logic. Furthermore, by employing a mechanism that compares and verifies the target system interface identifier using a whitelist based on different execution path types, targeted security checks are performed on the target interface identifier before constructing the execution parameter package. This achieves end-to-end security control of the call chain, effectively avoiding the risks of unauthorized interface calls and illegal external address access.
[0081] Furthermore, the inventors of this application have also discovered that, in the structured intent generation stage, system setting instructions (such as increasing volume, turning off Bluetooth, etc.) have the characteristics of limited semantic space and regular lexical form. If the same level of query preprocessing, deep semantic understanding and task planning process as application call instructions and site jump instructions is applied to them, it will cause unnecessary computational overhead and affect the response delay of system setting operations. On the other hand, application call instructions and site jump instructions have complex semantics and high ambiguity. If structured intents are generated directly without sufficient semantic understanding and task planning, the parsing accuracy is difficult to guarantee.
[0082] In view of this, embodiments of this application also propose a fast-slow path processing method for invocation instructions to achieve a good balance between system processing efficiency and intent analysis accuracy, such as... Figure 1 As shown.
[0083] First, the diagnostic orchestration server performs domain label recognition on the invocation commands. Lightweight text classification is performed on the original invocation commands to generate domain labels, categorizing the commands into a predefined domain label set. This set includes at least system setting commands and non-system setting commands (including application invocation commands and site redirection commands). Domain label recognition employs a combination strategy of rule-based keyword matching and a lightweight classification model: for system setting commands with regular forms and fixed vocabulary, rule matching can output domain labels with high confidence; for commands with complex semantics or high ambiguity, the lightweight classification model outputs the domain label with the highest confidence. The computational overhead of domain label recognition is far lower than the complete semantic understanding process, thus providing a low-latency response channel for system setting commands.
[0084] like Figure 1 As shown, when the domain label of the invocation command matches the system settings class, the structured intent is directly generated from the invocation command via the fast path. When the domain label recognition result is a system settings class, the system triggers the fast path processing flow. The fast path, based on a pre-compiled system settings intent parsing template, directly extracts the intent identifier and slot key-value pairs from the invocation command to generate a structured intent, without going through time-consuming steps such as query preprocessing, deep semantic understanding, and task planning. The design basis of the fast path is that the semantic space of system settings class commands is limited and relatively fixed, and the intent identifier set and slot structure can be fully enumerated during the system design phase. Therefore, all legal inputs can be covered by the pre-compiled template, achieving deterministic high-speed parsing.
[0085] Continue to refer to Figure 1 When the domain label of the invocation command does not match the system settings class, the system generates the structured intent by sequentially performing query preprocessing, semantic understanding, and task planning on the invocation command via the slow path. When the domain label recognition result does not belong to the system settings class, the system triggers the slow path processing flow, sequentially performing query preprocessing, semantic understanding, and task planning.
[0086] In the slow path processing, during the query preprocessing stage, the system performs text normalization processing on the call command (including word segmentation, noise reduction, and reference resolution) and outputs standardized query text. During the semantic understanding stage, the system inputs the standardized query text into the deep semantic understanding model and outputs the probability distribution of intent identifiers and the slot candidate set. During the task planning stage, the system performs confidence filtering and ambiguity resolution based on the probability distribution of intent identifiers and the slot candidate set, selects the intent identifier with the highest confidence from multiple intent candidates, and completes the final determination of slot key-value pairs, outputting structured intent.
[0087] The slow path uses deep semantic understanding and task planning mechanisms to handle semantically complex call commands, ensuring high accuracy in parsing application call classes and site jump classes. At the same time, its higher computational overhead only affects commands other than system settings classes and does not affect the response latency of system settings class commands.
[0088] Therefore, this application's embodiments employ a domain-label-driven fast / slow path routing mechanism. High-frequency, low-complexity system setting instructions are generated using the fast path with extremely low latency, while low-frequency, high-complexity application call and site redirection instructions are resolved using the slow path, ensuring high parsing accuracy. This achieves on-demand allocation of computing resources during the intent generation phase. Compared to a scheme that applies a complete semantic understanding process to all call instructions uniformly, the introduction of the fast path significantly reduces the end-to-end response latency of system setting operations without compromising parsing accuracy.
[0089] Furthermore, in some embodiments, for the case of a self-developed APP call when the execution path type is an application call class, in Figure 5 The text provides a detailed explanation. Figure 5 The diagram illustrates the parametric routing reuse relationship between the self-developed APP call and the vehicle function domain navigation (vehicle_function).
[0090] exist Figure 5 In this context, when the target application's record in the application call mapping sub-table does not contain a deep link template field, the system application agent adopts a root interface launch strategy: using the target application package name as the target system interface identifier, an execution parameter package is constructed and sent to the client via MCP. The client then calls the application launch Intent to route the target application to its main interface (root Activity). The root interface launch strategy is suitable for scenarios where the user's intent is simply "to open an application" without specifying a particular functional module, resulting in the shortest execution chain and the lowest response latency.
[0091] When the target application in the application call mapping table is a self-developed APP, and the slot key-value pairs carry functional module parameters, the system application agent adopts a Deep Link direct access strategy. It extracts the deep link template from the application call mapping table, binds the functional module parameters in the slot key-value pairs according to the template placeholder field names, constructs a complete deep link identifier, and uses this deep link identifier as the target system interface identifier to construct the execution parameter package, which is then sent to the client via MCP. The client calls the application startup Intent and passes in the deep link identifier. The routing module of the target self-developed application parses the deep link path and directly routes the interface to the corresponding functional module entry point, eliminating the need for the user to manually navigate through the root interface.
[0092] Continue to refer to, for example Figure 5When there are subtasks requiring multiple interface operations under the functional module entry point pointed to by the deep link, i.e. when intra-module navigation is required, the deep link template and the vehicle functional domain navigation agent share parameterized routing fields and client execution protocols. After the system application agent completes the deep link distribution, it transfers the remaining interface instruction sequence to the vehicle functional domain navigation agent for further processing, forming a collaborative mode of "deep link entry jump followed by subsequent orchestration".
[0093] To achieve field sharing between the deep link template and the vehicle functional domain navigation agent, in this embodiment, the placeholder field names in the deep link template are strictly consistent with the parameter key names in the routing parameter table of the vehicle functional domain navigation agent. When the system application agent routes the application to a certain functional module entry point through the deep link, the vehicle functional domain navigation agent can directly parse the routing field values from the deep link URI path without requiring the system application agent to perform additional parameter format conversion or secondary transmission. This eliminates the parameter adaptation layer between the two agents and reduces the interface complexity of collaborative calls.
[0094] Figure 6 This application presents a schematic diagram of the overall flow of the target application invocation method according to an embodiment of the present application. Based on the above embodiment, the target application invocation method is described in detail, specifically including: Step S701: Generate structured intent; The diagnostic orchestration server receives natural language input from the diagnostic app and performs semantic analysis on the input to generate structured intents. The structured intents can be generated using the fast / slow path processing method proposed in the above embodiments.
[0095] Step S702: Query the intent mapping table; The execution path type is determined by querying the intent mapping table based on the structured intent.
[0096] Step S703: Determine the execution path; When the execution path type is a system setting type, proceed to step S704; when it is an application call type, proceed to step S705; when it is a site redirect type, proceed to step S706; when the execution path type cannot be matched, proceed to step S707.
[0097] Step S704: Extract the Slots parameters and convert them into system API call parameters; The detailed execution process of this step is the same as that in step S300, and will not be repeated here.
[0098] Step S705: Extract target_app and query the application call mapping sub-table; The detailed execution process of this step is the same as that in step S300, and will not be repeated here.
[0099] Step S706: Extract target_site / query and construct the URL from the URL template; The detailed execution process of this step is the same as that in step S300, and will not be repeated here.
[0100] Step S707: When the execution path type cannot be matched in the mapping table, an unrecognized error is returned, triggering a diagnostic orchestration-side degradation.
[0101] Step S708: Parameter verification; The various parameters generated in the above steps are verified, including parameter type verification or range verification. The specific verification process is as described in step S300, and will not be repeated here.
[0102] Step S709: If the parameter verification fails, proceed to step S710; if the parameter verification passes, proceed to step S711.
[0103] Step S710: When parameter verification fails, a parameter error will be displayed, triggering a downgrade.
[0104] Step S711: Further security verification is performed, wherein the security verification process is as described in step S400, and will not be repeated here.
[0105] Step S712: If the security check fails, proceed to step S713; if the security check passes, proceed to step S714.
[0106] Step S713: If no match is found and the verification fails, a security rejection will be initiated, triggering a downgrade.
[0107] Step S714: Construct an execution parameter package, wherein the construction process of the execution parameter package is as described in step S500, and will not be repeated here.
[0108] Step S715: Send the data to the client via the communication connection using the MCP tool; The execution parameter package is sent to the diagnostic APP via the MCP protocol.
[0109] Step S716: Wait for the client to return the result; After the diagnostic APP executes according to the execution parameter package, it sends the execution result back to the diagnostic orchestration server.
[0110] Step S717: Determine the execution result to confirm whether the action was successful; if successful, proceed to step S718; if the execution fails, proceed to step S719.
[0111] Step S718: Construct a user-friendly response and return it to the dispute orchestration server.
[0112] Step S719: Execution fails, triggering downgrade and returning a failure message.
[0113] Based on the above process, in the first application scenario for maintenance personnel, when the maintenance personnel say "brighten the screen," the voice is recognized as text and reported. The orchestration side obtains the structured intent through the fast path: the domain is system settings, the action is to increase brightness, and the slot is "relative brightness." The system application agent queries the system settings mapping table to obtain the screen brightness system interface identifier, increases the brightness by a fixed step based on the current brightness, and after parameter verification and security checks, constructs an execution parameter package. This system settings execution parameter package (including the target interface and the converted brightness value) is sent to the client via MCP. After the client successfully calls the system API, the system application agent provides feedback in natural language: "The screen brightness has been increased, the current brightness is approximately 72%."
[0114] In the second application scenario for maintenance personnel, the personnel say, "Open Chrome and check P0171 for me." The semantic result is the APP call class and the action of opening the browser. The slot contains the target browser alias and the search statement. The system application agent queries the application call mapping sub-table to parse the browser package name. After the security verification is passed, because the search statement is not empty, the HTTPS search address is constructed and encoded. The MCP sends the APP call class execution parameter package (containing the package name and the link to be opened). The client launches Chrome and opens the address. The agent reports that the address has been opened and the search has been executed.
[0115] In the third application scenario for maintenance personnel, the personnel say "Open the first channel of the oscilloscope." The semantic result is an APP call class, where the oscilloscope is a self-developed APP. The "Open Application" action includes the target oscilloscope application and channel module identifier in the slot. The Agent queries the application call mapping sub-table to obtain the self-developed oscilloscope package name, passes the security verification of the allowed list according to the self-developed strategy, generates a Deep Link for the first channel of the oscilloscope, and sends the APP call class parameter package (including the package name and deep link) via MCP. After the client parses it, it directly accesses the first channel interface, and the Agent reports that it has been opened.
[0116] Based on the above embodiments, this application also proposes a vehicle diagnostic device 30, such as... Figure 7As shown, the vehicle diagnostic device 30 may include a processor 302, a communications interface 304, a memory 306, and a communication bus 308. The processor 302, communications interface 304, and memory 306 communicate with each other via the communication bus 308. The communications interface 304 is used to communicate with other devices, such as clients or other server network elements. The processor 302 is used to execute program 310, specifically the target application invocation method proposed in this embodiment.
[0117] Specifically, program 310 may include program code, which includes computer-executable instructions. Processor 302 may be a central processing unit (CPU), an ASIC, or one or more integrated circuits configured to implement the embodiments of this application. The computing device includes one or more processors, which may be processors of the same type, such as one or more CPUs; or they may be processors of different types, such as one or more CPUs and one or more ASICs.
[0118] Memory 306 is used to store program 310. Memory 306 may include high-speed RAM memory and may also include non-volatile memory, such as at least one disk storage device. Memory 306 stores code that executes the relevant steps in the target application invocation method embodiments proposed in this application.
[0119] This application also provides a computer-readable storage medium storing executable instructions. When the executable instructions are run on a vehicle diagnostic device, the vehicle diagnostic device performs the operation of the target application invocation method provided in any of the above embodiments.
[0120] This application also provides a target application invoking program, which is used to execute the target application invoking method provided in the above embodiments.
[0121] The algorithms or displays provided herein are not inherently related to any particular computer, virtual system, or other device. Various general-purpose systems can also be used in conjunction with the teachings herein. The required structure for constructing such systems is apparent from the above description. Furthermore, the embodiments of this application are not directed to any particular programming language. It should be understood that the content of this application described herein can be implemented using various programming languages, and the above description of specific languages is for the purpose of disclosing the best mode of implementation of this application.
[0122] Numerous specific details are set forth in the specification provided herein. However, it will be understood that embodiments of this application may be practiced without these specific details. In some instances, well-known methods, structures, and techniques have not been shown in detail so as not to obscure the understanding of this specification.
[0123] Similarly, it should be understood that, in order to simplify this application and aid in understanding one or more of the various aspects of the invention, in the above description of exemplary embodiments of this application, various features of the embodiments of this application are sometimes grouped together into a single embodiment, figure, or description thereof.
[0124] Those skilled in the art will understand that modules in the device of the embodiments can be adaptively changed and placed in one or more devices different from that embodiment. Modules, units, or components in the embodiments can be combined into a single module, unit, or component, and can be divided into multiple sub-modules, sub-units, or sub-components. Except where at least some of such features and / or processes or units are mutually exclusive, any combination can be used to combine all features disclosed in this specification (including the accompanying abstract and drawings) and all processes or units of any method or device so disclosed. Unless expressly stated otherwise, each feature disclosed in this specification (including the accompanying abstract and drawings) may be replaced by an alternative feature that serves the same, equivalent, or similar purpose.
[0125] It should be noted that the above embodiments are illustrative of this application and not restrictive, and those skilled in the art can design alternative embodiments without departing from the scope. Unless otherwise specified, the steps in the above embodiments should not be construed as limiting the order of execution.
Claims
1. A method for invoking a target application, characterized in that, include: Obtain the invocation instruction and generate a structured intent based on the invocation instruction. The structured intent includes an intent identifier and slot key-value pairs. The execution path type and the corresponding mapping sub-table are determined in the preset intent mapping table based on the intent identifier. Based on the intent identifier and the slot key-value pair, extract the target system interface identifier from the mapping sub-table; The target system interface identifier is verified according to the execution path type; When the target system interface identifier verification passes, an execution parameter package is constructed based on the target system interface identifier; The target application is invoked according to the execution parameter package.
2. The method according to claim 1, characterized in that, The intent mapping table includes a system settings mapping sub-table, an application call mapping sub-table, and a site redirection mapping sub-table; the execution path type includes system settings type, application call type, and site redirection type. The step of determining the execution path type and the corresponding mapping sub-table in a preset intent mapping table based on the intent identifier includes: Based on the intent identifier, the system settings mapping sub-table, the application call mapping sub-table, and the site jump mapping sub-table are searched one by one; When the system settings mapping sub-table matches the intent identifier, the execution path type is determined to be a system settings class, and the system settings mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type; When the application call mapping sub-table matches the intent identifier, the execution path type is determined to be an application call class, and the application call mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type; When the site redirection mapping sub-table matches the intent identifier, the execution path type is determined to be a site redirection type, and the site redirection mapping sub-table is determined to be the mapping sub-table corresponding to the execution path type; If the intent identifier is not matched in the system settings mapping sub-table, the application call mapping sub-table, or the site redirection mapping sub-table, an unrecognized operation result is returned.
3. The method according to claim 2, characterized in that, Based on the intent identifier and the slot key-value pair, the target system interface identifier is extracted from the mapping sub-table, including: When the execution path type is system settings type, the target system interface identifier is extracted from the system settings mapping sub-table, and the parameters in the slot key-value pair are converted according to the preset parameter type based on the device's allowed range; When the execution path type is an application call class and the target system interface identifier is a self-developed application, a deep link template is extracted from the application call mapping sub-table, the functional module parameters in the slot key-value pair are filled into the deep link template, a deep link identifier is constructed, and the deep link identifier is used as the target system interface identifier. When the execution path type is a site redirection type, and the slot key-value pair contains a search term, the search term is encoded and filled into the address template in the site redirection mapping sub-table to construct a URL address, and the URL address is used as the target system interface identifier.
4. The method according to claim 3, characterized in that, The method further includes: The deep link template shares parameterized routing fields with the vehicle functional domain navigation agent; When the functional module parameters require multi-step navigation, the vehicle functional domain navigation agent continues to process the interface instruction sequence after the deep link identifier jump.
5. The method according to claim 2, characterized in that, The step of verifying the target system interface identifier based on the execution path type includes: When the execution path type is a system setting type, the target system interface identifier is compared with the executable system interface whitelist. If the target system interface identifier is not in the executable system interface whitelist, the verification is deemed to have failed. When the execution path type is an application call class, the application package name corresponding to the target system interface identifier is compared with the package name whitelist. If the application package name is not in the package name whitelist, the verification is deemed to fail. When the execution path type is a site redirection type, the domain name corresponding to the target system interface identifier is compared with the domain name whitelist. If the domain name is not in the domain name whitelist, the verification is deemed to have failed, and access is prohibited using URL addresses that are not part of the Hypertext Transfer Protocol or the Hypertext Transfer Security Protocol.
6. The method according to claim 2, characterized in that, The execution parameter package includes the operation type and the target system interface identifier; The step of constructing the execution parameter package based on the target system interface identifier includes: When the execution path type is system setting type, the execution parameter package is constructed. The operation type in the execution parameter package is system setting, and the set value of the target system interface identifier is a value converted according to the preset parameter type. When the execution path type is an application call class, the execution parameter package is constructed. The operation type in the execution parameter package is application startup, and the target system interface identifier is the target application package name, an optional interface class name, or a deep link identifier. When the execution path type is a site redirection type, the execution parameter package is constructed, wherein the operation type in the execution parameter package is "open link" and the target system interface identifier is a Hypertext Transfer Security Protocol address.
7. The method according to claim 2, characterized in that, The step of obtaining the invocation instruction and generating a structured intent based on the invocation instruction includes: Domain label recognition is performed on the invocation command; When the domain tag of the invocation instruction matches the system settings class, the structured intent is generated directly from the invocation instruction via a fast path. When the domain tag of the invocation instruction does not match the system settings class, the structured intent is generated by sequentially performing query preprocessing, semantic understanding, and task planning on the invocation instruction via the slow path.
8. The method according to claim 1, characterized in that, The method further includes invoking the target application according to the execution parameter package, and the method further includes: If the call to the target application fails based on the execution parameter package, a fallback response is returned.
9. A vehicle diagnostic device, characterized in that, It includes a processor, a memory, a communication interface, and a communication bus, wherein the processor, the memory, and the communication interface communicate with each other through the communication bus; The memory is used to store at least one program that causes the processor to perform the operation of the target application invocation method as described in any one of claims 1-8.
10. A readable computer storage medium, characterized in that, The storage medium stores at least one program, which, when run on a vehicle diagnostic device, causes the vehicle diagnostic device to execute the target application invocation method as described in any one of claims 1-8.
