A data processing method, system, electronic device, and readable storage medium

Abstract

This invention provides a data processing method, system, electronic device, and readable storage medium. The method involves acquiring target data, synchronizing data based on the target data, and caching data that has not yet been synchronized to a temporary storage directory. It then determines whether cached data exists in the temporary storage directory. If it exists, the cached data and the target data are jointly written to a pre-created log file, and the number of entries written is recorded. If the target data does not exist, the target data is written to the pre-created log file, and the number of entries written is recorded. The recorded number of entries written is compared with a preset data upload threshold, and the data in the log file is uploaded in chunks based on the comparison result. This application, by uploading target data in chunks, not only reduces the number of network requests but also stores uploaded data even when network fluctuations occur, avoiding frequent duplicate uploads due to network issues during the data upload process.

Description

Technical Field

[0001] This application relates to the field of data storage technology, specifically to a data processing method, system, electronic device, and readable storage medium. Background Technology

[0002] With the development of vehicle technology, vehicles have become an indispensable part of people's lives, and the in-car environment has become an important space in people's lives. Currently, people's demands for vehicles are also increasing; they not only want safe driving, but also a good driving experience. Therefore, to provide a good driving experience, existing vehicle manufacturers install in-vehicle infotainment products (referred to as "vehicle systems") in vehicles, allowing drivers or passengers to fully utilize the vehicle for entertainment and leisure services. When drivers or passengers interact with the vehicle system, a large amount of data is generated. To save this data so that the vehicle can present different services to different drivers or passengers, this data needs to be uploaded and stored.

[0003] However, current methods for uploading and storing vehicle-mounted data typically involve identifying the data that needs to be written to memory and then providing memory space to store it. This means the current method treats the data to be written to memory as a single file and uploads the entire file, resulting in large network traffic requests. Furthermore, current methods generally upload data or files only after they have been completely written, meaning they lack the ability to perform unpredictable data writing and uploading. This leads to large amounts of data or files being uploaded or stored at once, and in situations with poor network conditions, the entire data or file may fail to be uploaded or stored. Summary of the Invention

[0004] In view of the shortcomings of the prior art described above, this application provides a data processing method, system, electronic device, and readable storage medium to solve the above-mentioned technical problems.

[0005] This application provides a data processing method, the method comprising the following steps:

[0006] Acquire pre-generated or real-time generated data, and denote it as the target data;

[0007] Data synchronization is performed based on the target data, and data that has not been synchronized is cached in a temporary storage directory.

[0008] Determine whether cached data exists in the temporary storage directory. If cached data exists in the temporary storage directory, write the cached data and the target data together into a pre-created log file and record the number of file writes at this time. Alternatively, if cached data does not exist in the temporary storage directory, write the target data into the pre-created log file and record the number of file writes at this time.

[0009] The number of records written to the file is compared with a preset data upload threshold, and the data in the log file is read into the data upload queue for fragmented upload based on the comparison result.

[0010] In one embodiment of this application, the process of reading data from the log file into the data upload queue for fragmented upload based on the comparison result includes:

[0011] When the number of records written to the file exceeds the preset data upload threshold, data is read from the log file into the data upload queue, and a direct upload message is sent, waiting for the data in the data upload queue to be uploaded in chunks; or,

[0012] When the number of records written to the file is less than or equal to the preset data upload threshold, data is read from the log file into the data upload field and transmitted from the data upload field to the data upload queue. A direct upload message is also sent, and the system waits for the data in the data upload queue to be uploaded in chunks.

[0013] In one embodiment of this application, the process of uploading data in the data upload queue in segments includes:

[0014] In response to the direct upload message, the polling upload data thread is woken up based on the response result;

[0015] The polling upload thread polls the data upload queue, uploading the data in the queue in chunks until the polling upload thread enters a blocked state, at which point the polling ends; or, the polling ends when the field type of the data extracted by the polling upload thread from the data upload queue is an end field.

[0016] Specifically, when the polling upload data thread polls the data upload queue, if there is no data in the data upload queue, the polling upload data thread enters a blocked state.

[0017] In one embodiment of this application, the process of using the polling upload data thread to poll the data upload queue and uploading the data in the data upload queue in chunks includes:

[0018] The polling upload data thread is used to poll the data upload queue and read the data in the data upload queue, which is recorded as the data to be uploaded;

[0019] The fields of the data to be uploaded are matched with preset fields to determine the field types of the data to be uploaded;

[0020] If the field type of the data to be uploaded belongs to a preset field, then the data to be uploaded is directly uploaded in chunks, or the polling access of the data upload queue by the polling upload thread is terminated.

[0021] If the field type of the data to be uploaded does not belong to the preset field, the data to be uploaded is transferred to the temporary storage directory, and when the number of data entries in the temporary storage directory is greater than the preset data upload threshold, the data to be uploaded in the temporary storage directory is uploaded in segments.

[0022] In one embodiment of this application, if the preset fields include a direct upload field and an end field, the method further includes:

[0023] Match the fields of the data to be uploaded with the direct upload field and the end field;

[0024] If the field type of the data to be uploaded is a direct upload field, then the data to be uploaded will be directly segmented and uploaded.

[0025] If the field type of the data to be uploaded is an end field, then the polling access of the data upload queue by the polling upload thread is terminated.

[0026] In one embodiment of this application, before waking up the polling data upload thread, the method further includes:

[0027] Retrieve a pre-created log dump file;

[0028] Read the data that was not uploaded in the log file into the log transfer file, and then delete the log file;

[0029] Modify the attributes of the log file containing the read data, and use the modified log file as the log recording file.

[0030] In one embodiment of this application, the process of waking up the polling data upload thread based on the response result includes:

[0031] Create a network listening broadcast based on the response result, and determine whether the current network is available based on the network listening broadcast;

[0032] If the current network is unavailable, the current network status is recorded, and the polling data upload thread is suspended to wait for it to be woken up.

[0033] If the current network is available, the polling upload data thread is woken up so that the polling upload data thread can poll the data upload queue.

