Application communication method and system in vehicle-mounted intelligent cabin system based on Android

Abstract

The invention discloses an application communication method in a vehicle-mounted intelligent cabin system based on Android, comprising the following steps: step 100, starting a server and a client to complete initialization; step 200, establishing an AIDL connection with uniqueness between the client side and the server side; step 300, the client sends a JSON format request message to the server through the AIDL interface; step 400, the server receives and processes the JSON format request message, and returns a response to the corresponding client after the processing is completed; and step 500, the client carries out callback according to the returned response result. According to the method and the system, when the interface parameters of the server are changed, the client can communicate among different applications without frequently updating the SDK, meanwhile, the data format among the different applications is standardized on the premise of ensuring the protocol flexibility, and the analysis is relatively simple.

Description

Technical Field

[0001] The present invention relates to the technical field of in-vehicle intelligent cockpit systems, and in particular, to an in-vehicle intelligent cockpit system application communication method and system based on Android. Background Art

[0002] With the continuous development of automotive intelligence, in-vehicle intelligent cockpit systems integrate various functional applications such as navigation, entertainment, information display, and vehicle control. Traditional in-vehicle systems use AIDL (Android Interface Definition Language) or Messenger to achieve inter-process communication, but there are the following disadvantages:

[0003] 1. When the service-side interface parameters change, the client needs to frequently update the SDK, otherwise it may cause the calling party to crash;

[0004] 2. The data formats and protocols between different applications are not unified, increasing the parsing complexity. Summary of the Invention

[0005] The main purpose of the present invention is to provide an in-vehicle intelligent cockpit system application communication method and system based on Android, aiming at the disadvantages that when the service-side interface parameters change in the prior art, the client needs to frequently update the SDK, and the data formats and protocols between different applications are not unified, and the parsing is relatively complex.

[0006] To achieve the above object, an in-vehicle intelligent cockpit system application communication method based on Android of the present invention includes the following steps:

[0007] Step 100: The server and the client are started and initialized;

[0008] Step 200: A unique AIDL connection is established between the client and the server;

[0009] Step 300: The client sends a JSON format request message to the server through the AIDL interface;

[0010] Step 400: The server receives the JSON format request message and processes it. After the processing is completed, the response is returned to the corresponding client;

[0011] Step 500: The client makes a callback according to the returned response result.

[0012] Preferably, the step 100 includes: when the server starts, first initialize the Dispatcher class component, and register the Dispatcher class component into the Hermasprotocolservice component. The Hermasprotocolservice component calls the RegisterDispatcher method in the Dispatcher class component to complete the initialization of the server.

[0013] When the client starts, complete the initialization of the client by initializing the BaseConnectionClient class component.

[0014] Preferably, the step 200 includes: the client first determines the target server to be connected according to the package name and actionName parameter information of the server, and then establishes a connection with the target server through the Connect method in the BaseConnectionClient class component. After the connection is successful, trigger the OnConnect method in the ConnectCallback interface to notify the client that the connection is successful.

[0015] Preferably, the step 300 includes: the client calls the SendMessage method in the ConnectionClient component. After the call, the ConnectionClient component calls the SendToServer method in the underlying BaseConnectionClient component to send the JSON format message to the server through the fixed AIDL interface VoidsendMessage(String josn, StringrequestCookie, IIPCCallback callback), where the request parameters are encapsulated in the data field of the JSON format message.

[0016] Preferably, the step 400 includes: after the HermasProtocolService component in the server receives a JSON-formatted message, it is transmitted to the Dispatcher component. According to the source of the JSON-formatted message, a request identifier requestCookie corresponding to the client is generated in the Dispatcher component, and it is called back to the server by invoking the OnDispatcherMessage method in the HermasProtocolService component. After the server finishes processing the JSON-formatted message, the client to which the response is to be returned is determined based on the combination of the requestCookie and the IIPCCallback hash value, and the processing result is returned to the corresponding client through the return message interface doResponseBigDataToClient(String json, String requestCookie).

