Cross-platform IPA packet uploading method, system and device based on Flutter and medium

Abstract

The invention discloses a Flutter-based cross-platform IPA packet uploading method, system and device and a medium, and the method specifically comprises the following steps: using a Flutter framework to develop a desktop application, and pre-packaging an iTMSTranport command line tool and a Java runtime environment in the desktop application; based on the desktop application, responding to user dragging or file selection operation to obtain an IPA file, automatically decompressing the IPA file and performing file analysis to obtain an analysis result; dynamically generating a command line instruction according to an analysis result; on the basis of a command line instruction, an uploading command is executed through a protossrun library promoter sub-process of the Flutter, and a command line output stream is captured in real time; and monitoring an exit code of the sub-process and a success identifier or an error identifier in the output stream, generating an uploading result report and triggering a system notification. According to the method, the key tool and the environment are integrated in the Flutter desktop application, so that a cross-platform IPA packet uploading function is realized, a unified and convenient operation entrance is provided for a user, platform limitation is broken, and development efficiency and experience are improved.

Description

Technical Field

[0001] This invention relates to the field of software development technology, and in particular to a method, system, device, and medium for uploading cross-platform IPA packages based on Flutter. Background Technology

[0002] In the current iOS mobile application development and release process, accurately and efficiently uploading the IPA package to the App Store is a crucial step, directly impacting the application's release schedule and final online performance. Currently, Apple provides developers with two main upload tools, but both have significant limitations and cannot meet developers' diverse needs in areas such as cross-platform operation, user experience, and login authentication.

[0003] On the one hand, while Apple's Transporter App provides some convenience for developers to upload IPA packages, it suffers from serious platform limitations. The tool only runs on Mac systems, a feature that poses a significant obstacle for developers using Windows and Linux systems when uploading IPA packages. In today's increasingly cross-platform development landscape, developers often need to work in different operating system environments, and the platform limitations of the Transporter App greatly restrict developers' operational flexibility, increase development costs and time consumption, and reduce overall development efficiency.

[0004] On the other hand, while Apple's iTMSTransporter command-line tool overcomes platform limitations to some extent and can theoretically be used on multiple operating systems, its actual user experience is poor. This tool uses a command-line interface, requiring developers to have certain command-line operation knowledge and skills, making it quite difficult to use for developers unfamiliar with the command line. Furthermore, the iTMSTransporter command-line tool requires developers to install and configure a complex runtime environment, including a Java runtime environment. This not only increases the complexity and tediousness of the operation but also easily leads to various problems caused by improper environment configuration, such as upload failures and tool malfunctions, severely impacting the developer's user experience and work efficiency.

[0005] Meanwhile, logging into the aforementioned tools with Apple ID presents numerous inconveniences. Apple ID login requires secondary verification, increasing complexity and time costs, especially for developers who frequently upload data. Each login involves cumbersome verification steps, significantly reducing work efficiency. Furthermore, Apple ID login authentication has an expiration date, requiring developers to log in again after expiration, further increasing the cumbersomeness and uncertainty of the process, causing unnecessary trouble for developers.

[0006] In summary, existing IPA package upload tools have many problems in terms of cross-platform support, user experience, and login authentication, and cannot meet the diverse needs of developers in the actual development process. Summary of the Invention

[0007] The purpose of this invention is to provide a cross-platform IPA package uploading method, system, device, and medium based on Flutter. By integrating key tools and environment within the Flutter desktop application, the cross-platform IPA package uploading function is realized, providing users with a unified and convenient operation entry point, breaking platform limitations, and improving development efficiency and experience, thereby solving at least one of the aforementioned problems in the prior art.

[0008] In a first aspect, the present invention provides a cross-platform IPA package upload method based on Flutter, the method specifically including: Develop desktop applications using the Flutter framework, and pre-package the iTMSTransporter command-line tool and Java runtime environment within the desktop application; Receive Apple login information entered by the user through a desktop application, generate an authentication token based on the Apple login information, and store it persistently. Based on a desktop application, it responds to user drag-and-drop or file selection operations to obtain IPA files, automatically decompresses the IPA files and parses the files to obtain the parsing results; Command-line instructions are dynamically generated based on the parsing results. The parameters of the command-line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API. Based on command-line instructions, a child process is launched using Flutter's process_run library to execute the upload command, and the command-line output stream is captured in real time. Progress keywords are matched using regular expressions and converted into a visual progress bar. Monitor the exit code of the child process and the success or error identifier in the output stream, generate an upload result report and trigger a system notification.

[0009] Secondly, the present invention provides a cross-platform IPA package upload system based on Flutter, the system specifically comprising: The first upload module is used to develop desktop applications using the Flutter framework, and pre-packages the iTMSTransporter command-line tool and Java runtime environment within the desktop application; The second upload module is used to receive Apple login information entered by the user through the desktop application, generate an authentication token based on the Apple login information, and store it persistently. The third upload module is used to retrieve IPA files based on desktop applications by responding to user drag-and-drop or file selection operations, automatically decompressing the IPA file and parsing the file to obtain the parsing results; The fourth upload module is used to dynamically generate command-line instructions based on the parsing results. The parameters of the command-line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API. The fifth upload module is used to execute upload commands by launching a child process through Flutter's process_run library based on command line instructions, capturing the command line output stream in real time, matching progress keywords through regular expressions and converting them into a visual progress bar; The sixth upload module is used to monitor the exit code of the subprocess and the success or error identifier in the output stream, generate an upload result report and trigger system notifications.

[0010] Thirdly, the present invention provides a computer device, including: a memory and a processor, and a computer program stored in the memory, wherein when the computer program is executed on the processor, it implements the Flutter-based cross-platform IPA package upload method as described in any of the above methods.

[0011] Fourthly, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the Flutter-based cross-platform IPA package upload method as described in any of the above methods.

[0012] Compared with the prior art, the present invention has at least one of the following technical effects: 1. This invention integrates key tools and environments within the Flutter desktop application, enabling cross-platform IPA package upload functionality. This provides users with a unified and convenient operation entry point, breaks platform limitations, and improves development efficiency and user experience.

[0013] 2. This invention pre-packages platform-specific compilation tools and environments, and dynamically adapts and sandboxes them when the application starts, ensuring that the toolchain runs stably on different operating systems and avoiding environment conflicts and configuration problems.

[0014] 3. This invention utilizes encryption algorithms and device fingerprints to generate keys, and combines them with platform channel mechanisms to securely store authentication tokens, thereby enhancing the security of login information, reducing repeated login operations for users, and improving the convenience and reliability of authentication.

[0015] 4. This invention uses zero-copy memory mapping and streaming decompression technology to quickly obtain the content of IPA files. Through real-time scanning and targeted parsing, it efficiently extracts key metadata, providing accurate data support for subsequent instruction generation and improving parsing efficiency and accuracy.

[0016] 5. This invention dynamically calls the API to obtain the associated store ID based on the parsing results, and combines adaptive command templates and parameter processing technology to generate accurate and executable command line instructions, ensuring that the upload command is accurately matched with the IPA package and platform environment, thereby improving the upload success rate.

[0017] 6. This invention captures the upload progress in real time through non-blocking stream reading and regular expression matching technology, and converts it into a visual progress bar, so that users can clearly understand the upload status. At the same time, log text is output synchronously to facilitate troubleshooting and monitoring.

[0018] 7. This invention monitors the status and output stream of subprocesses in parallel, uses a multi-level matching and collaborative analysis mechanism to generate detailed upload reports, and provides interactive reminders and feedback through a native notification interface to help users keep track of upload results and handle abnormal situations in a timely manner. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in the embodiments of this application, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Figure 1 This is a flowchart illustrating a cross-platform IPA package upload method based on Flutter, according to an embodiment of the present invention. Figure 2 This is a schematic diagram of the structure of a cross-platform IPA package upload system based on Flutter, provided in an embodiment of the present invention; Figure 3 This is a schematic diagram of the structure of a computer device provided in an embodiment of the present invention. Detailed Implementation

[0021] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods have been omitted so as not to obscure the description of this application with unnecessary detail.

[0022] It should be understood that, when used in this application specification and the appended claims, the term "comprising" indicates the presence of the described features, integrals, steps, operations, elements and / or components, but does not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or a collection thereof.

[0023] It should also be understood that the term “and / or” as used in this application specification and the appended claims means any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0024] As used in this application specification and the appended claims, the term "if" may be interpreted, depending on the context, as "when," "once," "in response to determination," or "in response to detection." Similarly, the phrase "if determined" or "if detected [the described condition or event]" may be interpreted, depending on the context, as meaning "once determined," "in response to determination," "once detected [the described condition or event]," or "in response to detection [the described condition or event]."