[0034] In one embodiment of this application, after reading the data from the log file into the data upload queue for fragmented upload, the method further includes: enabling the deregistration process, releasing the file write stream associated with the log file, cleaning up direct upload messages, and clearing the polling upload data thread.

[0035] In one embodiment of this application, when the number of data entries written to the file is greater than the preset data upload threshold, the method further includes:

[0036] The number of records written to the file is cleared, and after a first delay, data is read from the log file into the data upload queue, and after a second delay, the direct upload message is sent.

[0037] The duration of the first time period is shorter than the duration of the second time period.

[0038] This application also provides a data processing system, the system comprising:

[0039] The data acquisition module is used to acquire pre-generated or real-time generated data, denoted as target data;

[0040] The data synchronization module is used to synchronize data according to the target data and cache the data that has not been synchronized to a temporary storage directory;

[0041] A cached data determination module is used to determine whether cached data exists in the temporary storage directory;

[0042] The data writing module is used to write the cached data and the target data together into a pre-created log file when the cached data exists in the temporary storage directory, and record the number of file writes at this time; or, when the cached data does not exist in the temporary storage directory, write the target data into the pre-created log file and record the number of file writes at this time.

[0043] The comparison module is used to compare the number of file writes recorded by the data writing module with the preset data upload threshold.

[0044] The chunked upload module is used to read the data from the log file into the data upload queue for chunked upload based on the comparison results.

[0045] This application also provides a vehicle on which at least one application is installed; wherein the application is used to generate target data as described in any of the data processing methods above.

[0046] This application also provides an electronic device, the electronic device comprising:

[0047] One or more processors;

[0048] A storage device for storing one or more programs, which, when executed by one or more processors, cause the electronic device to perform the data processing method as described in any one of the preceding descriptions.

[0049] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a computer's processor, causes the computer to perform the data processing method as described in any one of the above descriptions.

[0050] As described above, this application provides a data processing method, system, electronic device, and readable storage medium, which have the following beneficial effects:

[0051] This application first obtains pre-generated or real-time generated data as target data; then, it performs data synchronization based on the target data, and caches data that has not been synchronized to a temporary storage directory; next, it determines whether cached data exists in the temporary storage directory, and if cached data exists, it writes both the cached data and the target data into a pre-created log file, recording the number of file writes at this time; alternatively, if cached data does not exist in the temporary storage directory, it writes the target data into the pre-created log file, recording the number of file writes at this time; finally, it compares the recorded number of file writes with a preset data upload threshold, and based on the comparison result, reads the data from the log file into the data upload queue for fragmented upload. Therefore, this application, by uploading target data in fragments, not only reduces the number of network requests but also stores uploaded data when network fluctuations occur, avoiding frequent duplicate uploads due to network issues during the data upload process.

[0052] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and do not limit this application. Attached Figure Description

[0053] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application. It is obvious that the drawings described below are merely some embodiments of this application, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort. In the drawings:

[0054] Figure 1 This is a schematic diagram illustrating an exemplary system architecture that applies the technical solutions in one or more embodiments of this application;

[0055] Figure 2 A schematic flowchart illustrating a data processing method provided in one embodiment of this application;

[0056] Figure 3 This is a schematic diagram of the data initialization and upload process provided in one embodiment of this application;

[0057] Figure 4 A schematic diagram of a data storage process provided in one embodiment of this application;

[0058] Figure 5 A schematic diagram of the cancellation process provided in one embodiment of this application;

[0059] Figure 6 This is a schematic diagram of the hardware structure of a data processing system provided in one embodiment of this application;

[0060] Figure 7 This is a schematic diagram of the hardware structure of an electronic device suitable for implementing one or more embodiments of this application. Detailed Implementation

[0061] The embodiments of the present invention will be described below with reference to the accompanying drawings and preferred embodiments. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific embodiments, and various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be understood that the preferred embodiments are only for illustrating the present invention and not for limiting the scope of protection of the present invention.

[0062] It should be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of the present invention. Therefore, the drawings only show the components related to the present invention and are not drawn according to the actual number, shape and size of the components in the actual implementation. In the actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0063] In the following description, numerous details are explored to provide a more thorough explanation of embodiments of the invention. However, it will be apparent to those skilled in the art that embodiments of the invention may be practiced without these specific details. In other embodiments, well-known structures and devices are shown in block diagram form rather than in detail to avoid obscuring embodiments of the invention.

[0064] Explanation of technical terms:

[0065] APP_RECORD_FILE: Log file.

[0066] TEMP_RECORD_FILE: Log file.

[0067] INIT_DATA_MSG: Initialization message.

[0068] mReadQueueDataThread: The thread that polls for uploaded data.

[0069] mLocalRecordQueue: Data upload queue.

[0070] UPLOAD_TYPE: Direct upload field.

[0071] END_TYPE: End field.

[0072] UPLOAD: Upload.

[0073] type: Field.

[0074] mUpLoadList: Temporary storage directory for uploads.

[0075] mUpLoadList size: Size of the temporary storage directory for uploads.

[0076] ONCE_UPLOAD_NUM: Data upload threshold.

[0077] mBackUplist: Temporary storage directory during data synchronization.

[0078] mAppDataRecordWriter: File writing stream.

[0079] onDestory: Handles the end callback method.

[0080] UPLOAD_DIRECT_MSG: Upload messages directly.

[0081] Network Change Receiver.

[0082] ALIGIN_DATA_MSG: Normal message.

[0083] sp: Android local storage.

[0084] totalNum: Total number of uploaded items.

[0085] mAppDataRecordFile: A log file that stores all data to be uploaded.

[0086] mTempRecordfile: Temporary file.

[0087] mUploadDataNum: A class variable used to record the number of items being uploaded.

[0088] bHasFinishAlign: Whether the status variable is being transferred.

[0089] waitnToReadData(false): A method name.

[0090] DataUploadManager: A class for managing uploads.

[0091] getinstance(): Gets an instance of the management class.

[0092] recordAppData: A method in the management class.

[0093] mAPPRecordNum: Number of records written to the file.