[0017] Preferably, the step 500 includes: after the client receives the response, the RequestCallback interface is found in the ConnectionClient component according to the requestCookie in the returned response result, and the onMessage method is triggered to call back the response result returned by the server.

[0018] Preferably, the JSON-formatted message includes a protocol identity number protocolId, a request identifier requestCode, a version number versionName, and a dynamic data body data.

[0019] In addition, to achieve the above object, the present invention also provides an in-vehicle intelligent cockpit system internal application communication system based on Android, including:

[0020] Server module and client module, the server module includes HermasProtocolService component and Dispatcher component, the client module includes BaseConnectionClient component, ConnectionClient component, ConnectCallback interface and RequestCallback interface, the HermasProtocolService component is used to receive JSON format messages from the client and transmit them to the Dispatcher component, the Dispatcher component is used to generate a request identifier requestCookie corresponding to the client, and call the OnDispatcherMessage method in the HermasProtocolService component to callback to the server. After the server processes this request, determine the returned client according to the combination of requestCookie and IIPCCallback hash value, and return the processing result to the corresponding client through the return message interface doResponseBigDataToClient(String json, String requestCookie); the BaseConnectionClient component is used to call the SendToServer method to send JSON format messages to the server, the ConnectionClient component is used to call the SendMessage method, the ConnectCallback interface is used to call the OnConnect method to notify the client that the connection is successful, the RequestCallback interface is used to trigger the onMessage method to callback the response result returned by the server, wherein the request parameters are encapsulated in the data field of the JSON format message.

[0021] Preferably, the JSON format message includes protocol identity number protocolId, request identifier requestCode, version number versionName and dynamic data body data.

[0022] The in-vehicle intelligent cockpit system application communication method and system based on Android provided by the present invention have the following beneficial effects:

[0023] The client uses the BaseConnectionClient component, ConnectionClient component, and interfaces to implement the client's transmission of JSON format messages with extended parameters to the server. By using the ConnectCallback interface and RequestCallback, the client realizes the callback for the connection success status and the response result returned by the server. The server uses the HermasProtocolService component to receive the JSON format messages with extended parameters transmitted by the client, and uses the Dispatcher component to process and respond to the JSON format messages with extended parameters. Thus, when the server interface changes, when the client only depends on the fixed AIDL interface, the client does not need to be updated. As long as it transmits messages through JSON extension, it can realize communication between different applications. At the same time, because JSON format communication is adopted, the parsing complexity is reduced. Description of the Drawings

[0024] In order to more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the drawings required for the description of the embodiments or the prior art. Obviously, the drawings in the following description are only the embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can be obtained according to the provided drawings:

[0025] Figure 1 The following shows a schematic flowchart of a method for in-vehicle intelligent cockpit system application communication based on Android provided by an embodiment of the present invention;

[0026] Figure 2 The following shows a schematic diagram of the system module structure of a system for in-vehicle intelligent cockpit system application communication based on Android provided by an embodiment of the present invention. Detailed Embodiments

[0027] To facilitate the understanding of the present invention, the present invention will be described more comprehensively below with reference to the relevant drawings. The typical embodiments of the present invention are shown in the drawings. However, the present invention can be implemented in many different forms and is not limited to the embodiments described herein. On the contrary, the purpose of providing these embodiments is to make the disclosure of the present invention more thorough and comprehensive.

[0028] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by those of ordinary skill in the technical field to which the present invention belongs. The terms used in the description of the present invention in this specification are only for the purpose of describing specific embodiments and are not intended to limit the present invention.