[0025] Furthermore, in the description of this application and the appended claims, the terms "first," "second," "third," etc., are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0026] References to "one embodiment" or "some embodiments" as described in this specification mean that one or more embodiments of this application include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0027] In this application embodiment, the entity executing the process includes a terminal device. This terminal device includes, but is not limited to, devices capable of executing the methods disclosed in this application, such as servers, computers, smartphones, and tablets. Figure 1 A flowchart illustrating a cross-platform IPA package upload method based on Flutter, as disclosed in an embodiment of the present invention, is shown below in detail: S101 uses the Flutter framework to develop desktop applications and pre-packages the iTMSTransporter command-line tool and Java runtime environment within the desktop application.

[0028] In this embodiment, you can download the installation package for the corresponding operating system from the Flutter official website and install it according to the instructions in the official documentation. After installation, run the `flutter doctor` command in the terminal or command line to check whether the development environment is configured correctly and ensure that all necessary dependencies (such as Dart SDK, Android Studio, or Xcode development tools, depending on the target desktop platform) are correctly installed and configured. For the target desktop platform, configure accordingly based on different operating systems. For example, if developing a Windows desktop application, ensure that the Windows development toolchain is correctly installed; for a macOS desktop application, install Xcode to obtain the necessary development tools and libraries; for a Linux desktop application, install the corresponding build tools and dependency libraries.

[0029] Download the iTMSTransporter command-line tool for your target platform from Apple's official developer website or other legitimate channels. Ensure the downloaded version matches your current development environment and Apple's app upload requirements. After downloading, perform an integrity check on the file, such as by verifying the file's hash value, to ensure the file has not been corrupted or tampered with.

[0030] Create a dedicated directory structure to store the iTMSTransporter tool and its related files. For different platforms, the file structure may need to be adjusted accordingly. For example, on Windows, the executable file and related DLL files may need to be placed in the same directory; on macOS, issues such as tool permissions and code signing may need to be considered to ensure the tool can be called correctly within the application.

[0031] In the code logic of a Flutter desktop application, a path variable needs to be set to point to the pre-packaged iTMSTransporter tool directory. This ensures that the tool can be accurately located and invoked during application runtime. The complete tool invocation path can be constructed using appropriate path concatenation methods depending on the target platform.

[0032] Based on the Java version requirements of the iTMSTransporter tool, select a compatible Java Runtime Environment (JRE) version. You can download the appropriate JRE installation package for your target platform from the Oracle website or other reliable open-source Java distributions (such as OpenJDK). Ensure that the downloaded JRE version is compatible with the iTMSTransporter tool to avoid runtime problems caused by version incompatibility.

[0033] To ensure the desktop application runs correctly on different machines and is unaffected by the JRE already installed on the system, a pre-selected JRE is fully integrated into the desktop application's resource directory. The JRE's installation directory (containing all necessary files and subdirectories) can be directly copied to a specific location within the desktop application. Upon application startup, an integrity check is performed on the integrated JRE to ensure all necessary files are present and undamaged. This can be verified by checking the existence and size of critical files (such as the Java executable and core library files). If an incomplete or corrupted JRE is detected, the user can be prompted to reinstall the application, or an automatic repair mechanism (such as re-downloading and reinstalling the pre-packaged JRE) can be provided.

[0034] During development, functional testing was performed on the desktop application that pre-packaged the iTMSTransporter command-line tool and Java runtime environment. A simple test scenario was created, such as simulating the upload of an empty IPA file (only used to test whether the tool call and environment configuration were correct). The desktop application was then used to call the pre-packaged tool and environment to check whether the iTMSTransporter tool could start normally, and the tool's output information was observed.

[0035] Compatibility testing was conducted across different operating system versions and processor architecture combinations. For example, testing was performed on Windows 10 and Windows 11 x64 architectures, different versions of macOS (such as macOS Monterey, macOS Ventura, etc.), and common Linux distributions (such as Ubuntu, CentOS, etc.). The startup speed of the application, the stability of tool calls, and the existence of compatibility issues caused by environmental differences were examined under different environments.

[0036] Performance testing was conducted on desktop applications calling pre-packaged tools and environments. Measurements were taken from application startup to successful invocation of the iTMSTransporter tool and commencement of operations, as well as system resource consumption (such as CPU usage and memory usage) during execution. The goal was to ensure that application performance met real-world usage requirements and that pre-packaged tools and environments did not cause significant performance degradation.

[0037] S102 receives Apple login information entered by the user through a desktop application, generates an authentication token based on the Apple login information, and stores it persistently.

[0038] In this embodiment, a clean and simple Apple login interface is built using a Widget in the Flutter desktop application. When the user clicks the login button, the entered Apple ID and password are first validated. For example, the Apple ID is checked to see if it conforms to a common email format, and the password length is within the required range. If the input information does not meet the requirements, an error message is displayed below the corresponding input box, preventing the login process from continuing. Once the input information is validated, the desktop application initiates a login request to the Apple authentication server. This process is implemented by calling a pre-built network request module within the application, which is responsible for communicating with the Apple authentication server and transmitting the login information entered by the user.

[0039] Prepare the parameters required for the login request according to the requirements of Apple's authentication server. In addition to the Apple ID and password entered by the user, this may include other information such as the application's client ID and redirect URI. These parameters are used to identify the application and determine the callback address after successful authentication. Encapsulate the prepared parameters according to the format specified by Apple's authentication server, typically using an HTTP POST request.

[0040] Use a pre-built network request library (such as a Flutter-based HTTP library with secondary encapsulation to meet the network communication needs of desktop applications) to send a login request to the Apple authentication server. When sending the request, handle potential network errors, such as network connection failures or timeouts, and display corresponding error messages to the user.

[0041] Receive the response from Apple's authentication server and process it differently based on the response status code and content. If the response status code indicates successful login (usually 200), extract the authentication token (such as the access token and refresh token in OAuth 2.0) from the response content. The authentication token is the credential returned by the server after successful login, used for subsequent access to protected resources. If the response status code indicates login failure (such as 401 for unauthorized, 403 forbidden, etc.), parse the error message in the response content and display the corresponding error message to the user on the login screen of the desktop application, such as "Incorrect username or password, please re-enter".

[0042] Store authentication tokens in encrypted form in a local file. Choose a secure file storage location, such as the application's data directory, and set appropriate permissions to prevent unauthorized access by other users or programs. Alternatively, use a lightweight local database (such as SQLite) to store authentication tokens. Databases offer better data management and query capabilities, and can also enhance security by encrypting the database file or the stored tokens.

[0043] S103, based on a desktop application, responds to user drag-and-drop or file selection operations to obtain IPA files, automatically decompresses the IPA files and parses them to obtain the parsing results.

[0044] In this embodiment, a Widget is used to build an intuitive and easy-to-use file retrieval interface in the Flutter desktop application.

[0045] In Flutter desktop applications, an event listener mechanism is used to capture user drag-and-drop operations. When a user drags a file into the drag area, a drag-in event is triggered; when the file moves within the drag area, a drag-move event is triggered; and when the user releases the mouse, a drag-release event is triggered. In the drag-release event handler, it checks if the dragged file is an IPA file. This can be initially determined by obtaining the file extension (e.g., .ipa). If the file type does not meet the requirements, an error message is displayed on the interface, such as "Please upload a valid IPA file." If the file type verification passes, the complete path of the IPA file on the local system is obtained and passed to the subsequent file processing module.

[0046] When the user clicks the "Select File" button, the system-provided file selection interface is invoked, and a file selection dialog box pops up. In the dialog box, a file filter is set to display only IPA files, allowing the user to quickly find the desired file. After the user selects and confirms the IPA file in the dialog box, the complete path of that file is obtained and passed to the subsequent file processing module.

[0047] Considering cross-platform compatibility and ease of use, choose a decompression library or tool suitable for use in Flutter desktop applications. For example, you can use a system command-based decompression method (built-in decompression functionality or command-line versions of third-party decompression tools on Windows, and the unzip command on Mac and Linux), or integrate a cross-platform decompression library (such as relevant plugins that may exist in the Flutter ecosystem or native decompression libraries that are called through platform channels).

[0048] Depending on the selected decompression tool, the corresponding decompression command or interface for calling the decompression library is built in the desktop application. If system commands are used, different commands need to be built for different operating systems. For example, on Mac or Linux systems, a command like `unzip [IPA file path] -d [decompression target directory]` is built; on Windows systems, the corresponding command is built based on the selected decompression tool.

[0049] Create a temporary directory in the desktop application to store the extracted files. This directory should have a unique name to avoid conflicts with other files. You can use a timestamp or a random string to generate the directory name.

[0050] The decompression command or the API call of the decompression library is executed in a background thread. This avoids blocking the user interface and ensures application responsiveness. During the decompression process, progress indicators can be used to provide feedback to the user (although progress display is not the focus of this section, a simple indication that decompression is in progress can be provided).