[0094] Figure 1 A schematic diagram of an exemplary system architecture that can apply the technical solutions of one or more embodiments of this application is shown. Figure 1 As shown, the system architecture 100 may include terminal device 110, network 120, and server 130. Terminal device 110 may include various electronic devices such as smartphones, tablets, laptops, and desktop computers. Server 130 may be a standalone physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server providing cloud computing services. Network 120 may be a communication medium of various connection types capable of providing a communication link between terminal device 110 and server 130, such as a wired communication link or a wireless communication link.

[0095] Depending on the implementation requirements, the system architecture in this application embodiment can have any number of terminal devices, networks, and servers. For example, server 130 can be a server group composed of multiple server devices. In addition, the technical solutions provided in this application embodiment can be applied to terminal device 110, or to server 130, or can be implemented jointly by terminal device 110 and server 130. This application does not impose any special limitations on this.

[0096] In one embodiment of this application, the terminal device 110 or server 130 can acquire pre-generated or real-time generated data as target data; then, it performs data synchronization based on the target data and caches the data that has not been synchronized to a temporary storage directory; it then determines whether there is cached data in the temporary storage directory, and if there is cached data, it writes the cached data and target data together into a pre-created log file and records the number of file writes at this time; or, if there is no cached data in the temporary storage directory, it writes the target data into the pre-created log file and records the number of file writes at this time; finally, it compares the recorded number of file writes with a preset data upload threshold, and reads the data from the log file into the data upload queue for fragmented upload based on the comparison result. By using the terminal device 110 or server 130 to execute the data processing method, the target data can be uploaded in fragments, which not only reduces the number of network requests, but also stores the uploaded data when the network fluctuates, avoiding frequent duplicate uploads due to network problems during the data upload process.

[0097] The above section introduced an exemplary system architecture that applies the technical solution of this application. Next, we will continue to introduce the data processing method of this application.

[0098] Figure 2 A schematic flowchart of a data processing method according to an embodiment of this application is shown. Specifically, in an exemplary embodiment, as follows... Figure 2 As shown, this embodiment provides a data processing method, which includes the following steps:

[0099] S210, acquire pre-generated or real-time generated data, and record it as target data;

[0100] S220, perform data synchronization based on the target data, and cache the data that has not been synchronized to a temporary storage directory;

[0101] S230, determine whether there is cached data in the temporary storage directory, and if there is cached data in the temporary storage directory, write the cached data and the target data together into a pre-created log file and record the number of file writes at this time; or, if there is no cached data in the temporary storage directory, write the target data into a pre-created log file and record the number of file writes at this time.

[0102] S240, compare the number of records written to the file with the preset data upload threshold, and read the data from the log file into the data upload queue for fragmented upload based on the comparison result.

[0103] Therefore, this embodiment can reduce the number of network requests by uploading the target data in segments, and can also store the uploaded data when the network fluctuates, thus avoiding frequent duplicate uploads due to network problems during the data upload process.

[0104] According to the above description, in an exemplary embodiment, the process of reading data from the log file into the data upload queue for fragmented upload based on the comparison result includes: when the number of file writes is greater than the preset data upload threshold, reading data from the log file into the data upload queue, sending a direct upload message, and waiting for fragmented upload of the data in the data upload queue; or, when the number of file writes is less than or equal to the preset data upload threshold, reading data from the log file into the data upload field, transmitting the data from the data upload field to the data upload queue, sending a direct upload message, and waiting for fragmented upload of the data in the data upload queue. The preset data upload threshold in this embodiment can be set according to actual conditions, and this embodiment does not impose a specific numerical limit. As an example, the data upload threshold in this embodiment is set to 6 entries. Wherein, when the number of file writes is greater than the preset data upload threshold, this embodiment can also clear the number of file writes, delay for a first time before reading data from the log file into the data upload queue, and wait for a second time before sending the direct upload message; wherein, the duration of the first time is less than the duration of the second time. Specifically, when the number of records written to the file, mAPPRecordNum, exceeds the data upload threshold ONCE_UPLOAD_NUM, the number of records written to the file, mAPPRecordNum, is cleared. After a 100-millisecond delay, data is read from the log file APP_RECORD_FILE or the log file mAppDataRecordFile storing all data to be uploaded into the data upload queue, mLocalRecordQueue. In this embodiment, the number of data records read from the log file mAppDataRecordFile storing all data to be uploaded into the data upload queue is mUploadDataNum + ONCE_UPLOAD_NUM. Then, the message msg is cleared, and after waiting for another 10 seconds, the direct upload message UPLOAD_DIRECT_MSG is sent. This embodiment ensures that the process completes once within 10 seconds by waiting for 10 seconds. The reading process is repeated once more, reading mUploadDataNum+ONCE_UPLOAD_NUM data entries from the log file mAppDataRecordFile that stores all data to be uploaded into the direct upload field UPLOAD_TYPE, and then transmitting the data from the direct upload field UPLOAD_TYPE to the data upload queue mgocalRecordQueue.

[0105] According to the above description, in an exemplary embodiment, the process of uploading data in the data upload queue in chunks includes: responding to the direct upload message and waking up the polling upload data thread according to the response result; using the polling upload data thread to poll the data upload queue, uploading the data in chunks in the data upload queue, until the polling upload data thread enters a blocked state, and then ending the polling; or, ending the polling when the field type corresponding to the data extracted by the polling upload data thread from the data upload queue is an end field; wherein, when the polling upload data thread polls the data upload queue, if there is no data in the data upload queue, the polling upload data thread enters a blocked state.