[0029] The general idea of the present invention is as follows: Aiming at the drawbacks in the prior art that when the server interface parameters change, the client needs to frequently update the SDK, and the data formats and protocols between different applications are not unified and the parsing is relatively complex. In the present invention, the client uses the BaseConnectionClient component, the ConnectionClient component, and the interface to enable the client to send JSON-format messages with extended parameters to the server. By using the ConnectCallback interface and the RequestCallback, the client realizes the callback of the connection success status and the response result returned by the server. The server uses the HermasProtocolService component to receive the JSON-format messages with extended parameters sent by the client, and uses the Dispatcher component to process and respond to the JSON-format messages with extended parameters. Thus, when the server interface changes, the client only depends on the fixed AIDL interface, and the client does not need to be updated. Only by sending messages through JSON extension can the communication between different applications be realized. At the same time, because JSON-format communication is adopted, the parsing complexity is reduced.

[0030] To better understand the above technical solution, the following will combine the accompanying drawings of the specification and specific implementation manners to elaborate on the above technical solution in detail. It should be understood that the embodiments of the present invention and the specific features in the embodiments are detailed descriptions of the technical solution of the present application, rather than limitations on the technical solution of the present application. Without conflict, the technical features in the embodiments of the present invention and the embodiments can be combined with each other.

[0031] Refer to Figure 1 , Figure 1 The figure shows a schematic flowchart of a method for application communication in an in-vehicle intelligent cockpit system based on Android provided by an embodiment of the present invention. In this embodiment, a method for application communication in an in-vehicle intelligent cockpit system based on Android includes:

[0032] Step 100: The server and the client are started and initialized.

[0033] In the in-vehicle intelligent cockpit system, the communication between various applications can be both a server and a client to each other. For example: 1. Multimedia acts as a server to provide interfaces such as play and pause. The user controls the music pause through a voice command, and the voice application acts as a client to call the pause interface of the multimedia. At this time, the multimedia is the server; 2. Multimedia needs the voice application to play a piece of TTS. The multimedia calls the TTS interface provided by the voice application. At this time, the multimedia is the client. When the in-vehicle intelligent cockpit system is powered on and started, each application is initialized.

[0034] Specifically, when the server starts, it first initializes the Dispatcher class component and registers the Dispatcher class component into the Hermasprotocolservice component. The Hermasprotocolservice component calls the RegisterDispatcher method in the Dispatcher class component to complete the initialization of the server. When the client starts, it initializes the BaseConnectionClient class component to complete the initialization of the client.

[0035] The server components include the Hermasprotocolservice component and the Dispatcher class component. HermasProtocolService is a parent class provided for the server to inherit. As an application of the server, it needs to inherit this class. The Dispatcher class component is the class name in the server that controls the reception of client messages. The client components include the BaseConnectionClient component and the ConnectionClient component. The client interfaces include the ConnectCallback interface and the RequestCallback interface. The ConnectCallback interface is a callback interface for managing the connection status between the client and the server, such as connection, disconnection, and connection in progress. The RequestCallback interface is a callback interface for the client to receive data when the server returns data to the client.

[0036] Step 200: Establish a unique AIDL connection between the client and the server.

[0037] In a vehicle-mounted system, there are many applications that act as clients and servers for each other. Therefore, the connection between the client and the server needs to ensure the uniqueness and accuracy of communication.

[0038] Specifically, the client first determines the target server to be connected according to the package name and actionName parameter information of the server, and then establishes a connection with the target server through the Connect method in the BaseConnectionClient class component. After the connection is successful, it triggers the OnConnect method in the ConnectCallback interface to notify the client that the connection is successful.

[0039] The package name and actionName actually belong to a part of the protocol. The server will pre - define its own package name and actionName. When the client needs to connect to this server, it can use the parameters pre - set by this server to connect. For example, the package name of the server is com.xxx.xxx and the actionName is com.xxx.xxx.actionProtocol. When the client establishes a connection, it determines which specific server to connect to through these two parameters.

[0040] Take a similar example: When a voice assistant wants to access a music player, the voice assistant is the client and the music player is the server. "Music Player" can be used as its package name, and "Play Music" can be used as its actionName. Both "Music Player" and "Play Music" are pre - defined and public. The client only needs to obtain them from the system's public area.