[0051] After the decompression operation is complete, check if the decompression was successful. If decompression fails, display an error message on the interface, such as "IPA file decompression failed, please check file integrity"; if decompression is successful, obtain the list of decompressed files and directory structure to prepare for subsequent file parsing.

[0052] An IPA file is essentially a compressed archive. After decompression, it contains multiple files and folders. Some of these key files contain important application information, such as the Info.plist file which contains the application's Bundle ID, version number, and other information, and the files in the _CodeSignature folder which are related to the application's code signing. This example primarily parses these key files to obtain useful information.

[0053] Based on the directory structure after the IPA file is decompressed, locate the key file that needs to be parsed. For example, find the path to the Info.plist file by traversing the decompressed directory. File system operation functions can be used to perform directory traversal and file search.

[0054] Open the located key file and read its contents. For text files (such as Info.plist), the file contents can be read directly and then parsed; for binary files (such as certain code signing related files), it may be necessary to read and process them according to their specific format.

[0055] The Info.plist file typically stores information in XML format. This file can be parsed using an XML parsing library (such as an XML parsing plugin that may exist in the Flutter ecosystem or a native XML parsing library called through the platform channel). During parsing, key information such as BundleID, application version number, and application name is extracted.

[0056] Based on the specific format and specifications of code signing, these files are parsed to obtain relevant data such as certificate information and signing time.

[0057] The information parsed from various key files will be integrated to form a complete parsing result. The parsing result can be stored in a structured data format, such as using a Map or a custom data structure, for easy subsequent use and display.

[0058] S104. Dynamically generate command line instructions based on the parsing results. The parameters of the command line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API.

[0059] In this embodiment, the API endpoint used to obtain the associated Store ID is determined according to Apple's official documentation. This endpoint is typically a specific URL used to send a request to Apple's servers to obtain store information related to the application. Request parameters are constructed based on the API requirements, including certain identifying information about the application (such as the App ID).

[0060] Based on the usage specifications and requirements of the iTMSTransporter command-line tool, a basic command-line instruction template was determined. This template includes the basic commands and fixed parameters required to perform upload operations, while also reserving space for inserting dynamic parameters (BundleID, certificate information, associated store ID).

[0061] Replace the BundleID, certificate information, and associated store ID obtained from the Apple API in the verified parsing results with the corresponding reserved positions in the command template. After generating the final command line command, perform an integrity check on the command. Ensure that all required parameters are correctly inserted and that the command format conforms to the requirements of the iTMSTransporter tool. If any problems are found in the command, such as missing parameters or incorrect formatting, display an error message to the user on the desktop application interface, such as "The generated command line command contains an error. Please check the parsing results or API information," and allow the user to repeat the relevant operation or check for problems.

[0062] S105, based on command-line instructions, uses Flutter's process_run library to launch a child process to execute upload commands, captures the command-line output stream in real time, matches progress keywords using regular expressions, and converts them into a visual progress bar.

[0063] In this embodiment, in a desktop application developed based on Flutter, ensure that the `process_run` library has been correctly integrated. This library provides the functionality to start and manage child processes within the Flutter application. Pass command-line instructions in an appropriate format (such as a string) to the function in the `process_run` library used to start child processes. During the transmission process, ensure the completeness and accuracy of the instructions to avoid child process startup failures or execution exceptions due to incorrect formatting or missing parameters.

[0064] The `process_run` library's function to start a child process is called, passing the command-line instruction as an argument. This function creates a new child process at the operating system level and attempts to execute the upload command specified in the instruction (i.e., calling the iTMSTransporter command-line tool pre-packaged within the desktop application to upload the IPA package). When starting the child process, some optional parameters can be set, such as the working directory (specifying the initial directory where the child process executes, usually set to the directory containing the IPA file or a suitable temporary directory) and environment variables (setting necessary environment variables according to the requirements of the iTMSTransporter tool, such as Java runtime environment-related variables), to ensure that the child process can successfully execute the upload command in the correct environment.

[0065] The `process_run` library provides functionality for listening to the output streams of child processes. Immediately after starting a child process, an output stream listener is set to capture, in real time, the standard output stream (stdout) and standard error stream (stderr) information generated during the execution of upload commands. These output streams contain various status information, progress indicators, and potential error messages during the upload process, serving as crucial data for subsequent progress matching and error handling.

[0066] Since command-line output may be a continuous stream of bytes, an appropriate buffer is set up to store the captured output stream data to improve processing efficiency and accuracy. When the data in the buffer reaches a certain amount or a specific condition is met (such as receiving a newline character), the data in the buffer is processed. The byte stream data is converted into a string format for subsequent matching and analysis using regular expressions.