[0106] In this embodiment, the process of using the polling upload data thread to poll the data upload queue and upload the data in chunks includes: using the polling upload data thread to poll the data upload queue and reading the data in the data upload queue, which is recorded as data to be uploaded. The fields of the data to be uploaded are matched with preset fields to determine the field type of the data to be uploaded. If the field type of the data to be uploaded belongs to the preset fields, the data to be uploaded is directly chunked and uploaded, or the polling upload data thread's access to the data upload queue is terminated. If the field type of the data to be uploaded does not belong to the preset fields, the data to be uploaded is transferred to the temporary storage directory, and when the number of data entries in the temporary storage directory exceeds the preset data upload threshold, the data to be uploaded in the temporary storage directory is chunked and uploaded. According to the above description, in this embodiment, if the preset fields include a direct upload field and an end field, the method further includes: matching the fields of the data to be uploaded with the direct upload field and the end field; if the field type of the data to be uploaded is a direct upload field, then the data to be uploaded will be directly uploaded in chunks; if the field type of the data to be uploaded is an end field, then the polling access of the polling upload data thread to the data upload queue will be terminated.

[0107] As an example, specifically, after waking up the polling upload data thread `mReadQueueDataThread`, the main purpose of this thread is to poll the queue of data to be uploaded, namely the data upload queue `mLocalRecordQueue`. Because it is a polling thread, it continuously reads data from the data upload queue `mLocalRecordQueue`, processing each piece of data and performing corresponding logical processing based on the retrieved data. It is worth noting that because the polling upload data thread `mReadQueueDataThread` uses a blocking queue, during the polling process, if there is no data to read in the data upload queue `mLocalRecordQueue`, the thread will directly enter a blocked state, which can be logically considered as a stop, until new data enters the data upload queue `mLocalRecordQueue` before continuing. After the polling upload data thread `mReadQueueDataThread` reads data from the data upload queue `mLocalRecordQueue`, it first checks the `type` field of the data for corresponding logical judgment. There are two main types: the direct upload field `UPLOAD_TYPE` and the end field `END_TYPE`. If it's the end field `END_TYPE`, the loop will exit immediately, stopping the entire polling upload data thread `mReadQueueDataThread`. Next, it checks the direct upload field `UPLOAD_TYPE`. This field requires direct upload. If the parsed data row contains the direct upload field `UPLOAD_TYPE`, the upload logic will begin immediately. If it's not one of these two types, the read data will first be stored in the temporary upload storage directory `mUpLoadList`. Because it's continuously polling and most data is neither the `UPLOAD_TYPE` nor the end field `END_TYPE`, the size of the temporary upload storage directory `mUpLoadListsize` will continuously increase. The upload logic will only begin when it exceeds the data upload threshold `ONCE_UPLOAD_NUM`.

[0108] In an exemplary embodiment, before waking up the polling data upload thread, the method may further include: obtaining a pre-created log transfer file; reading data from the log file that has not yet been uploaded in segments into the log transfer file, and deleting the log file; modifying the attributes of the log transfer file containing the read data, and using the log transfer file with the modified attributes as the log file. Specifically, in this embodiment, before waking up the polling data upload thread, an initialization message INIT_DATA_MSG is first sent to the processing center to clear the data already uploaded from the log file APP_RECORD_FILE. During this clearing process, the previously created log transfer file TEMP_RECORD_FILE is used. The specific process involves reading the remaining data from the log file APP_RECORD_FILE (after it has been uploaded to the server) into the log transfer file TEMP_RECORD_FILE. Then, the log file APP_RECORD_FILE is deleted, and the temporary file is renamed to the log file APP_RECORD_FILE to keep the log file up-to-date. After clearing, the variables that control the log status are reset.

[0109] In an exemplary embodiment, the process of waking up the polling data upload thread based on the response result includes: creating a network listening broadcast based on the response result, and determining whether the current network is available based on the network listening broadcast; if the current network is unavailable, recording the current network status and suspending the polling data upload thread to wait for it to be woken up; if the current network is available, waking up the polling data upload thread to allow it to poll the data upload queue.

[0110] In one specific embodiment, this embodiment also provides a data processing method, the method including an initialization process, a data upload process, and a data storage and deregistration process. The initialization and data upload processes are as follows: Figure 3 As shown, data storage is as follows Figure 4 As shown, the cancellation process is as follows: Figure 5 As shown.

[0111] Specifically, such as Figure 3 As shown, the first step is file initialization. This step mainly involves creating two files: a log file (APP_RECORD_FILE) to record the content to be uploaded, and a log transfer file (TEMP_RECORD_FILE) for temporary storage. Simultaneously, a network listener / broadcast is registered to record network status changes when there are network fluctuations.

[0112] The second, more complex part involves creating a looping query thread to check if there is any data to upload. First, an initialization message `INIT_DATA_MSG` is sent to the processing center. Data already uploaded to the file is then cleared from the log file `APP_RECORD_FILE`. This clearing process utilizes the previously created log transfer file `TEMP_RECORD_FILE`. Specifically, the remaining data already uploaded to the server is read from the log file `APP_RECORD_FILE` and transferred to `TEMP_RECORD_FILE`. Then, the log file `APP_RECORD_FILE` is deleted, and a temporary file is renamed to `APP_RECORD_FILE` to keep the log file up-to-date. After clearing, the log status variables are reset.

[0113] At this point, a polling thread `mReadQueueDataThread` is started. The main purpose of this thread is to poll the queue of data to be uploaded, specifically the data upload queue `mLocalRecordQueue`. Because it's a polling thread, it continuously reads data from the `mLocalRecordQueue`, processing each data entry one at a time and performing corresponding logical processing based on the retrieved data. It's important to note that because `mReadQueueDataThread` uses a blocking queue, during the polling process, if there is no data to read in the `mLocalRecordQueue`, the thread will directly enter a blocked state, which can be logically considered as a pause, until new data is added to the `mLocalRecordQueue` before resuming. After the polling upload data thread `mReadQueueDataThread` reads data from the data upload queue `mLocalRecordQueue`, it first checks the `type` field of the data for corresponding logical judgment. There are two main types: the direct upload field `UPLOAD_TYPE` and the end field `END_TYPE`. If it's the end field `END_TYPE`, the loop will exit immediately, stopping the entire polling upload data thread `mReadQueueDataThread`. Next, it checks the direct upload field `UPLOAD_TYPE`. This field requires direct upload. If the parsed data row contains the direct upload field `UPLOAD_TYPE`, the upload logic will begin immediately. If it's not one of these two types, the read data will first be stored in the temporary upload storage directory `mUpLoadList`. Because it's continuously polling and most data is neither the `UPLOAD_TYPE` nor the end field `END_TYPE`, the size of the temporary upload storage directory `mUpLoadListsize` will continuously increase. The upload logic will only begin when it exceeds the data upload threshold `ONCE_UPLOAD_NUM`.