[0041] After determining the target server, it is necessary to call the Connect method in the BaseConnectionClient class component to connect to the server. After the connection is successful, the OnConnect method in the ConnectCallback interface will be triggered, thereby notifying the client that the current connection status is the successful connection status. The ConnectCallback interface is a parameter passed in when the client calls the connect method. When the client successfully connects to the server, the onConnect method will be triggered to notify the client of the successful connection. onConnect is a callback method and the client will not actively call it.

[0042] Step 300: The client sends a JSON - formatted request message to the server through the AIDL interface;

[0043] Applications in the in - vehicle system communicate with each other using the AIDL mechanism. The client transmits a JSON - formatted request message to the server through a fixed AIDL - type interface.

[0044] Specifically, the client calls the SendMessage method in the ConnectionClient component. After the call, the ConnectionClient component calls the SendToServer method in the underlying BaseConnectionClient component to send the JSON - formatted message to the server through the fixed AIDL interface Void sendMessage(String josn, String requestCookie, IIPCCallback callback). Among them, the request parameters are encapsulated in the data field of the JSON - formatted message.

[0045] sendMessage is an interface method for external use by the client. After the client calls sendMessage, the underlying BaseConnectionClient component calls the internal sendToServer method, and finally sends the JSON-formatted request message to the server. In fact, it is a method for the client integrated with the SDK. sendToServer is a method inside the SDK. void sendMessage(String json, String requestCookie, IIPCCallback callBack), where sendMessage is the interface method name, and it contains three parameters: json, requestCookie, and callBack. In this patent, the AIDL interface provided by the server is fixed, and all changes are adapted through the json string passed in through the interface. In this way, when the server interface changes, the client does not need to update the AIDL file. The traditional solution requires increasing the number of parameters. In the patent solution, the number of parameters is fixed. The patent transmits the string of the json protocol. In the traditional solution, when adding attributes to the interface method, the number of input parameters needs to be increased. In the patent solution, the added attributes are included in the string of the json protocol, so the number of input parameters of the interface can remain unchanged.

[0046] For JSON-formatted messages, it can include the protocol identity number protocolId, the request identifier requestCode, the version number versionName, and the dynamic data body data.

[0047] JSON dynamic extension: The request parameters are encapsulated in the data field of JOSN. For example, the play request can be extended from {"songID": 1} to {"id": 1, "openPage": true} without modifying the ALDL interface. When the server interface changes, only the data in the dynamic data body data of the JSON-formatted message needs to be changed. For example, the interface provided by the server is void sendMessage(String json, String requestCookie, IIPCCallback callBack),

[0048]

[0049]

[0050] At this time, the interface is still void sendMessage(String json, String requestCookie, IIPCCallback callBack), and the only thing that changes is the message body in the json parameter.

[0051] Step 400: The server receives the JSON-format request message and processes it. After processing, it returns the response to the corresponding client.

[0052] After receiving the JSON-format message transmitted by the client, the server needs to parse and process the JSON-format message. After processing, it needs to accurately return the processing result to the client that sent the JSON-format message for the client to perform a callback.

[0053] Specifically, after the HermasProtocolService component in the server receives the JSON-format message, it is transmitted to the Dispatcher component. According to the source of the JSON-format message, a request identifier requestCookie for the corresponding client is generated in the Dispatcher component and is called back to the server by calling the OnDispatcherMessage method in the HermasProtocolService component. After the server finishes processing the JSON-format message, it determines the client to which the response is to be returned based on the combination of the requestCookie and the IIPCCallback hash value, and returns the processing result to the corresponding client through the return message interface doResponseBigDataToClient(String json, String requestCookie).