[0067] Based on common progress information output by the iTMSTransporter command-line tool when executing upload commands, a set of progress keywords is defined. These keywords include "Uploading" (indicating upload is in progress), "Progress" (indicating progress), "Completed" (indicating completion), and combinations of numbers and units related to the upload percentage (such as "50%). Through analysis and summarization of a large amount of actual output information, the most representative and accurate set of progress keywords is determined to ensure comprehensive coverage of various progress states during the upload process.

[0068] For each defined progress keyword, a corresponding regular expression pattern is constructed. Regular expressions are powerful text matching tools capable of precisely finding text within a string that matches a specific pattern. For example, for upload percentage information, the regular expression `r'\d+%'` can be constructed, which matches one or more numbers followed by a percent sign, thus accurately extracting the upload progress percentage. For other progress keywords, such as "Uploading", a simple regular expression `r'Uploading'` can be constructed for matching. Based on different progress keywords and matching requirements, multiple regular expression patterns are constructed, forming a complete set of regular expressions for comprehensively matching various progress information during the upload process.

[0069] When processing string data converted from the output stream, the pre-constructed set of regular expressions is used to match the strings sequentially. The string is traversed, checking for substrings that match the regular expression pattern. If a matching substring is found, the corresponding progress information type (such as upload percentage, progress status, etc.) is determined based on the matching regular expression pattern, and the relevant specific value or status description is extracted. For example, when the regular expression r'\d+%' matches the string "Uploading50%", "50" is extracted as the current upload percentage.

[0070] The progress information (such as the upload percentage) obtained from regular expression matching is converted into a data format suitable for display in a visual progress bar. Typically, the upload percentage is converted to a floating-point number between 0 and 1, representing the percentage of upload progress. In a Flutter desktop application, choose an appropriate visual component to implement the progress bar functionality. Flutter provides several progress bar components, such as LinearProgressIndicator and CircularProgressIndicator; choose the appropriate component type based on the application's design style and user needs. Create a progress bar component instance and set its initial state (e.g., initial progress of 0). Pass the converted progress data to the progress bar component to trigger its update operation. Flutter's reactive programming model allows the progress bar component to automatically re-render and display the latest upload progress when the progress data changes. Place the progress bar component in a suitable position on the application's main interface to ensure users can clearly see the upload progress. Additionally, you can add auxiliary information next to the progress bar, such as the current upload percentage and upload status description, to further enhance the user experience.

[0071] S106: Monitor the exit code of the child process and the success or error identifier in the output stream, generate an upload result report and trigger a system notification.

[0072] In this embodiment, in the operating system, when a child process finishes execution, it returns an exit code. This exit code is an integer value used to represent the execution status of the child process. Typically, an exit code of 0 indicates that the child process has successfully completed execution, while a non-zero value indicates that an error occurred during execution. Different non-zero values ​​may correspond to different types of errors. In Flutter-based desktop applications, after using the `process_run` library to launch a child process to execute an upload command, this library provides an interface function to obtain the child process's exit code.

[0073] While starting the child process to execute the upload command, a listener is set up to monitor the child process's execution status in real time. Specifically, when calling the `process_run` library function to start the child process, a callback function can be passed as an argument. This callback function will be automatically invoked when the child process finishes execution. Inside the callback function, the exit code of the child process is obtained by calling the library's provided interface function to retrieve the exit code. For example, when the child process finishes execution, the operating system will trigger the execution of the callback function, at which point the exit code is retrieved and analyzed within the callback function.

[0074] After obtaining the exit code of the child process, it is analyzed and processed in detail. If the exit code is 0, the upload command is considered to have executed successfully; if the exit code is a non-zero value, the error type needs to be further determined. A predefined error code mapping table can be used to associate common non-zero exit codes with specific error descriptions. For example, an exit code of 1 might indicate a file not found error, while an exit code of 2 might indicate insufficient permissions. Based on the obtained exit code, the corresponding error description is looked up in the error code mapping table, providing detailed error information for generating the subsequent upload result report.

[0075] In addition to determining the upload result through the exit code, it is also necessary to monitor the success and error identifiers in the command-line output stream. The success identifier is a specific string output by the iTMSTransporter command-line tool when the upload operation is successfully completed, such as "Upload Successful"; the error identifier is a specific string output when an error occurs during the upload process, such as "Error: [specific error information]". By conducting a detailed analysis of the iTMSTransporter tool's output information, a representative set of success and error identifiers can be determined.

[0076] During the execution of the upload command in the child process, the `process_run` library is used to capture the command-line output stream (including the standard output stream and standard error stream) in real time. After converting the captured output stream data into string format, a string matching algorithm (such as simple containment relationship judgment) is used to scan the output stream string to check for the existence of predefined success or error identifiers. To improve the accuracy and efficiency of matching, regular expressions can be used for matching. Corresponding regular expression patterns are constructed for different identifiers to perform precise matching of the output stream string.

[0077] When a success identifier is matched in the output stream, a successful upload message is recorded. When an error identifier is matched, the specific error information within the error identifier is extracted and recorded in detail. For example, if the error identifier "Error: Invalid certificate" is matched, an invalid certificate error message is recorded. This recorded information will be used to generate a subsequent upload result report, providing users with more detailed feedback on the upload process.

[0078] Based on the analysis results of the child process exit codes and the matching results of the output stream identifiers, a detailed upload result report is generated. The report should include: (1) Basic information of the upload task: including the name of the uploaded IPA file, the upload time, and other basic information to help users quickly understand the basic situation of this upload task. (2) Upload result status: clearly indicating whether the upload was successful or failed. If the upload is successful, a clear prompt of "upload successful" is displayed; if the upload fails, a prompt of "upload failed" is displayed. (3) Detailed error information (if the upload fails): if the upload fails, based on the exit code analysis and the matching results of the output stream identifiers, a detailed error description is provided, including the error type, specific error information, etc., to help users quickly locate and solve the problem. (4) Suggestions and solutions: for common error types, corresponding suggestions and solutions are provided in the report. For example, if the error is caused by an invalid certificate, it is recommended that the user check the validity and configuration of the certificate; if the error is caused by a network problem, it is recommended that the user check the network connection, etc.

[0079] After generating the upload result report, the system notification is triggered by calling the corresponding system notification interface based on the selected notification method and the constructed notification content. In Flutter applications, interaction with system notification functionality can be achieved by calling native code through Platform Channels. For example, on the Android platform (when the application runs on a Linux system using the Android desktop environment), Android's notification-related APIs are called through Platform Channels; on the iOS platform (when the application runs on a macOS system), the iOS Notification Center API is called. This method enables cross-platform system notification triggering, providing timely feedback of upload results to the user.

[0080] In some embodiments, step S101 above, which involves pre-packaging the iTMSTransporter command-line tool and Java runtime environment within the desktop application, specifically includes: By pre-installing the iTMSTransporter command-line tool and Java runtime environment compiled for each platform in the platform subdirectory of the Flutter project resources, pre-packaged resources are formed. Based on pre-packaged resources, the current operating system platform is detected when the desktop application starts, the matching platform resource package is located, the platform resource package is decompressed to a temporary working directory, and a sandboxed toolchain environment is created. For sandboxed toolchain environments, the temporary working directory is injected into the header of the system PATH variable by modifying the process environment variable, and JAVA_HOME is set to point to the decompressed JRE path, overriding the system default toolchain path.

[0081] In this embodiment, the source code of the iTMSTransporter command-line tool or pre-compiled versions for different operating systems are obtained from Apple's official channels. For the source code, it is compiled using the corresponding compilation tools for each platform (such as Visual Studio on Windows, Xcode on macOS, GCC on Linux, etc.) to generate an executable file that can run on the corresponding operating system. For different operating system versions and architectures (such as 32-bit and 64-bit Windows, different versions of macOS, common Linux distributions and architectures), compilation and testing are performed separately to ensure that the generated iTMSTransporter executable file can run stably on the target platform.

[0082] Obtain the JRE installer for your desired operating system from the Oracle website or other Java distribution channels. For each operating system platform, select a JRE version compatible with the iTMSTransporter tool. Unzip and organize the obtained JRE installer, removing unnecessary files and directories to reduce the package size. Organize the organized JRE file structure according to a standardized format for easier subsequent packaging and use.

[0083] In the Flutter project's resource directory, create corresponding subdirectories according to the operating system platform, such as resources / windows, resources / macos, resources / linux, etc. These subdirectories will be used to store the pre-compiled iTMSTransporter tool and JRE resources for the corresponding platform.

[0084] Place the compiled iTMSTransporter executable and the organized JRE files into the corresponding platform subdirectories. For easier management and decompression, the resources for each platform can be packaged into a compressed file (such as a ZIP file), for example, windows_resources.zip, macos_resources.zip, and linux_resources.zip, and these compressed files can be stored in the corresponding platform subdirectories.

[0085] When the desktop application launches, Flutter uses its Platform Channels mechanism to call native code to detect the current operating system platform. For Windows, system information can be obtained by calling the Windows API; for macOS, system functions provided by macOS can be used; and for Linux, platform information can be obtained by reading system files (such as / etc / os-release) or calling relevant commands (such as uname).

[0086] Based on information obtained from calling system APIs, the system can determine whether the current operating system platform is Windows, macOS, or Linux. Furthermore, it can obtain the operating system version and architecture information to more accurately locate the matching resource package.

[0087] Based on the detected operating system platform information, the corresponding platform subdirectory path is built into the Flutter project's resource directory. For example, if the current platform is detected as Windows, the build path will be resources / windows.

[0088] Locate the pre-packaged resource package compressed file (e.g., windows_resources.zip) in the constructed platform subdirectory path. If the resource package file is found, record its path for later decompression.

[0089] Create a unique subdirectory as your temporary working directory within your operating system's temporary file directory (e.g., %TEMP% on Windows, / tmp on macOS, / tmp on Linux). You can generate a unique directory name using timestamps, random strings, or other methods to avoid conflicts with other applications' temporary files. Check that the created temporary working directory has the correct read and write permissions to ensure that your applications can properly decompress and manipulate files within that directory. If permissions are insufficient, modify the directory permissions by calling system functions or commands.

[0090] Use Flutter's file manipulation features or the system's built-in decompression tools (such as the decompression command on Windows, and the unzip command on macOS and Linux) to decompress the located resource package compressed file. Place all decompressed files into a temporary working directory, maintaining the original file structure. After decompression, check if the expected iTMSTransporter executable file and JRE file are present in the temporary working directory. The decompression result can be verified by traversing the directory structure or checking for the existence of specific files. If decompression fails or files are missing, log the error message and prompt the user to try again or troubleshoot.

[0091] The purpose of a sandboxed toolchain environment is to isolate pre-packaged tools and runtime environments from the system's default toolchain, preventing mutual interference. By restricting decompressed resource files to a temporary working directory and modifying process environment variables, applications running the iTMSTransporter tool preferentially utilize resources and tools within the sandboxed environment. After creating the sandboxed environment, you can verify successful isolation by running simple test commands or programs. For example, running a simple Java program that depends on a JRE in the temporary working directory checks whether it can correctly use the decompressed JRE without being affected by the system's default JRE.

[0092] Use Flutter's provided interfaces or call system functions to obtain the current process's PATH environment variable value. The PATH variable specifies the list of directories the system searches when looking for executable files. Adding the path to the temporary working directory to the beginning of the PATH variable value ensures that the system prioritizes searching directories in the sandboxed toolchain environment when looking for executable files. For example, if the current PATH variable value is / usr / local / bin: / usr / bin: / bin and the temporary working directory is / tmp / app_temp_work, then the modified PATH variable value is / tmp / app_temp_work: / usr / local / bin: / usr / bin: / bin.

[0093] Set the modified PATH variable value back to the current process's environment variables so that subsequent commands and programs can use the new PATH variable to search for executable files.

[0094] In the extracted temporary working directory, locate the JRE installation directory. Typically, the JRE directory contains subdirectories such as bin and lib. You can determine the JRE root directory by traversing the directory structure or searching for specific flag files. Set the value of the JAVA_HOME environment variable to the extracted JRE path. For example, if the extracted JRE path is / tmp / app_temp_work / jre, then set JAVA_HOME to / tmp / app_temp_work / jre. Run a simple Java command (such as java -version) to check if the set JAVA_HOME environment variable can be used correctly to call the extracted JRE. If the command executes correctly and displays the JRE version information, the environment variable has been set successfully.

[0095] In this embodiment, the iTMSTransporter command-line tool and Java runtime environment were successfully pre-packaged in a Flutter-based desktop application, enabling convenient cross-platform use and improving the efficiency and stability of developers uploading IPA packages.

[0096] In some embodiments, step S102 above, which involves receiving Apple login information input by the user through a desktop application, generating an authentication token based on the Apple login information, and persistently storing it, specifically includes: The login credentials are obtained by receiving the user's Apple ID and App-specific password through the desktop application's interactive interface. Send an HTTPS request to the Apple authentication server and trigger the server to generate an authentication token by including login credentials in the request body; Based on the authentication token, the AES-GCM encryption algorithm is used in conjunction with the device hardware fingerprint to generate a key, and the original token is encapsulated into a ciphertext data block. For encrypted data blocks, the Flutter platform channel mechanism is invoked to forward them to the operating system's native keystore, and secure storage is performed through dedicated interfaces of multiple platforms.

[0097] In this embodiment, a dedicated login interface is designed in the desktop application, which includes prompts and input fields. The prompts inform the user that they need to enter their Apple ID and App-specific password, for example, displaying "Please enter your Apple ID" and "Please enter your App-specific password" above the input fields. In the desktop application's backend code, input listeners are set up for the Apple ID input field and the App-specific password input field, respectively. When the user enters content in the input fields, the listeners capture the characters entered by the user in real time and store them in corresponding variables.

[0098] After the user clicks the "Sign In" button, the system validates the entered Apple ID and App Password. For the Apple ID, it checks if it conforms to Apple's official format requirements, such as whether it contains a specific domain suffix. For the App Password, it checks if its length meets the requirements (usually 16 characters). If the input format is incorrect, the system displays the corresponding error message, such as "Apple ID format is incorrect, please re-enter" or "App Password length does not meet the requirements, please re-enter," and prevents further login attempts.

[0099] If the input format validation passes, the user's Apple ID and App-specific password are combined into a login credential object. This object can be a custom data structure containing two attributes: Apple ID and App-specific password, which will be used when sending subsequent requests to Apple's authentication server.

[0100] Obtain the HTTPS request address used to generate the authentication token. This address is typically a specific interface provided by Apple's authentication server, used to receive the user's login credentials and return the authentication token. When constructing the HTTPS request, set appropriate request header information. The request header should include necessary fields, such as setting Content-Type to application / json, indicating that the data in the request body is in JSON format; you can also set some custom request header fields to identify desktop application version information or device information, etc.

[0101] Use a network request library supported by your desktop application (such as Flutter's http package or calling the operating system's native network request interface) to send a pre-built HTTPS request to the Apple Certification Server. When sending the request, you can set an appropriate timeout to avoid prolonged periods of unresponsiveness due to network issues.

[0102] Wait for Apple's authentication server to process the request and return a response. The response may contain different status codes and response body data. Common status codes include 200 (indicating successful request), 400 (indicating incorrect request parameters), and 401 (indicating authentication failure).

[0103] If the server returns a 200 status code, the request was successful, and the authentication token is parsed from the response body. The response body is usually also in JSON format, containing the authentication token and other possible related information, such as the token's expiration date. A JSON parsing library is used to parse the response body data into an object, extract the authentication token, and store it in a variable. If the server returns a status code other than 200, the corresponding error message is displayed on the interface, such as "Login failed. Please check your Apple ID and App Password for correctness" or "Server busy. Please try again later."

[0104] Depending on the operating system platform, the corresponding system interface is called to obtain the device's hardware fingerprint information. For Windows platforms, the Windows API can be used to obtain the device's unique identifier, such as the hard drive serial number or motherboard serial number; for macOS platforms, system functions provided by macOS can be used to obtain the device's UUID or other hardware-related information; for Linux platforms, device hardware information can be obtained by reading system files (such as / etc / machine-id) or by calling relevant commands (such as dmidecode).

[0105] The acquired device hardware information is integrated and processed to generate a unique device hardware fingerprint. A hash algorithm (such as SHA-256) can be used to hash the hardware information, and the result is used as the device hardware fingerprint. This ensures that the hardware fingerprints generated for different devices are unique and provides a certain level of security.

[0106] The generated device hardware fingerprint is used as part of the encryption key, combined with a randomly generated initialization vector (IV), and the final AES-GCM encryption key is generated using a key derivation function (such as PBKDF2). The length of the initialization vector should conform to the requirements of the AES-GCM algorithm, typically 12 bytes.

[0107] The authentication token is encrypted using the generated encryption key and initialization vector with AES-GCM. The AES-GCM algorithm not only encrypts the data but also generates an authentication tag to verify the integrity and authenticity of the data. The encrypted authentication token becomes a ciphertext data block, and a corresponding authentication tag is generated simultaneously.

[0108] Define a platform channel in your Flutter application to communicate with the operating system's native code. The platform channel can be a MethodChannel, which uses defined method names to enable method calls and data transfer between the desktop application and the native code.

[0109] In the Dart code of your desktop application, implement platform channel-related methods to send encrypted data blocks and authentication tags to the operating system's native code. For example, define a method named `storeCredential` that takes encrypted data blocks and authentication tags as parameters and passes them to the native code via the platform channel.

[0110] On the Windows platform, secure storage of encrypted data blocks is achieved using the Windows Cryptography API: Next Generation (CNG) or Data Protection API (DPAPI). After receiving the encrypted data block and authentication tag through the platform channel, the corresponding CNG or DPAPI function is called to store the data in the operating system's secure storage area, such as the Windows Credential Manager.

[0111] On macOS, the Keychain Services API is used to store encrypted data blocks. Keychain is a secure keystore provided by macOS for storing sensitive information such as passwords and keys. After obtaining the encrypted data block and authentication tag through the platform channel, the relevant functions in the Keychain Services API are called to add the data to the Keychain.

[0112] On Linux platforms, key management tools such as GNOME Keyring or KWallet can be used to securely store encrypted data blocks. Depending on the user's desktop environment, the appropriate key management tool is selected, and the encrypted data blocks and authentication tags are passed to the native code via the platform channel. The key management tool then calls its provided interface to store the data in a keystore.

[0113] After completing the storage operation of the encrypted data block, the operating system's native code returns the storage result (such as information on whether the storage was successful or failed) to the Dart code of the desktop application through the platform channel.

[0114] After receiving the storage result returned by the native code, the desktop application processes it accordingly. If the storage is successful, a message "Login information has been successfully saved" will be displayed on the interface; if the storage fails, a corresponding error message will be displayed, such as "Failed to save login information. Please check system permissions or try again."

[0115] In this embodiment, the user's Apple login information is securely received in the desktop application, an authentication token is generated and stored in an encrypted manner, thus ensuring the security and privacy of the user information.

[0116] In some embodiments, step S103 above, which involves obtaining an IPA file based on a desktop application in response to a user's drag-and-drop or file selection operation, automatically decompressing the IPA file, and performing file parsing, specifically includes: Based on the desktop application, capture the IPA file that the user drags to the application window, or obtain the path of the IPA file in response to the file selection dialog box operation, and establish a file access handle; Based on file access handles, zero-copy memory mapping technology is used to load IPA files into a buffer, and the internal files are extracted item by item by the ZIP streaming decompression engine. During the decompression process, file path characteristics are scanned in real time. When the Info.plist file or the embedded.mobileprovision file is detected, the traversal is immediately interrupted and the file content is transferred to the parsing queue. For the files in the parsing queue, the XML / JSON converter is called to extract the BundleID from the Info.plist file, and the ASN.1 decoder is applied to the embedded.mobileprovision file to obtain the certificate fingerprint information, forming a structured metadata set.

[0117] In this embodiment, after obtaining a valid IPA file path through drag-and-drop or a file selection dialog box, the file is opened using a file opening interface provided by the operating system (such as the CreateFile function in Windows, and the open function in macOS and Linux). When calling the interface, the file access mode needs to be specified, typically selecting readable mode to facilitate subsequent file reading operations.

[0118] When a file is successfully opened, the operating system returns a file access handle. This handle is a unique identifier used by the operating system to identify and manage open files. Desktop applications need to save this handle for subsequent operations such as reading and closing the file.

[0119] Zero-copy memory mapping is a technique that directly maps files to the virtual memory address space of a process. In this way, processes can access files as if they were accessing memory, avoiding the multiple copies of data between kernel space and user space that are present in traditional file reading methods, thus improving file access efficiency.

[0120] The opened IPA file is mapped to the process's virtual memory address space using memory mapping interfaces provided by the operating system (such as the CreateFileMapping and MapViewOfFile functions in Windows, and the mmap function in macOS and Linux). When calling the interface, parameters such as the file size and access permissions need to be specified. After successful memory mapping, the operating system returns the mapped memory address. Desktop applications can then directly access the contents of the IPA file through this address without performing additional file reading operations.

[0121] An IPA file is essentially a ZIP archive. Therefore, a general ZIP decompression engine can be used to decompress IPA files. Before starting decompression, it's necessary to verify that the file is a valid ZIP format, which can be done by checking the file header information (such as the magic number "PK" of the ZIP file). Choose a suitable ZIP streaming decompression engine (such as the open-source minizip) and initialize it according to the engine's documentation. During initialization, you need to pass in information such as the mapped IPA file's memory address and file size so that the engine can correctly read and decompress the file. Use the ZIP streaming decompression engine to read the compressed items in the IPA file item by item. For each compressed item, the engine provides relevant file information, such as filename, file size, and compression method. Based on this information, the file content can be extracted to a specified memory buffer or temporary file. During the extraction process, a streaming processing method can be used, that is, reading and writing the file content block by block, avoiding loading a large file into memory at once and reducing memory usage.

[0122] In an IPA file, the Info.plist and embedded.mobileprovision files are two key files containing important metadata information about the application. The Info.plist file is typically located in the root directory of the IPA file or a specific subdirectory (such as Payload / [AppName].app / ), and its filename is always "Info.plist"; the embedded.mobileprovision file is typically located in the Payload / [AppName].app / directory, and its filename is always "embedded.mobileprovision". When using a ZIP streaming decompression engine to extract files item by item, the path of each file is scanned in real time. The path of the current file is compared with the predefined key file path characteristics to determine whether it is a key file.

[0123] Upon detecting the Info.plist or embedded.mobileprovision file, the ZIP streaming decompression engine's traversal process is immediately interrupted. This is because these two files contain crucial information needed for subsequent parsing, eliminating the need to decompress other files. The contents of the detected critical files are read into a memory buffer, and relevant information about the buffer or file (such as file type, memory address, etc.) is added to the parsing queue. The parsing queue stores critical files to be parsed, and subsequent files are parsed according to the order in the queue.

[0124] The Info.plist file is typically an XML file (and in some cases, a JSON file). Use an XML / JSON converter provided by a desktop application development framework or an open-source one (such as libxml2, jsoncpp, etc.) to convert the contents of the Info.plist file into a data structure that the program can process, such as a tree structure or a dictionary structure.

[0125] In the transformed data structure, according to the specifications in the Info.plist file, locate the node or key-value pair containing the BundleID. The BundleID is typically located in... <key> CFBundleIdentifier< / key> under the node <string>Within the tag. After extracting the BundleID, store it in a specific variable or data structure in memory.

[0126] The embedded.mobileprovision file is a binary file whose format conforms to the ASN.1 (Abstract Syntax Notation One) specification. It is decoded using an open-source ASN.1 decoder (such as asn1c). The decoder converts the binary file into an ASN.1 data structure that the program can understand.

[0127] In the decoded ASN.1 data structure, the node containing the certificate fingerprint information is located according to the specifications of the embedded.mobileprovision file. The certificate fingerprint information is typically located in a specific ASN.1 module or field. After extracting the certificate fingerprint information, it is stored in a specific variable or data structure in memory.

[0128] The extracted metadata, such as BundleID and certificate fingerprint information, are integrated to form a structured metadata set.

[0129] In some embodiments, in step S104 above, the step of dynamically generating command-line instructions based on the parsing results, wherein the parameters of the command-line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API, specifically including: Based on the parsing results, the BundleID and certificate fingerprint information of the IPA packet are obtained, and combined with the authentication token, a set of basic parameters is formed. For the BundleID, a GraphQL query is initiated by calling the Apple Developer API. By attaching an authentication token to the request header, the associated App Store ID is extracted from the server response. Based on the pre-packaged iTMSTransporter command-line tool within the desktop application, obtain adaptive iTMSTransporter command templates and automatically convert path separators according to the current operating system. It integrates a set of basic parameters, App Store ID, and iTMSTransporter command templates, and uses a string replacement engine to replace placeholders with actual parameter values. At the same time, it escapes special characters and finally outputs executable command-line instructions.

[0130] In this embodiment, an HTTP request header object is created, and the authentication token is appended to the request header. A constructed HTTP request is sent to the Apple Developer API's GraphQL endpoint using a desktop application-supported network request library (such as via the operating system's native network interface or a third-party library). An appropriate request timeout is set to avoid prolonged unresponsiveness due to network issues. The server is then waited for a response, typically in JSON format. The response data is parsed, and the response status code is checked. If the status code is 200, the request was successful, and the value of the appStoreId field is extracted from the response body. If the status code is not 200, appropriate error handling is performed based on the status code, such as displaying an error message on the application interface to inform the user of the query failure and possible reasons.