[0114] like Figure 4As shown, the data storage logic is triggered when data needs to be uploaded. To ensure the integrity of the uploaded data, it first checks whether data synchronization is in progress. If data synchronization is in progress, the data will be cached in the temporary storage directory mBckUplist during the data synchronization process. If synchronization is complete, it checks whether there is cached data. If there is cached data, it will first be written to the initialized log file APP_RECORD_FILE via the file write stream mAppDataRecordWriter. Otherwise, the current data is directly written to the file, and a counter is added to record the data. When there are 6 data entries, it starts reading data from the file into the data upload queue mgocalRecordQueue. One advantage of doing this is to reduce the number of network requests and achieve the purpose of chunked upload.

[0115] like Figure 5 As shown, after reading the data from the log file into the data upload queue for chunked upload, the method further includes: enabling the deregistration process, releasing the file write stream associated with the log file, cleaning up direct upload messages, and clearing the polling upload data thread. Specifically, in Figure 5 In this context, every initialization process necessitates a corresponding deregistration process, as queues, threads, and broadcast receivers are used during initialization. Deregistration also requires deregistering the corresponding components; otherwise, memory leaks and other issues may occur. When the user actively calls the `ondestroy` callback method to end the process, the file write stream should be closed, the processing queue cleared, the broadcast receiver deregistered, and the file synchronized once.

[0116] In summary, this application provides a data processing method. First, it acquires pre-generated or real-time generated data as target data. Then, it performs data synchronization based on the target data, caching any data that has not yet been synchronized to a temporary storage directory. Next, it determines whether cached data exists in the temporary storage directory. If cached data exists, it writes both the cached data and the target data into a pre-created log file, recording the number of file writes at that time. Alternatively, if cached data does not exist in the temporary storage directory, it writes the target data into the pre-created log file, recording the number of file writes at that time. Finally, it compares the recorded number of file writes with a preset data upload threshold, and based on the comparison result, reads the data from the log file into a data upload queue for fragmented upload. Therefore, this method, by uploading target data in fragments, not only reduces the number of network requests but also stores uploaded data even when network fluctuations occur, avoiding frequent duplicate uploads due to network issues during the data upload process.

[0117] like Figure 6 As shown, this application also provides a data processing system, which includes:

[0118] Data acquisition module 610 is used to acquire pre-generated or real-time generated data, denoted as target data;

[0119] The data synchronization module 620 is used to perform data synchronization based on the target data and cache the data that has not been synchronized to a temporary storage directory;

[0120] The cache data determination module 630 is used to determine whether cache data exists in the temporary storage directory;

[0121] The data writing module 640 is used to write the cached data and the target data together into a pre-created log file when cached data exists in the temporary storage directory, and record the number of file writes at this time; or, when cached data does not exist in the temporary storage directory, write the target data into the pre-created log file and record the number of file writes at this time.

[0122] The comparison module 650 is used to compare the number of file writes recorded by the data writing module with the preset data upload threshold.

[0123] The chunked upload module 660 is used to read the data from the log file into the data upload queue for chunked upload based on the comparison results.

[0124] Therefore, this embodiment can reduce the number of network requests by uploading the target data in segments, and can also store the uploaded data when the network fluctuates, thus avoiding frequent duplicate uploads due to network problems during the data upload process.

[0125] According to the above description, in an exemplary embodiment, the process of the chunked upload module 660 reading data from the log file into the data upload queue for chunked upload based on the comparison result includes: when the number of file writes is greater than the preset data upload threshold, reading data from the log file into the data upload queue, sending a direct upload message, and waiting for chunked upload of the data in the data upload queue; or, when the number of file writes is less than or equal to the preset data upload threshold, reading data from the log file into the data upload field, transmitting the data from the data upload field to the data upload queue, and sending a direct upload message, and waiting for chunked upload of the data in the data upload queue. The preset data upload threshold in this embodiment can be set according to actual conditions, and this embodiment does not impose a specific numerical limit. As an example, the data upload threshold in this embodiment is set to 6 entries. Wherein, when the number of file writes is greater than the preset data upload threshold, this embodiment can also clear the number of file writes, delay reading data from the log file into the data upload queue for a first time, and wait for a second time before sending the direct upload message; wherein, the duration of the first time is less than the duration of the second time. Specifically, when the number of records written to the file, mAPPRecordNum, exceeds the data upload threshold ONCE_UPLOAD_NUM, the number of records written to the file, mAPPRecordNum, is cleared. After a 100-millisecond delay, data is read from the log file APP_RECORD_FILE or the log file mAppDataRecordFile storing all data to be uploaded into the data upload queue, mLocalRecordQueue. In this embodiment, the number of data records read from the log file mAppDataRecordFile storing all data to be uploaded into the data upload queue is mUploadDataNum + ONCE_UPLOAD_NUM. Then, the message msg is cleared, and after waiting for another 10 seconds, the direct upload message UPLOAD_DIRECT_MSG is sent. This embodiment ensures that the process completes once within 10 seconds by waiting for 10 seconds. The reading process is repeated once more, reading mUploadDataNum+ONCE_UPLOAD_NUM data entries from the log file mAppDataRecordFile that stores all data to be uploaded into the direct upload field UPLOAD_TYPE, and then transmitting the data from the direct upload field UPLOAD_TYPE to the data upload queue mgocalRecordQueue.

[0126] According to the above description, in an exemplary embodiment, the process of the fragmented upload module 660 uploading data in the data upload queue in fragments may further include: responding to the direct upload message and waking up the polling upload data thread according to the response result; using the polling upload data thread to poll the data upload queue, uploading the data in the data upload queue in fragments, until the polling upload data thread enters a blocked state, and then ending the polling; or, ending the polling when the field type corresponding to the data extracted by the polling upload data thread from the data upload queue is an end field; wherein, when the polling upload data thread polls the data upload queue, if there is no data in the data upload queue, the polling upload data thread enters a blocked state.