[0054] The server transmits the received JSON-formatted message to the server message dispatcher Dispatcher component. In the Dispatcher component, a corresponding request identifier requestCookie is generated for the JSON-formatted message transmitted by the client. By calling the OnDispatcherMessage method in the HermasProtocolService component, the message is distributed to the server business implementation party that inherits HermasProtocolService through the message distribution interface onDispatchMessage(String json, String requestCookie). After processing this request, the business implementation party returns the processing result to the corresponding client through the return message interface doResponseBigDataToClient(String json, String requestCookie). The message receiving method (onMessage(String result, int statusCode)) in the callback interface (RequestCallback) of the client can receive the result of this request. The uniqueness of the interface request is determined by the hash value combination of requestCookie and IIPCCallback callback in the sendMessage(String json, String requestCookie, IIPCCallback callback) method in the Dispatcher to determine which client to return to.

[0055] Step 500: The client makes a callback according to the returned response result.

[0056] The client receives the server response result and performs callback processing.

[0057] Specifically, after receiving the response, the client finds the RequestCallback interface in the ConnectionClient component according to the requestCookie in the returned response result, and triggers the onMessage method to callback the response result returned by the server.

[0058] After receiving the response, the client finds the corresponding RequestCallback in the ConnectionClient through the requestCookie in the returned result for callback. For example, when the client sends a message to request music playback, the onMessage method of the RequestCallback interface can be used to process the response result returned by the server.

[0059] The following is a specific embodiment based on the above technical solution for implementing the communication function of the music interface:

[0060] 1. Permission Query

[0061] · Protocol ID: 50000

[0062] · Function Description: Obtain whether the permission has been granted and is available

[0063] Request Example:

[0064] {

[0065] "requestCode": "123456789",

[0066] "protocolId": 50000,

[0067] "versionName": "v_1.0",

[0068] "requestAuthor": "com.XXX.XXX",

[0069] "messageType": "request",

[0070] "data": {}

[0071] }

[0072] Return Example:

[0073] {

[0074] "statusCode": 10000,

[0075] "requestCode": "123456789",

[0076] "responseCode": "123456789",

[0077] "protocolId": 50000,

[0078] "versionName": "v_1.0",

[0079] "requestAuthor": "com.XXX.XXX",

[0080] "messageType": "response",

[0081] "data": {

[0082] "resultCode": 10000

[0083] }

[0084] } Through these embodiments, it is demonstrated how to use the solution of the present invention to implement the application communication function within the in-vehicle intelligent cockpit system, ensuring the consistency, reliability, and compatibility of messages.

[0085] Based on the above method, the client in the present invention realizes that the client can send JSON-format messages with extended parameters to the server by adopting the BaseConnectionClient component, the ConnectionClient component, and the interface. The client realizes the callback of the connection success status and the response result returned by the server by adopting the ConnectCallback interface and the RequestCallback. The server realizes receiving the JSON-format messages with extended parameters sent by the client by adopting the HermasProtocolService component, and processes and responds to the JSON-format messages with extended parameters by adopting the Dispatcher component. Thus, when the server interface changes, when the client only depends on the fixed AIDL interface, the client does not need to be updated. As long as the messages are sent through JSON extension, the communication between different applications can be realized. At the same time, because JSON-format communication is adopted, the parsing complexity is reduced.

[0086] Correspondingly, the present invention also provides an in-vehicle intelligent cockpit system application communication system based on Android. Referring to Figure 2 , Figure 2 FIG. shows a schematic diagram of the system module structure of an in-vehicle intelligent cockpit system application communication system provided by an embodiment of the present invention. The system realizes the application communication within the in-vehicle intelligent cockpit system through the method described above. The system includes:

[0087] Server module and client module, the server module includes HermasProtocolService component and Dispatcher component, the client module includes BaseConnectionClient component, ConnectionClient component, ConnectCallback interface and RequestCallback interface. The HermasProtocolService component is used to receive JSON format messages from the client and transmit them to the Dispatcher component. The Dispatcher component is used to generate a request identifier requestCookie corresponding to the client, and call the OnDispatcherMessage method in the HermasProtocolService component to callback to the server. After the server processes this request, it determines the client to return according to the combination of requestCookie and IIPCCallback hash value, and returns the processing result to the corresponding client through the return message interface doResponseBigDataToClient(String json, String requestCookie); the BaseConnectionClient component is used to call the SendToServer method to send JSON format messages to the server, the ConnectionClient component is used to call the SendMessage method, the ConnectCallback interface is used to call the OnConnect method to notify the client of successful connection, and the RequestCallback interface is used to trigger the onMessage method to callback the response result returned by the server. Among them, the request parameters are encapsulated in the data field of the JSON format message.

[0088] Preferably, the JSON format message includes protocol identity number protocolId, request identifier requestCode, version number versionName and dynamic data body data.

[0089] In the specification provided herein, a large number of specific details are described. However, it can be understood that the embodiments of the present invention can be practiced without these specific details. In some instances, well-known methods, structures and technologies are not shown in detail so as not to obscure the understanding of this specification.

[0090] Similarly, it should be understood that, in order to streamline the present disclosure and assist in understanding one or more of the various inventive aspects, in the foregoing description of the exemplary embodiments of the present invention, the various features of the present invention are sometimes grouped together in a single embodiment, figure, or description thereof. However, the disclosed method should not be construed as reflecting an intention that the claimed invention requires more features than are expressly recited in each claim. Rather, as reflected in the following claims, the inventive aspects lie in less than all the features of the single foregoing disclosed embodiment. Thus, the claims following the detailed description are hereby expressly incorporated into the detailed description, with each claim standing on its own as a separate embodiment of the present invention.

[0091] Those skilled in the art will appreciate that the modules in the devices in the embodiments can be adaptively changed and disposed in one or more devices different from the embodiments. The modules or units or components in the embodiments can be combined into one module or unit or component, and in addition, they can be divided into multiple sub-modules or sub-units or sub-components. Except that at least some of such features and / or processes or units are mutually exclusive, any combination can be used to combine all the features disclosed in this specification (including the accompanying claims, abstract, and drawings) and all the processes or units of any method or device so disclosed. Unless otherwise expressly stated, each feature disclosed in this specification (including the accompanying claims, abstract, and drawings) can be replaced by an alternative feature that provides the same, equivalent, or similar purpose.

[0092] In addition, those skilled in the art will be able to understand that although some of the embodiments herein include certain features included in other embodiments rather than other features, the combination of the features of different embodiments means that it is within the scope of the present invention and forms different embodiments. For example, in the following claims, any one of the claimed embodiments can be used in any combination.

[0093] The various component embodiments of the present invention can be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. Those skilled in the art should understand that a microprocessor or a digital signal processor (DSP) can be used in practice to implement some or all of the functions of some or all of the components according to the embodiments of the present invention. The present invention can also be implemented as a device or apparatus program (e.g., a computer program and a computer program product) for executing part or all of the methods described herein. Such a program for implementing the present invention can be stored on a computer-readable medium, or can be in the form of one or more signals. Such signals can be downloaded from an Internet website, or provided on a carrier signal, or provided in any other form.

[0094] It should be noted that the above embodiments are illustrative of the present invention and not restrictive thereof, and those skilled in the art can design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in the claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The present invention can be implemented by means of hardware including several different elements and by means of a suitably programmed computer. In the unit claims listing several devices, several of these devices may be embodied by the same item of hardware. The use of the words first, second, and third, etc. does not denote any order. These words may be interpreted as names.

Claims

1. An application communication method in an Android-based vehicle-mounted intelligent cockpit system, characterized in that: The following steps are involved: Step 100: The server and client are started and initialized; Step 200: Establish a unique AIDL connection between the client and the server; Step 300: The client sends a JSON format request message to the server through the AIDL interface; Step 400: The server receives and processes the request message in JSON format, and after processing, returns a response to the corresponding client; Step 500: The client performs a callback according to the returned response result.