[0131] In the desktop application, a predefined iTMSTransporter command template is provided. This template contains placeholders for later replacement of actual parameter values. Since different operating systems use different path separators (e.g., \ for Windows, / for macOS and Linux), the path separator in the command template is automatically converted according to the current operating system after the template is retrieved. This can be achieved by determining the operating system type (e.g., obtaining the operating system name using a system API) and then using a string replacement method to replace the path separator with the one applicable to the current operating system.

[0132] Create a parameter substitution map dictionary, storing the parameters from the base parameter set as key-value pairs. Iterate through each character in the command template; when a placeholder is encountered, look up the corresponding actual parameter value in the parameter substitution map dictionary and replace it in the command template. This can be implemented using the string's `replace` method or a more complex string replacement algorithm.

[0133] In command-line instructions, certain characters (such as spaces, quotation marks, and backslashes) have special meanings and need to be escaped to ensure correct execution. For example, if a parameter value contains spaces, it needs to be enclosed in quotation marks; if it contains quotation marks, they need to be escaped. The process iterates through the replaced command-line instruction string, escaping any special characters identified. This can be achieved using regular expressions or specific string manipulation functions.

[0134] The command-line instruction string, after parameter substitution and special character escaping, can be displayed on the desktop application interface for user viewing and confirmation; alternatively, it can be executed directly in the background by calling the operating system's command-line execution interface (such as the system function in Windows, and the exec family of functions in macOS and Linux).