[0127] In this embodiment, the process of using the polling upload data thread to poll the data upload queue and upload the data in chunks includes: using the polling upload data thread to poll the data upload queue and reading the data in the data upload queue, which is recorded as data to be uploaded. The fields of the data to be uploaded are matched with preset fields to determine the field type of the data to be uploaded. If the field type of the data to be uploaded belongs to the preset fields, the data to be uploaded is directly chunked and uploaded, or the polling upload data thread's access to the data upload queue is terminated. If the field type of the data to be uploaded does not belong to the preset fields, the data to be uploaded is transferred to the temporary storage directory, and when the number of data entries in the temporary storage directory exceeds the preset data upload threshold, the data to be uploaded in the temporary storage directory is chunked and uploaded. According to the above description, in this embodiment, if the preset fields include a direct upload field and an end field, the system further includes: matching the fields of the data to be uploaded with the direct upload field and the end field; if the field type of the data to be uploaded is a direct upload field, then the data to be uploaded will be directly uploaded in segments; if the field type of the data to be uploaded is an end field, then the polling access of the polling upload data thread to the data upload queue will be terminated.

[0128] As an example, specifically, after waking up the polling upload data thread `mReadQueueDataThread`, the main purpose of this thread is to poll the queue of data to be uploaded, namely the data upload queue `mLocalRecordQueue`. Because it is a polling thread, it continuously reads data from the data upload queue `mLocalRecordQueue`, processing each piece of data and performing corresponding logical processing based on the retrieved data. It is worth noting that because the polling upload data thread `mReadQueueDataThread` uses a blocking queue, during the polling process, if there is no data to read in the data upload queue `mLocalRecordQueue`, the thread will directly enter a blocked state, which can be logically considered as a stop, until new data enters the data upload queue `mLocalRecordQueue` before continuing. After the polling upload data thread `mReadQueueDataThread` reads data from the data upload queue `mLocalRecordQueue`, it first checks the `type` field of the data for corresponding logical judgment. There are two main types: the direct upload field `UPLOAD_TYPE` and the end field `END_TYPE`. If it's the end field `END_TYPE`, the loop will exit immediately, stopping the entire polling upload data thread `mReadQueueDataThread`. Next, it checks the direct upload field `UPLOAD_TYPE`. This field requires direct upload. If the parsed data row contains the direct upload field `UPLOAD_TYPE`, the upload logic will begin immediately. If it's not one of these two types, the read data will first be stored in the temporary upload storage directory `mUpLoadList`. Because it's continuously polling and most data is neither the `UPLOAD_TYPE` nor the end field `END_TYPE`, the size of the temporary upload storage directory `mUpLoadListsize` will continuously increase. The upload logic will only begin when it exceeds the data upload threshold `ONCE_UPLOAD_NUM`.

[0129] In an exemplary embodiment, before waking up the polling data upload thread, the system may further include: obtaining a pre-created log transfer file; reading data from the log file that has not yet been uploaded in segments into the log transfer file, and deleting the log file; modifying the attributes of the log transfer file containing the read data, and using the log transfer file with the modified attributes as the log file. Specifically, in this embodiment, before waking up the polling data upload thread, an initialization message INIT_DATA_MSG is first sent to the processing center to clear the data already uploaded from the log file APP_RECORD_FILE. During this clearing process, the previously created log transfer file TEMP_RECORD_FILE is used. The specific process involves reading the remaining data from the log file APP_RECORD_FILE (after it has been uploaded to the server) into the log transfer file TEMP_RECORD_FILE. Then, the log file APP_RECORD_FILE is deleted, and the temporary file is renamed to the log file APP_RECORD_FILE to keep the log file up-to-date. After clearing, the variables that control the log status are reset.

[0130] In an exemplary embodiment, the process of waking up the polling data upload thread based on the response result includes: creating a network listening broadcast based on the response result, and determining whether the current network is available based on the network listening broadcast; if the current network is unavailable, recording the current network status and suspending the polling data upload thread to wait for it to be woken up; if the current network is available, waking up the polling data upload thread to allow it to poll the data upload queue.

[0131] In one specific embodiment, this embodiment also provides a data processing system, which is used to execute an initialization process, a data upload process, and a data storage and deregistration process. The initialization and data upload processes are as follows: Figure 3 As shown, data storage is as follows Figure 4 As shown, the cancellation process is as follows: Figure 5 As shown.

[0132] Specifically, such as Figure 3 As shown, the first step is file initialization. This step mainly involves creating two files: a log file (APP_RECORD_FILE) to record the content to be uploaded, and a log transfer file (TEMP_RECORD_FILE) for temporary storage. Simultaneously, a network listener / broadcast is registered to record network status changes when there are network fluctuations.

[0133] The second, more complex part involves creating a looping query thread to check if there is any data to upload. First, an initialization message `INIT_DATA_MSG` is sent to the processing center. Data already uploaded to the file is then cleared from the log file `APP_RECORD_FILE`. This clearing process utilizes the previously created log transfer file `TEMP_RECORD_FILE`. Specifically, the remaining data already uploaded to the server is read from the log file `APP_RECORD_FILE` and transferred to `TEMP_RECORD_FILE`. Then, the log file `APP_RECORD_FILE` is deleted, and a temporary file is renamed to `APP_RECORD_FILE` to keep the log file up-to-date. After clearing, the log status variables are reset.