2. The method for application communication in an Android-based vehicle-mounted intelligent cockpit system according to claim 1, characterized in that: The step 100 comprises: When the server starts, the Dispatcher class component is initialized first, and the Dispatcher class component is registered in the Hermasprotocolservice component. The Hermasprotocolservice component calls the RegisterDispatcher method in the Dispatcher class component to complete the initialization of the server. When the client starts, the client initialization is completed by initializing the BaseConnectionClient class component.

3. The method for application communication in an Android-based vehicle-mounted intelligent cockpit system according to claim 2, characterized in that: The step 200 comprises: The client first determines the target server to be connected based on the package name and actionName parameter information of the server, and then establishes a connection with the target server through the Connect method in the BaseConnectionClient class component. After the connection is successful, the OnConnect method in the ConnectCallback interface is triggered to notify the client of the successful connection.

4. The method for application communication in an Android-based vehicle-mounted intelligent cockpit system according to claim 3, characterized in that: The step 300 includes: The client calls the SendMessage method in the ConnectionClient component. After the call, the ConnectionClient component calls the SendToServer method in the underlying BaseConnectionClient component and sends a JSON format message to the server through the fixed AIDL interface VoidsendMessage(String josn, String requestCookie, IIPCCallback callback). The request parameters are encapsulated in the data field of the JSON format message.

5. The method for application communication in an Android-based vehicle-mounted intelligent cockpit system according to claim 4, characterized in that: The step 400 includes: After the HermasProtocolService component in the server receives the JSON format message, it transmits it to the Dispatcher component. According to the source of the JSON format message, a request identifier requestCookie corresponding to the client is generated in the Dispatcher component, and the request is called back to the server by calling the OnDispatcherMessage method in the HermasProtocolService component. After processing the JSON format message, the server determines the returned client based on the combination of requestCookie and IIPCCallback hash values, and returns the processing result to the corresponding client through the return message interface doResponseBigDataToClient(Stringjson, String requestCookie).

6. The method for application communication in an Android-based vehicle-mounted intelligent cockpit system according to claim 5, characterized in that: The step 500 includes: After receiving the response, the client finds the RequestCallback interface in the ConnectionClient component according to the requestCookie in the returned response result, and triggers the onMessage method to call back the response result returned by the server.

7. The method for application communication in an Android-based vehicle-mounted intelligent cockpit system according to claim 6, characterized in that: The JSON format message includes a protocol identification number protocolId, a request identifier requestCode, a version number versionName and a dynamic data body data.

8. An application communication system in an in-vehicle intelligent cockpit system based on Android, characterized in that: include: The server module and the client module include a HermasProtocolService component and a Dispatcher component, and the client module includes a BaseConnectionClient component, a ConnectionClient component, a ConnectCallback interface, and a RequestCallback interface. The HermasProtocolService component is used to receive a JSON format message from the client and transmit it to the Dispatcher component. The Dispatcher component is used to generate a request identifier requestCookie corresponding to the client, and call back to the server by calling the OnDispatcherMessage method in the HermasProtocolService component. After the server processes the request, the returned client is determined according to the combination of requestCookie and IIPCCallback hash values, and the message interface doResponseBigDataToClient(String json, String requestCookie) returns the processing result to the corresponding client; the BaseConnectionClient component is used to call the SendToServer method to send a JSON format message to the server, the ConnectionClient component is used to call the SendMessage method, the ConnectCallback interface is used to call the OnConnect method to notify the client of a successful connection, and the RequestCallback interface is used to trigger the onMessage method to callback the response result returned by the server, wherein the request parameters are encapsulated in the data field of the JSON format message.

9. The application communication system in the vehicle-mounted intelligent cockpit system based on Android as claimed in claim 8, characterized in that: The JSON format message includes a protocol identification number protocolId, a request identifier requestCode, a version number versionName and a dynamic data body data.

Images