[0135] In some embodiments, step S105 above, which involves starting a subprocess to execute the upload command based on command-line instructions using Flutter's process_run library, capturing the command-line output stream in real time, matching progress keywords using regular expressions, and converting the result into a visual progress bar, specifically includes: A child process executor is created using Flutter's process_run library, the execution environment is configured based on command-line instructions, and a dual-channel capture pipeline for standard output and error stream is established. For dual-channel capture pipelines, a real-time data callback listener is registered to continuously acquire byte data blocks of command line output through non-blocking stream reading technology and convert them into a UTF-8 encoded text line sequence; The text line sequence is pattern matched using a pre-defined set of regular expression rules. When text containing progress percentages, stage identifiers, or warning keywords is detected, structured progress events are extracted. Based on structured progress events, discrete events are converted into continuous progress values ​​through a weight allocation algorithm, driving the Flutter animation engine to update the progress bar component on the interface, while simultaneously outputting the original text after coloring in the log panel.

[0136] In this embodiment, add the `process_run` library dependency to the `pubspec.yaml` file of the Flutter project. Run the `flutter pub get` command to download and install the library, ensuring it can be used correctly in the project. Import the `process_run` library into the corresponding business logic code of the Flutter application. Use the Shell class provided by the library to create a child process executor instance.

[0137] Configure the execution environment of the subprocess according to the requirements of the upload command. This may include setting the working directory, environment variables, etc. For example, if the upload command needs to be executed in a specific project directory, you can use the `shell.setWorkingDirectory('project directory path')` method to set the working directory. If you need to pass specific environment variables, you can use the `shell.env` property to set them.

[0138] The `process_run` library provides the ability to capture the standard output (stdout) and standard error (stderr) streams of a child process. When starting a child process, a dual-channel capture pipeline can be established by configuring relevant parameters. For example, using a variant of the `shell.run` method (such as `shell.runExecutableArguments` with appropriate stream processing parameters) ensures that both stdout and stderr output can be captured simultaneously.

[0139] For the established dual-channel capture pipeline, register real-time data callback listeners for stdout and stderr respectively. When the child process outputs data, these listeners will be triggered to capture the output data in a non-blocking manner. For example, in the shell.runExecutableArguments method, the onProcessOutput and onProcessError callback functions can be set to handle the output of stdout and stderr respectively.

[0140] The callback listener uses non-blocking stream reading technology to continuously retrieve byte data blocks from the child process's output stream. Within the callback function, the received data is presented as a byte array (List<String>). <int>The data is presented in the form of a stream. Dart's Stream-related APIs, such as the Stream.listen method, are used to read data blocks in real time, avoiding blocking the main thread and ensuring the smoothness of the application.

[0141] After obtaining the byte data block, convert it to UTF-8 encoded text. Use the utf8.decode method to convert the byte array into a string. Then, split the string into a sequence of text lines according to the newline character (such as \n).

[0142] Based on common formats in upload command output, a pre-defined set of regular expression rules is used to match progress percentages, stage identifiers, and warning keywords. The transformed text line sequence is traversed, and each line is matched against the pre-defined set of regular expression rules. Dart's RegExp class can be used to implement regular expression matching. When a regular expression match is successful, relevant information is extracted from the match result and encapsulated as a structured progress event. For example, if a progress percentage is matched, the percentage value is extracted; if a stage identifier is matched, the stage name is extracted; if a warning keyword is matched, the warning type and details are extracted. This information is then encapsulated into an object or dictionary as a structured progress event.