[0134] At this point, a polling thread `mReadQueueDataThread` is started. The main purpose of this thread is to poll the queue of data to be uploaded, specifically the data upload queue `mLocalRecordQueue`. Because it's a polling thread, it continuously reads data from the `mLocalRecordQueue`, processing each data entry one at a time and performing corresponding logical processing based on the retrieved data. It's important to note that because `mReadQueueDataThread` uses a blocking queue, during the polling process, if there is no data to read in the `mLocalRecordQueue`, the thread will directly enter a blocked state, which can be logically considered as a pause, until new data is added to the `mLocalRecordQueue` before resuming. After the polling upload data thread `mReadQueueDataThread` reads data from the data upload queue `mLocalRecordQueue`, it first checks the `type` field of the data for corresponding logical judgment. There are two main types: the direct upload field `UPLOAD_TYPE` and the end field `END_TYPE`. If it's the end field `END_TYPE`, the loop will exit immediately, stopping the entire polling upload data thread `mReadQueueDataThread`. Next, it checks the direct upload field `UPLOAD_TYPE`. This field requires direct upload. If the parsed data row contains the direct upload field `UPLOAD_TYPE`, the upload logic will begin immediately. If it's not one of these two types, the read data will first be stored in the temporary upload storage directory `mUpLoadList`. Because it's continuously polling and most data is neither the `UPLOAD_TYPE` nor the end field `END_TYPE`, the size of the temporary upload storage directory `mUpLoadListsize` will continuously increase. The upload logic will only begin when it exceeds the data upload threshold `ONCE_UPLOAD_NUM`.

[0135] like Figure 4As shown, the data storage logic is triggered when data needs to be uploaded. To ensure the integrity of the uploaded data, it first checks whether data synchronization is in progress. If data synchronization is in progress, the data will be cached in the temporary storage directory mBckUplist during the data synchronization process. If synchronization is complete, it checks whether there is cached data. If there is cached data, it will first be written to the initialized log file APP_RECORD_FILE via the file write stream mAppDataRecordWriter. Otherwise, the current data is directly written to the file, and a counter is added to record the data. When there are 6 data entries, it starts reading data from the file into the data upload queue mgocalRecordQueue. One advantage of doing this is to reduce the number of network requests and achieve the purpose of chunked upload.

[0136] like Figure 5 As shown, after reading the data from the log file into the data upload queue for fragmented upload, the system further includes: enabling the deregistration process, releasing the file write stream associated with the log file, cleaning up direct upload messages, and clearing the polling upload data thread. Specifically, in Figure 5 In this context, every initialization process necessitates a corresponding deregistration process, as queues, threads, and broadcast receivers are used during initialization. Deregistration also requires deregistering the corresponding components; otherwise, memory leaks and other issues may occur. When the user actively calls the `ondestroy` callback method to end the process, the file write stream should be closed, the processing queue cleared, the broadcast receiver deregistered, and the file synchronized once.

[0137] In summary, this application provides a data processing system that first acquires pre-generated or real-time generated data as target data; then, it performs data synchronization based on the target data and caches data that has not yet been synchronized to a temporary storage directory; next, it determines whether cached data exists in the temporary storage directory, and if cached data exists, it writes both the cached data and the target data into a pre-created log file, recording the number of file writes at this time; alternatively, if cached data does not exist in the temporary storage directory, it writes the target data into the pre-created log file, recording the number of file writes at this time; finally, it compares the recorded number of file writes with a preset data upload threshold, and based on the comparison result, reads the data from the log file into a data upload queue for fragmented upload. Therefore, this system, by uploading target data in fragments, not only reduces the number of network requests but also stores uploaded data when network fluctuations occur, avoiding frequent duplicate uploads due to network issues during the data upload process.

[0138] It should be noted that the data processing system provided in the above embodiments and the data processing method provided in the above embodiments belong to the same concept. The specific ways in which each module and unit performs operations have been described in detail in the method embodiments, and will not be repeated here. In practical applications, the data processing system provided in the above embodiments can be assigned to different functional modules as needed, that is, the internal structure of the system can be divided into different functional modules to complete all or part of the functions described above, and this is not a limitation here.

[0139] This application also provides a vehicle equipped with at least one application program; wherein the application program is used to generate target data as described in any of the data processing methods above. It should be noted that the target data processing method provided in this embodiment belongs to the same concept as the data processing methods provided in the above embodiments, so it will not be described again in this embodiment.

[0140] Embodiments of this application also provide an electronic device, including: one or more processors; and a storage device for storing one or more programs, which, when executed by the one or more processors, cause the electronic device to implement the data processing methods provided in the above embodiments.

[0141] Figure 7 A schematic diagram of a computer system suitable for implementing the embodiments of this application is shown. It should be noted that... Figure 7 The computer system 1000 of the electronic device shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of this application.

[0142] like Figure 7 As shown, the computer system 700 includes a Central Processing Unit (CPU) 701, which can perform various appropriate actions and processes based on programs stored in Read-Only Memory (ROM) 702 or programs loaded from storage portion 708 into Random Access Memory (RAM) 703, such as performing the methods described in the above embodiments. The RAM 703 also stores various programs and data required for system operation. The CPU 701, ROM 702, and RAM 703 are interconnected via a bus 704. An Input / Output (I / O) interface 705 is also connected to the bus 704.

[0143] The following components are connected to the I / O interface 705: an input section 706 including a keyboard, mouse, etc.; an output section 707 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and speakers, etc.; a storage section 708 including a hard disk, etc.; and a communication section 709 including a network interface card such as a LAN (Local Area Network) card, modem, etc. The communication section 709 performs communication processing via a network such as the Internet. A drive 710 is also connected to the I / O interface 705 as needed. A removable medium 711, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on the drive 710 as needed so that computer programs read from it can be installed into the storage section 708 as needed.

[0144] Specifically, according to embodiments of this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program including a computer program for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 709, and / or installed from removable medium 711. When the computer program is executed by central processing unit (CPU) 701, it performs various functions defined in the system of this application.

[0145] It should be noted that the computer-readable medium shown in the embodiments of this application can be a computer-readable signal medium or a computer-readable storage medium, or any combination of the two. A computer-readable storage medium can be, for example, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), flash memory, optical fiber, portable compact disc read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this application, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying a computer-readable computer program. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. Computer-readable signal media can also be any computer-readable medium other than computer-readable storage media, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The computer program contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to wireless, wired, etc., or any suitable combination thereof.