[0143] Define a weighted allocation algorithm to convert structured progress events into continuous progress values ​​based on their different types and content. For example, assign certain progress ranges to different stages, such as 0%-70% for the upload stage, 70%-90% for the verification stage, and 90%-100% for the completion stage. Calculate continuous progress values ​​based on the current stage and progress percentage (if any).

[0144] The calculated continuous progress value is passed to Flutter's progress bar component (such as LinearProgressIndicator or CircularProgressIndicator). Flutter's state management mechanism (such as setState or a more advanced state management library) is used to update the progress bar display when the progress value changes.

[0145] Add a log panel (such as a collection of Text components wrapped in a ListView) to display the raw output text of the child process. Color the text according to its type (e.g., normal output, warning, error) to distinguish between different types of information. For example, warnings are displayed in yellow, and error messages in red. The text coloring effect can be implemented using Flutter's RichText and TextSpan components.

[0146] In this embodiment, the Flutter application can successfully launch a child process to execute the upload command, capture and process the command line output in real time, and convert the progress information into a visual progress bar to provide users with clear and intuitive upload progress feedback.

[0147] In some embodiments, step S106 above, which involves generating an upload result report and triggering a system notification based on the exit code of the monitoring subprocess and the success or error identifier in the output stream, specifically includes: By monitoring the exit code channel and output stream channel of subprocesses in parallel, a collaborative analysis mechanism for exit status and text output is established. For the output stream channel, a multi-level regular expression matching engine is applied to scan a predefined set of success / error patterns. At the same time, the status level is divided by combining the numerical range of the exit code channel to generate a preliminary result identifier. By integrating preliminary result identifiers and raw output content, the report template engine integrates key event timestamps, error solution links, and performance metrics into a structured report, and attaches a compressed archive of the original logs. Based on the structured report, the system calls the operating system's native notification interface to send interactive reminders, and automatically triggers sound or vibration feedback according to the error level.

[0148] In this embodiment, in the Flutter application, after starting a child process that executes the upload command using the `process_run` library, two independent monitoring threads or asynchronous tasks are started simultaneously to monitor the child process's exit code channel and output stream channel, respectively. For example, two Futures can be created near the code that starts the child process, or Isolate can be used to achieve parallel monitoring.

[0149] In exit code monitoring tasks, methods provided by the `process_run` library (such as `shell.shouldExit` and similar functions, depending on the library's actual API) are used to listen for child process exit events. When a child process exits, its exit code is retrieved. Different operating systems and command-line tools have specific conventions for exit codes; typically, 0 indicates success, and non-zero values ​​indicate failure. Different non-zero values ​​may correspond to different types of errors.

[0150] The output stream monitoring task continuously reads the standard output (stdout) and standard error (stderr) streams of the child process. It employs a non-blocking stream reading method, acquiring data from the output stream in real time by setting callback functions or using the Stream's listening mechanism. The acquired byte data is converted into strings, split line by line, and stored for subsequent analysis.

[0151] Create a shared data structure (such as an object containing exit codes and a list of output lines) to pass information between the two monitoring tasks. This shared data structure is updated when the exit code monitoring task receives an exit code or the output stream monitoring task receives a new output line. This allows information from the two channels to be correlated, providing a foundation for subsequent collaborative analysis.

[0152] For the text in the output stream, a set of multi-level regular expression patterns is predefined to match success and error indicators. These patterns can be divided into different levels. For example, the first-level pattern is used to quickly identify obvious success or error keywords, such as "Upload successful" or "Error:". Based on the matching of the first-level pattern, the second-level pattern is configured to further extract more detailed error information, such as error code and error description. For example, for the output "Error:

[404] File not found", the first-level pattern matches "Error:", and the second-level pattern can extract the error code "404" and the error description "File not found".

[0153] Based on the exit code of the child process and in combination with common exit code conventions, different status levels are divided. For example: (1) Success level: Exit code 0 indicates that the child process has executed successfully. (2) Warning level: Exit code within a certain range (e.g., 1-10) indicates that some recoverable problems or warnings have occurred during execution. (3) Error level: Exit code within another range (e.g., greater than 10) indicates that a serious error has occurred during execution.

[0154] The system combines the regular expression matching results with the exit code status level to generate a preliminary result identifier. For example, if the exit code is 0 and a success pattern is matched in the output stream, the preliminary result identifier is "Success"; if the exit code is within the warning level range and there is warning-related information in the output stream, the preliminary result identifier is "Warning"; if the exit code is within the error level range or a serious error pattern is matched in the output stream, the preliminary result identifier is "Error".

[0155] In addition to the preliminary result identifier and the original output content, the following key information also needs to be collected: (1) Key event timestamps: Record the time of subprocess startup, key output events (such as start uploading, upload completion, error occurrence, etc.), and subprocess exit. The current time can be obtained and recorded using Dart's DateTime class. (2) Error solution links: Based on the error type in the preliminary result identifier, search for the corresponding solution link from the predefined error solution database. For example, if the error type is "file not found", search for relevant document links to solve the file not found problem. (3) Performance metrics: If the output stream contains performance-related information (such as upload speed, time consumption, etc.), extract and record these metrics.

[0156] Define a predefined report template containing placeholders for key information. For example, the report template could be an HTML string containing something like... Upload result: {{result}} , Start time: {{startTime}} Placeholders, etc.

[0157] Use string replacement or a more advanced template engine (such as Dart's mustache template library) to replace the collected key information with the corresponding placeholders in the report template to generate structured report content.

[0158] The raw output (i.e., the stdout and stderr output of the child process) is compressed to reduce storage space. Dart's archive library can be used to package the output into a ZIP compressed file. The compressed file is then added as an attachment to a structured report, allowing users to easily view detailed raw log information.

[0159] Interactive notifications are sent by calling the corresponding native notification API based on different operating systems (such as Android, iOS, macOS, Windows, etc.). In Flutter, plugins (such as the flutter_local_notifications plugin) can be used to achieve cross-platform notification sending functionality. Basic notification information is configured, such as title, content, and icon. The title can be set based on the initial result, such as "Upload Successful Notification" or "Upload Error Notification"; the content can include a summary of key information from a structured report.

[0160] When sending a notification, different feedback effects are automatically triggered based on the status level in the preliminary result identifier. For example: (1) Success status: Play a gentle prompt tone to indicate that the task has been successfully completed. (2) Warning status: Play a medium prompt tone and trigger a slight vibration to remind the user to pay attention to possible problems. (3) Error status: Play a rapid alarm tone and trigger a strong vibration to attract the user's attention.

[0161] In this embodiment, the Flutter application can accurately monitor the execution status of child processes, generate detailed upload result reports, and provide timely and effective feedback on task execution to users through system notifications, thereby improving the user experience.

[0162] Reference Figure 2 An embodiment of the present invention provides a cross-platform IPA package upload system 2 based on Flutter, wherein the system 2 specifically includes: The first upload module 201 is used to develop desktop applications using the Flutter framework and pre-package the iTMSTransporter command-line tool and Java runtime environment within the desktop application; The second upload module 202 is used to receive Apple login information entered by the user through a desktop application, generate an authentication token based on the Apple login information, and persistently store it. The third upload module 203 is used to retrieve IPA files based on desktop applications by responding to user drag-and-drop or file selection operations, automatically decompressing the IPA file and parsing the file to obtain the parsing results; The fourth upload module 204 is used to dynamically generate command line instructions based on the parsing results. The parameters of the command line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API. The fifth upload module 205 is used to execute upload commands by starting a child process through Flutter's process_run library based on command line instructions, capture the command line output stream in real time, match progress keywords using regular expressions and convert them into a visual progress bar; The sixth upload module 206 is used to monitor the exit code of the subprocess and the success or error identifier in the output stream, generate an upload result report and trigger a system notification.

[0163] It is understandable that, such as Figure 1 The content of the cross-platform IPA package upload method embodiment based on Flutter shown is applicable to the cross-platform IPA package upload system embodiment based on Flutter. The specific functions implemented in the cross-platform IPA package upload system embodiment based on Flutter are the same as those shown below. Figure 1 The cross-platform IPA package upload method based on Flutter shown in the example is the same, and the beneficial effects achieved are the same as those described above. Figure 1 The beneficial effects achieved by the cross-platform IPA package upload method embodiment based on Flutter shown are also the same.

[0164] It should be noted that the information interaction and execution process between the above systems are based on the same concept as the method embodiments of the present invention. For details on their specific functions and technical effects, please refer to the method embodiments section, which will not be repeated here.

[0165] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the system can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0166] Reference Figure 3 The present invention also provides a computer device 3, including: a memory 302 and a processor 301, and a computer program 303 stored on the memory 302. When the computer program 303 is executed on the processor 301, it implements the cross-platform IPA package upload method based on Flutter as described in any of the above methods.

[0167] The computer device 3 may be a desktop computer, laptop, handheld computer, or cloud server, etc. The computer device 3 may include, but is not limited to, a processor 301 and a memory 302. Those skilled in the art will understand that... Figure 3 The computer device 3 is merely an example and does not constitute a limitation on the computer device 3. It may include more or fewer components than shown in the figure, or combine certain components, or different components, such as input / output devices, network access devices, etc.

[0168] The processor 301 may be a Central Processing Unit (CPU), or it may be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or any conventional processor.

[0169] In some embodiments, the memory 302 may be an internal storage unit of the computer device 3, such as a hard disk or memory of the computer device 3. In other embodiments, the memory 302 may be an external storage device of the computer device 3, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., equipped on the computer device 3. Furthermore, the memory 302 may include both internal and external storage units of the computer device 3. The memory 302 is used to store the operating system, applications, boot loader, data, and other programs, such as the program code of the computer program. The memory 302 can also be used to temporarily store data that has been output or will be output.

[0170] This invention also provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the Flutter-based cross-platform IPA package upload method as described in any of the above methods.

[0171] In this embodiment, if the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include at least: any entity or device capable of carrying computer program code to a photographing device / terminal device, a recording medium, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium. Examples include USB flash drives, portable hard drives, magnetic disks, or optical disks. In some jurisdictions, according to legislation and patent practice, computer-readable media cannot be electrical carrier signals or telecommunication signals.

[0172] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0173] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0174] In the embodiments disclosed in this application, it should be understood that the disclosed devices / terminal equipment and methods can be implemented in other ways. For example, the device / terminal equipment embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual coupling or direct coupling or communication connection may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0175] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.< / int> < / string>

Claims

1. A cross-platform IPA package upload method based on Flutter, characterized in that, The method specifically includes: Develop desktop applications using the Flutter framework, and pre-package the iTMSTransporter command-line tool and Java runtime environment within the desktop application; Receive Apple login information entered by the user through a desktop application, generate an authentication token based on the Apple login information, and store it persistently. Based on a desktop application, it responds to user drag-and-drop or file selection operations to obtain IPA files, automatically decompresses the IPA files and parses the files to obtain the parsing results; Command-line instructions are dynamically generated based on the parsing results. The parameters of the command-line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API. Based on command-line instructions, a child process is launched using Flutter's process_run library to execute the upload command, and the command-line output stream is captured in real time. Progress keywords are matched using regular expressions and converted into a visual progress bar. Monitor the exit code of the child process and the success or error identifier in the output stream, generate an upload result report and trigger a system notification.

2. The method according to claim 1, characterized in that, The pre-packaged iTMSTransporter command-line tool and Java runtime environment within the desktop application specifically include: By pre-installing the iTMSTransporter command-line tool and Java runtime environment compiled for each platform in the platform subdirectory of the Flutter project resources, pre-packaged resources are formed. Based on pre-packaged resources, the current operating system platform is detected when the desktop application starts, the matching platform resource package is located, the platform resource package is decompressed to a temporary working directory, and a sandboxed toolchain environment is created. For sandboxed toolchain environments, the temporary working directory is injected into the header of the system PATH variable by modifying the process environment variable, and JAVA_HOME is set to point to the decompressed JRE path, overriding the system default toolchain path.

3. The method according to claim 1, characterized in that, The process of receiving Apple login information input by the user through a desktop application, generating an authentication token based on the Apple login information, and persistently storing it specifically includes: The login credentials are obtained by receiving the user's Apple ID and App-specific password through the desktop application's interactive interface. Send an HTTPS request to the Apple authentication server and trigger the server to generate an authentication token by including login credentials in the request body; Based on the authentication token, the AES-GCM encryption algorithm is used in conjunction with the device hardware fingerprint to generate a key, and the original token is encapsulated into a ciphertext data block. For encrypted data blocks, the Flutter platform channel mechanism is invoked to forward them to the operating system's native keystore, and secure storage is performed through dedicated interfaces of multiple platforms.

4. The method according to claim 1, characterized in that, The desktop application-based process, which responds to user drag-and-drop or file selection operations to obtain IPA files, automatically decompresses the IPA file, and performs file parsing, specifically includes: Based on the desktop application, capture the IPA file that the user drags to the application window, or obtain the path of the IPA file in response to the file selection dialog box operation, and establish a file access handle; Based on file access handles, zero-copy memory mapping technology is used to load IPA files into a buffer, and the internal files are extracted item by item by the ZIP streaming decompression engine. During the decompression process, file path characteristics are scanned in real time. When the Info.plist file or the embedded.mobileprovision file is detected, the traversal is immediately interrupted and the file content is transferred to the parsing queue. For the files in the parsing queue, the XML / JSON converter is called to extract the BundleID from the Info.plist file, and the ASN.1 decoder is applied to the embedded.mobileprovision file to obtain the certificate fingerprint information, forming a structured metadata set.

5. The method according to claim 4, characterized in that, The command-line instructions are dynamically generated based on the parsing results. The parameters of the command-line instructions include BundleID, certificate information, and the associated store ID obtained from the Apple API, specifically including: Based on the parsing results, the BundleID and certificate fingerprint information of the IPA packet are obtained, and combined with the authentication token, a set of basic parameters is formed. For the BundleID, a GraphQL query is initiated by calling the Apple Developer API. By attaching an authentication token to the request header, the associated App Store ID is extracted from the server response. Based on the pre-packaged iTMSTransporter command-line tool within the desktop application, obtain adaptive iTMSTransporter command templates and automatically convert path separators according to the current operating system. It integrates a set of basic parameters, App Store ID, and iTMSTransporter command templates, and uses a string replacement engine to replace placeholders with actual parameter values. At the same time, it escapes special characters and finally outputs executable command-line instructions.

6. The method according to claim 1, characterized in that, The process, based on command-line instructions, uses Flutter's `process_run` library to launch a child process to execute the upload command, captures the command-line output stream in real time, matches progress keywords using regular expressions, and converts them into a visual progress bar. Specifically, this includes: A child process executor is created using Flutter's process_run library, the execution environment is configured based on command-line instructions, and a dual-channel capture pipeline for standard output and error stream is established. For dual-channel capture pipelines, a real-time data callback listener is registered to continuously acquire byte data blocks of command line output through non-blocking stream reading technology and convert them into a UTF-8 encoded text line sequence; The text line sequence is pattern matched using a pre-defined set of regular expression rules. When text containing progress percentages, stage identifiers, or warning keywords is detected, structured progress events are extracted. Based on structured progress events, discrete events are converted into continuous progress values ​​through a weight allocation algorithm, driving the Flutter animation engine to update the progress bar component on the interface, while simultaneously outputting the original text after coloring in the log panel.

7. The method according to any one of claims 1 to 6, characterized in that, The exit code of the monitoring subprocess and the success or error identifier in the output stream are used to generate an upload result report and trigger a system notification, specifically including: By monitoring the exit code channel and output stream channel of subprocesses in parallel, a collaborative analysis mechanism for exit status and text output is established. For the output stream channel, a multi-level regular expression matching engine is applied to scan a predefined set of success / error patterns. At the same time, the status level is divided by combining the numerical range of the exit code channel to generate a preliminary result identifier. By integrating preliminary result identifiers and raw output content, the report template engine integrates key event timestamps, error solution links, and performance metrics into a structured report, and attaches a compressed archive of the original logs. Based on the structured report, the system calls the operating system's native notification interface to send interactive reminders, and automatically triggers sound or vibration feedback according to the error level.

8. A cross-platform IPA package upload system based on Flutter, characterized in that, The system specifically includes: The first upload module is used to develop desktop applications using the Flutter framework, and pre-packages the iTMSTransporter command-line tool and Java runtime environment within the desktop application; The second upload module is used to receive Apple login information entered by the user through the desktop application, generate an authentication token based on the Apple login information, and store it persistently. The third upload module is used to retrieve IPA files based on desktop applications by responding to user drag-and-drop or file selection operations, automatically decompressing the IPA file and parsing the file to obtain the parsing results; The fourth upload module is used to dynamically generate command-line instructions based on the parsing results. The parameters of the command-line instructions include BundleID, certificate information, and associated store ID obtained from the Apple API. The fifth upload module is used to execute upload commands by launching a child process through Flutter's process_run library based on command line instructions, capturing the command line output stream in real time, matching progress keywords through regular expressions and converting them into a visual progress bar; The sixth upload module is used to monitor the exit code of the subprocess and the success or error identifier in the output stream, generate an upload result report and trigger system notifications.

9. A computer device, characterized in that, include: The memory and processor, and the computer program stored in the memory, which, when executed on the processor, implements the Flutter-based cross-platform IPA package upload method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, It stores a computer program, which, when executed by a processor, implements the Flutter-based cross-platform IPA package upload method as described in any one of claims 1 to 7.

Images