[0146] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. Each block in a flowchart or block diagram may represent a module, segment, or portion of code, which contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, and combinations of blocks in a block diagram or flowchart, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0147] The units described in the embodiments of this application can be implemented in software or hardware, and the described units can also be located in a processor. The names of these units do not necessarily limit the specific unit itself.

[0148] Another aspect of this application provides a computer-readable storage medium storing a computer program thereon, which, when executed by a computer's processor, causes the computer to perform the data processing method as described above. This computer-readable storage medium may be included in the electronic device described in the above embodiments, or it may exist independently and not assembled into the electronic device.

[0149] Another aspect of this application provides a computer program product or computer program including computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the data processing methods provided in the various embodiments described above.

[0150] The above embodiments are merely illustrative of the principles and effects of the present invention and are not intended to limit the invention. Any person skilled in the art can modify or alter the above embodiments without departing from the spirit and scope of the present invention. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical concept disclosed in the present invention should still be covered by the claims of the present invention.

Claims

1. A data processing method, characterized by, The method comprises the following steps: acquiring pre-generated or real-time generated data, denoted as target data; performing data synchronization based on the target data, and caching data that has not completed data synchronization to a temporary storage directory; determining whether there is cached data in the temporary storage directory, and when there is cached data in the temporary storage directory, jointly writing the cached data and the target data to a pre-created log record file, and recording the file write number at this time; or when there is no cached data in the temporary storage directory, writing the target data to a pre-created log record file, and recording the file write number at this time; comparing the recorded file write number with a preset data upload threshold, and reading data in the log record file to a data upload queue for fragmented upload according to the comparison result, including: when the file write number is greater than the preset data upload threshold, reading data from the log record file to the data upload queue and sending a direct upload message, and waiting for fragmented upload of data in the data upload queue; or when the file write number is less than or equal to the preset data upload threshold, reading data from the log record file to a data upload field and transmitting the data to the data upload queue by the data upload field, and sending a direct upload message, and waiting for fragmented upload of data in the data upload queue; wherein the process of fragmented upload of data in the data upload queue comprises: responding to the direct upload message, and waking up a polling upload data thread according to the response result; polling the data upload queue by using the polling upload data thread to perform fragmented upload of data in the data upload queue, and ending polling when the polling upload data thread enters a blocked state; or ending polling when the field type corresponding to the data extracted from the data upload queue by the polling upload data thread is an end field; wherein when the polling upload data thread polls the data upload queue, if there is no data in the data upload queue, the polling upload data thread enters a blocked state.

2. The data processing method according to claim 1, characterized in that, The process of polling the data upload queue by using the polling upload data thread to perform fragmented upload of data in the data upload queue comprises: polling the data upload queue by using the polling upload data thread, and reading data in the data upload queue, denoted as to-be-uploaded data; matching the fields of the to-be-uploaded data with preset fields to determine the field type of the to-be-uploaded data; if the field type of the to-be-uploaded data belongs to the preset fields, directly performing fragmented upload of the to-be-uploaded data, or ending polling of the data upload queue by the polling upload data thread; If the field type of the data to be uploaded does not belong to the preset field, the data to be uploaded is transmitted to the temporary storage directory, and when the number of data in the temporary storage directory is greater than the preset data upload threshold, the data to be uploaded in the temporary storage directory is uploaded in slices.

3. The data processing method according to claim 2, characterized in that, If the preset field includes a direct upload field and an end field, the method further includes: matching the field of the data to be uploaded with the direct upload field and the end field; if the field type of the data to be uploaded is a direct upload field, the data to be uploaded is directly uploaded in slices; if the field type of the data to be uploaded is an end field, the polling access of the data upload queue by the polling data upload thread is ended.

4. The data processing method according to any one of claims 1 to 3, characterized in that, Before waking up the polling data upload thread, the method further includes: obtaining a pre-created log dump file; reading the data in the log record file that has not completed slice uploading into the log dump file, and deleting the log record file; performing attribute changes on the log dump file of the read data, and taking the log dump file after the attribute changes as a log record file.

5. The data processing method according to any one of claims 1 to 3, characterized in that, The process of waking up the polling data upload thread according to the response result includes: creating a network listening broadcast according to the response result, and judging whether the current network is available based on the network listening broadcast; if the current network is not available, recording the current network state, and suspending the polling data upload thread to wait, so that the polling data upload thread waits to be woken up; if the current network is available, waking up the polling data upload thread, so that the polling data upload thread polls the data upload queue.

6. The data processing method according to any one of claims 1 to 3, characterized in that, After reading the data in the log record file into the data upload queue for slice uploading, the method further includes: enabling a logout process, releasing the file write stream associated with the log record file, cleaning the direct upload message, and emptying the polling data upload thread.

7. The data processing method according to any one of claims 1 to 3, characterized in that, When the number of file writes is greater than the preset data upload threshold, the method further includes: emptying the number of file writes, and after delaying for a first time, reading data from the log record file into the data upload queue, and after waiting for a second time, sending the direct upload message; wherein the duration of the first time is less than the duration of the second time.

8. A data processing system, characterized by The system includes: a data collection module for obtaining pre-generated or real-time generated data, denoted as target data; a data synchronization module for synchronizing data according to the target data, and buffering data that has not completed data synchronization to a temporary storage directory; a buffered data judgment module for judging whether there is buffered data in the temporary storage directory; a data write module for writing the buffered data and the target data into a pre-created log record file when there is buffered data in the temporary storage directory, and recording the number of file writes at this time; or, when there is no buffered data in the temporary storage directory, writing the target data into a pre-created log record file, and recording the number of file writes at this time; The comparison module is configured to compare the number of file write entries recorded by the file writing module with a preset data uploading threshold; The file writing module is configured to write a log record file, and the file writing module comprises: a file writing module, a comparison module, a data uploading queue, a data uploading field, and a polling uploading data thread.

9. An electronic device, comprising: The electronic device comprises: one or more processors; The electronic device comprises:

10. A computer-readable storage medium, characterized in that, one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises: one or more processors; The electronic device comprises

Images