A reporting and inspection method, system, device and medium for game advertising media packages

Abstract

This invention is applicable to the field of advertising placement and discloses a reporting and inspection method, system, device, and medium for game advertising media packages. The reporting and inspection method ensures the effective display of advertising content through interaction between the game terminal, advertising platform, and SDK. The method also involves sending and responding to advertising requests, inspecting and analyzing log data, notifying abnormal content, and packaging and installing advertising content. In particular, during the advertising content packaging and installation process, the invention also introduces a stress testing solution to simulate actual environments to perform SDK performance testing and generate performance reports. This method not only ensures the accurate display of advertising content but also improves the stability and reliability of the SDK through stress testing, providing strong support for the efficient dissemination of game advertising.

Description

Technical Field

[0001] The present invention relates to the field of advertising placement, and in particular to a method, system, device and medium for reporting and checking game advertising media packages. Background Art

[0002] In the mobile internet advertising industry, game advertising media package reporting and inspection is a key technology to ensure advertising effectiveness and billing. The media package refers to the resource package of game advertisements, which includes advertisement images, videos, animations and other content. With the rapid development of the gaming industry, there are many advertising platforms, and game publishers need to carry out refined management of advertising on each platform, which requires that the advertising media package reporting function must be stable and reliable.

[0003] Existing methods for reporting and inspecting game ad media packages often lack effective means for evaluating the performance of ad platforms and SDKs under specific circumstances. In these situations, the system may face significant pressure, leading to response delays, service interruptions, or performance degradation, which in turn affects the effectiveness of reporting and inspection. Summary of the Invention

[0004] The present invention aims to solve at least one of the technical problems existing in the prior art. To this end, the present invention proposes a reporting and checking method, system, device and medium for game advertisement media packages.

[0005] In a first aspect, the present application proposes a method for reporting and checking game advertising media packages, comprising:

[0006] The game terminal sends an advertisement request to the advertising platform through the SDK, and the advertising platform responds to the advertisement request and transmits the game advertisement content to the game terminal;

[0007] The script sends a check command to the SDK based on the advertisement content transmitted by the game terminal, and the SDK transmits log data to the script according to the check command;

[0008] The script analyzes the log data and reports the analysis results to the advertising platform, and the script determines whether to display the advertising content based on the analysis results;

[0009] If the analysis result contains abnormal content, the script prompts to check the abnormal content; if the analysis result contains no abnormal content, the script packages and installs the advertising content on the test device;

[0010] When the test device packages and installs the advertising content, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generates a performance report of the SDK based on the performance data.

[0011] To be more specific, in the above technical solution, the stress environment includes at least one of low device power, insufficient device memory and different network environments; the performance data includes at least one of response time, resource occupancy and crash rate.

[0012] More specifically, in the above technical solution, recording the response time includes:

[0013] Setting a time window, and extracting all response time data within the time window from the data recording the response time;

[0014] Calculating a mean of the response time based on the data of all response times within the time window, and calculating a standard deviation of the response time based on the mean and the data of each response time;

[0015] Based on the mean and the standard deviation, a timeout judgment threshold is calculated, where the timeout judgment threshold = the mean of the response time + 3 * the standard deviation of the response time;

[0016] Based on the data of all response times in the time window, the request volume and the timed-out request volume in the time window are obtained respectively, the timeout rate in the time window is calculated based on the request volume and the timed-out request volume, and the size of the next time window is adjusted according to the timeout rate.

[0017] More specifically, in the above technical solution, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generating a performance report of the SDK based on the performance data includes:

[0018] The script simulates different network environments, obtains the performance table data of the SDK under various network conditions, records the response time and success rate of the SDK under different network delay and packet loss rate pressure environments, and obtains the performance report of the SDK in different network environments.

[0019] More specifically, in the above technical solution, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generating a performance report of the SDK based on the performance data further includes:

[0020] The script simulates a stressful environment of low battery and insufficient device memory, obtains the running status of the SDK, records the CPU occupancy and crash rate of the SDK, and obtains a performance report of the SDK under low battery and insufficient device memory.

[0021] To be more specific, in the above technical solution, after the script analyzes the log data, it also includes memory leak detection. The memory leak detection includes: the script analyzes the log data through a linear regression algorithm to predict the memory growth trend. If the memory usage shows a continuous growth trend, it is determined that there is a memory leak, and the memory leakage rate is calculated.

[0022] To be more specific, in the above technical solution, based on the log data, the actual values ​​of the click-through rate, views and dwell time of the advertising content in the current time period are obtained, and the predicted values ​​of the click-through rate, views and dwell time of the advertising content in each time period are obtained through model training. The predicted values ​​and the actual values ​​are compared using statistical analysis methods to obtain the performance of the advertising content in the current time period.

[0023] Secondly, this application also proposes a reporting system for game advertising media packages, including:

[0024] First processing module: The game terminal sends an advertisement request to the advertisement platform through the SDK, and the advertisement platform responds to the advertisement request and transmits the advertisement content of the game to the game terminal;

[0025] Second processing module: a script sends a check command to the SDK based on the advertisement content transmitted by the game terminal, and the SDK transmits log data to the script according to the check command;

[0026] A third processing module: the script analyzes the log data and reports the analysis results to the advertising platform, and the script determines whether to display the advertising content based on the analysis results;

[0027] Fourth processing module: if the analysis result contains abnormal content, the script prompts to check the abnormal content; if the analysis result contains no abnormal content, the script packages and installs the advertisement content on the test device;

[0028] When the test device packages and installs the advertising content, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generates a performance report of the SDK based on the performance data.

[0029] In a third aspect, the present application further proposes a terminal device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements any of the above methods when executing the computer program.

[0030] In a fourth aspect, the present application further proposes a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the method as described in any one of the above items is implemented.

[0031] Compared with the prior art, the embodiments of the present invention have the following beneficial effects:

[0032] The reporting and checking method for game advertisement media packages of the present invention improves the stability and accuracy of advertisement reporting, reduces testing workload, improves testing efficiency, and reduces human errors through automation.

[0033] In addition, the present invention significantly improves the efficiency and accuracy of advertising display and SDK exception handling analysis through automated testing and multi-dimensional exception simulation; the system can promptly detect and feedback abnormal situations, ensuring the stability of advertising display and the reliability of the SDK; at the same time, through the simulation and data analysis of various extreme situations, the present invention provides strong support for the further optimization of the SDK, improving its recovery ability and performance stability in harsh environments. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0035] Figure 1 This is a flowchart of a method for reporting and checking game advertisement media packages provided by one embodiment of the present invention;

[0036] Figure 2 This is a structural diagram of a reporting and checking system for game advertisement media packages provided by one embodiment of the present invention;

[0037] Figure 3 It is a structural diagram of the terminal device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0038] In the following description, specific details such as specific system structures and techniques are provided for purposes of illustration rather than limitation to facilitate a thorough understanding of the embodiments of the present application. However, it will be apparent to those skilled in the art that the present application may be implemented in other embodiments without these specific details. In other cases, detailed descriptions of well-known systems, devices, circuits, and methods are omitted to avoid obscuring the description of the present application with unnecessary detail.

[0039] It should be understood that when used in the present specification and the appended claims, the term "comprising" indicates the presence of described features, integers, steps, operations, elements and / or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components and / or collections thereof.

[0040] It will also be understood that the term "and / or" used in this specification and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.

[0041] As used in this specification and the appended claims, the term "if" can be interpreted as "when" or "upon" or "in response to determining" or "in response to detecting," depending on the context. Similarly, the phrase "if it is determined" or "if [described condition or event] is detected" can be interpreted as meaning "upon determination" or "in response to determining" or "upon detection of [described condition or event]" or "in response to detecting [described condition or event]," depending on the context.

[0042] In addition, in the description of the present application specification and the appended claims, the terms "first", "second", "third", etc. are only used to distinguish the descriptions and cannot be understood as indicating or implying relative importance.

[0043] References to "one embodiment" or "some embodiments" in this specification mean that a particular feature, structure, or characteristic described in conjunction with that embodiment is included in one or more embodiments of the present application. Thus, phrases such as "in one embodiment," "in some embodiments," "in other embodiments," and "in other embodiments" appearing in various places in 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 "including," "comprising," "having," and variations thereof all mean "including but not limited to," unless otherwise specifically emphasized.

[0044] See also Figure 1 This application proposes a method for reporting and checking game advertising media packages, including:

[0045] S01. The game terminal sends an advertisement request to the advertisement platform through the SDK. The advertisement platform responds to the advertisement request and transmits the advertisement content of the game to the game terminal.

[0046] S02. The script sends a check command to the SDK based on the advertisement content transmitted by the game terminal, and the SDK transmits log data to the script according to the check command;

[0047] S03, the script analyzes the log data and reports the analysis results to the advertising platform, and the script determines whether to display the advertising content based on the analysis results;

[0048] S04. If the analysis result contains abnormal content, the script prompts to check the abnormal content; if the analysis result does not contain abnormal content, the script packages and installs the advertising content on the test device;

[0049] When the test device packages and installs the advertising content, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generates a performance report of the SDK based on the performance data.

[0050] The SDK sends an ad request to the ad platform, carrying parameters such as device information and user information. Based on these parameters, the ad platform selects appropriate ad content and returns it to the SDK. After receiving the ad content from the ad platform, the SDK displays the ad within the game and simultaneously records ad display log data. An automated script sends a check command to the SDK, retrieves the ad display log data recorded by the SDK, and parses and analyzes the log data. By analyzing the log data, it determines whether the ad display is successful, generates an ad display result report, and sends the results back to the ad platform. If the analysis results indicate an anomaly, the automated script prompts manual intervention to investigate the specific anomaly and generates an anomaly report. The SDK uses a script to automatically package and install the game ad content on the test device. The script simulates various extreme conditions, such as network environments, low battery, and insufficient memory, to stress test the SDK. Under these extreme test conditions, the script records various SDK performance metrics, such as response time, resource usage, and crash rate, to assess its stability and reliability. Using big data analytics, the SDK performance data collected from multiple iterations of testing is aggregated and analyzed to generate a comprehensive report on the SDK's performance under various complex environments. Based on the comprehensive analysis report, determine whether the SDK meets the expected stability and reliability requirements. If not, feedback will be provided to the SDK development team for optimization and improvement.

[0051] Specifically, when the SDK sends an ad request to the ad platform, it carries information such as the device's IMEI number, MAC address, and operating system version, as well as user tags such as age, gender, and location. After receiving these parameters, the ad platform uses machine learning algorithms such as logistic regression and decision trees to analyze user profiles, screening out ads with an estimated CTR greater than 0.5% and returning them to the SDK. After receiving the ad content, the SDK uses the ViewVisibility algorithm to determine the ad's viewability. If the viewability is greater than 50% and lasts for more than one second, it counts it as a valid impression and stores the impression log data, including the ad ID, impression timestamp, and viewability, in a local database in JSON format. An automated script sends a check command to the SDK via HTTP. The SDK returns the log data from the local database to the script, which parses the JSON data using regular expressions to extract key fields. It then uses the NumPy library to analyze the data and calculate metrics such as the number of impressions and CTR for each ad. If the analysis results indicate that an ad's CTR is less than 0.1%, it is considered an anomaly and an exception report is generated and automatically sent to the ad platform and operations staff via email. The script uses the Appium framework to automatically install game APK and IPA packages on different Android device models. It also sets up extreme environments such as disconnected networks, weak networks, and high latency, simulating user behaviors such as frequent switching between the foreground and background apps and quickly swiping through lists to stress-test the SDK. During the test, the script uses the Android Profiler and Instruments tools to record performance indicators such as the SDK's CPU usage, memory usage, and crash rate. Using the MapReduce framework, the script processes massive amounts of log data obtained from multiple devices and multiple iterations of testing in parallel, compiling statistics on the SDK's comprehensive performance in various network environments and user operations to generate a visual analysis report. If the SDK's crash rate is higher than 1% or the response time is longer than 500ms, it is judged as substandard, and a JIRA task is automatically created and assigned to the SDK development team for optimization.

[0052] In some embodiments, the stress environment includes at least one of low device power, insufficient device memory, and different network environments; and the performance data includes at least one of response time, resource usage, and crash rate.

[0053] In some embodiments, recording the response time includes:

[0054] Setting a time window, and extracting all response time data within the time window from the data recording the response time;

[0055] Calculating a mean of the response time based on the data of all response times within the time window, and calculating a standard deviation of the response time based on the mean and the data of each response time;

[0056] Based on the mean and the standard deviation, a timeout judgment threshold is calculated, where the timeout judgment threshold = the mean of the response time + 3 * the standard deviation of the response time;

[0057] Based on the data of all response times in the time window, the request volume and the timed-out request volume in the time window are obtained respectively, the timeout rate in the time window is calculated based on the request volume and the timed-out request volume, and the size of the next time window is adjusted according to the timeout rate.

[0058] Based on the collected response time data samples of requests under stress, an initial time window size is set to obtain all response time data within the initial time window. The mean response time is calculated from all response time data collected within the time window. The standard deviation of the response time is calculated by taking the sum of the squares of the differences between all response time samples and the mean within the time window and then taking the square root of the mean. The timeout threshold is calculated based on the mean response time and the standard deviation using the formula "timeout threshold = mean response time + 3 * standard deviation response time." The minimum response time value within the time window is obtained by iterating over all response time data within the time window. The maximum response time value within the time window is obtained by iterating over all response time data within the time window. The number of requests within the time window is determined based on the total number of ad requests. Each response time within the time window is compared with the timeout threshold, and the number of requests exceeding the threshold is counted to obtain the number of timed requests. The timeout rate within the time window is calculated based on the number of timed requests and the total number of requests using the formula "timeout rate = number of timed requests / number of requests." Based on the above calculation results, the size of the next time window is dynamically adjusted to ensure that response time samples can be collected more accurately, optimizing the response time analysis process of ad requests under stressful environments.

[0059] Specifically, when analyzing the response time of ad requests, we first set the initial time window size to 10 minutes. By collecting all response time data within this 10-minute period, assuming the collected data samples are: [120ms, 130ms, 125ms, 150ms, 200ms, 180ms, 170ms, 160ms, 140ms, 155ms]. Based on this data, we calculate the mean response time as: Mean = (120 + 130 + 125 + 150 + 200 + 180 + 170 + 160 + 140 + 155) / 10 = 153ms. Then, we calculate the square of the difference between each response time and the mean. For example, if the first response time is 120ms, the corresponding square of the difference is: (120 - 153)^2 = (-33)^2 = 1089. The sum of the squares of all response time differences is calculated as follows: (120-153)^2 + (130-153)^2 + (125-153)^2 + (150-153)^2 + (200-153)^2 + (180-153)^2 + (170-153)^2 + (160-153)^2 + (140-153)^2 + (155-153)^2 = 1089+529+784+9+2209+729+289+49+169+4 = 5860. Taking the square root of the mean gives the standard deviation of the response time: standard deviation = sqrt(5860 / 10) ≈ 22 ms. Based on the mean and standard deviation, the timeout threshold is calculated: timeout threshold = 153 + 3*22 ≈ 226 ms. By traversing all response time data within the time window, we find that the minimum response time is 120ms and the maximum response time is 200ms. The total number of requests within the time window is 10. Next, we compare each response time with the timeout threshold and count the number of requests that exceed the threshold. Since all response times are less than 226ms, the number of timed-out requests is zero. Based on the number of timed-out requests and the total number of requests, we calculate the timeout rate: timeout rate = 0 / 10 = 0. Based on these calculations, we can dynamically adjust the size of the next time window. Since the current timeout rate is 0, indicating that the response time of ad requests is relatively stable, we can appropriately increase the time window, for example, to 15 minutes, to collect more response time samples and thus optimize the response time analysis process for ad requests. The above process demonstrates how to effectively analyze and optimize the response time of ad requests under stressful conditions by setting an initial time window, collecting response time data, calculating the mean and standard deviation, determining the timeout threshold, counting the number of timed-out requests and the timeout rate, and dynamically adjusting the time window size.

[0060] In some embodiments, the automated script sends a check command to the SDK, which returns log data containing key performance indicators such as CPU utilization, memory usage, and battery power. The script parses the log data and extracts the values ​​of each indicator, such as a CPU utilization of 35%, a memory usage of 120MB, and a battery power of 15%. The device resource simulation framework intercepts the SDK's resource query request by hooking the system API and returns preset low-resource status data, such as a CPU utilization of 90%, a memory usage of only 30MB, and a battery power of 5%, allowing the SDK to operate in a controlled low-resource environment. The script analyzes the SDK's operation log and captures alarms triggered by excessive CPU utilization and anomalies such as cache write failures caused by low memory usage, thereby determining that the current environment cannot meet the display requirements of the advertisement. The script prompts manual intervention to check the SDK's exception handling logic and optimize resource scheduling strategies, such as using incremental updates and delayed loading to reduce one-time resource consumption. After optimization, the game was repackaged and the above testing process was repeated with different resource states. Comparative analysis revealed improvements in the SDK's adaptability and stability, with CPU utilization reduced to 60%, memory usage increased to 80MB, and ads displaying normally. With the help of a network simulator, the SDK's request retry and timeout handling mechanisms were further tested under weak and no network conditions. Test cases were developed for key scenarios to comprehensively evaluate the SDK's performance and ultimately produce a complete test report.

[0061] In some embodiments, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generating a performance report of the SDK based on the performance data includes:

[0062] The script simulates different network environments, obtains the performance table data of the SDK under various network conditions, records the response time and success rate of the SDK under different network delay and packet loss rate pressure environments, and obtains the performance report of the SDK in different network environments.

[0063] In some embodiments, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generating a performance report of the SDK based on the performance data further includes:

[0064] The script simulates a stressful environment of low battery and insufficient device memory, obtains the running status of the SDK, records the CPU occupancy and crash rate of the SDK, and obtains a performance report of the SDK under low battery and insufficient device memory.

[0065] It is understandable that the present invention can, based on the SDK's functions and business scenarios, simulate different network environments to obtain the SDK's performance under various network conditions. By recording the SDK's response time, success rate and other indicators under different network delays, packet loss rates and other conditions, the SDK's stress tolerance under different network environments can be obtained. For example, based on the power and memory usage of the mobile device, the SDK's operating status under resource-constrained conditions can be obtained by simulating low power and insufficient memory on the device. By monitoring the SDK's CPU occupancy rate, crash rate and other indicators when the power is low and the memory is insufficient, the SDK's stability and reliability under extreme conditions can be judged. For example, based on the SDK's business volume and concurrency requirements, the SDK's processing power in high-concurrency scenarios can be obtained by simulating a large number of concurrent users. By gradually increasing the number of concurrent users and recording changes in the SDK's response time, error rate and other conditions, the maximum number of concurrent users that the SDK can support can be determined. For example, based on the SDK's data transmission and storage requirements, we simulate large data volumes to assess the SDK's performance in data-intensive scenarios. By continuously increasing the amount of data per request, we monitor changes in metrics like the SDK's transmission speed and storage usage to determine the SDK's processing efficiency and resource consumption under large data volumes. Based on the results of these stress tests, we analyze and compare the SDK's overall performance under various extreme conditions. By summarizing test metrics from different scenarios and plotting SDK performance trends and bottlenecks, we can determine optimization directions and improvement measures for the SDK, thereby improving its stability, reliability, and efficiency to better meet the actual needs of the business.

[0066] Specifically, to comprehensively evaluate the SDK's performance under various network conditions, you can use network simulation tools such as Charles or Fiddler, setting different network delays (e.g., 100ms, 500ms, 1s) and packet loss rates (e.g., 1%, 5%, 10%). Then, using automated test scripts such as Appium or Selenium, simulate user behavior and record the SDK's average response time and request success rate under each network condition. For example, if the SDK's average response time is less than 1s and its success rate is greater than 99% when the network delay is 500ms and the packet loss rate is 5%, it can be considered to perform well under moderate network conditions. Furthermore, to test the SDK's stability under resource-constrained conditions, you can use Android Studio's DeviceMonitor or Xcode's Instruments to simulate scenarios where the device battery level drops below 10% or the available memory is less than 50MB, and monitor the SDK's CPU usage and crash count. If the SDK's CPU usage remains below 30% and no crashes occur after running continuously for one hour, it indicates high resource utilization and adaptability to harsh device conditions. In addition, it is necessary to evaluate the load capacity of the SDK in high-concurrency scenarios. With the help of stress testing tools such as JMeter or LoadRunner, set the number of concurrent users to 100, 500, 1000, etc., and observe the changing trends of the SDK's average response time and error rate. If the average response time increases by less than 50% and the error rate is less than 1% when the number of concurrency reaches 500, it indicates that the SDK can withstand a larger scale of concurrent access. Finally, for data-intensive applications, you can use Charles's Rewrite function or a self-developed data generator to simulate a single request with a data volume of 1KB, 100KB, 1MB, etc., and analyze the changes in the SDK's data transmission speed and memory usage. For example, if the request data volume is 1MB, the SDK's average transmission speed is higher than 5MB / s and the memory usage is less than 50MB, it proves that its data processing efficiency is high and can meet the business needs of large data volumes. By combining the stress test results from multiple dimensions above, we can determine the overall performance of the SDK in extreme scenarios such as unstable network, poor device performance, many concurrent users, and large data volumes. Through visual charts such as line charts and waterfall charts, we can intuitively display the strengths and weaknesses of its performance and the room for improvement, providing strong data support and decision-making basis for subsequent optimization work, and ultimately creating a stable, efficient, reliable, and high-quality SDK product.

[0067] In some embodiments, after analyzing the log data, the script also includes memory leak detection. The memory leak detection includes: the script analyzes the log data through a linear regression algorithm to predict the memory growth trend. If the memory usage shows a continuous growth trend, it is determined that there is a memory leak, and the memory leakage rate is calculated.

[0068] Preferably, the script adds memory leak detection between analyzing the log data and reporting the analysis results to the advertising platform, which is specifically implemented as follows: advertising request: the game sends an advertising request to the advertising platform through the SDK and waits for the advertising response; reporting response: the advertising platform responds to the game request and returns the advertising content; automated script detection: the script sends a check command to the SDK, and the SDK returns log data to the script for analysis; at the same time, the script regularly samples and analyzes the memory space occupied by the SDK and records memory usage; memory leak detection: a linear regression algorithm is used to analyze the collected memory data and predict the memory growth trend; if the memory usage shows a continuous growth trend, it is determined that there is a memory leak, and the leakage rate is calculated. rate; memory leak detection results serve as a key indicator of the ad SDK's operational health; Report Result Analysis: The script analyzes the reported results and memory detection results to comprehensively determine whether ads are successfully displayed and whether the SDK has any anomalies such as memory leaks. The analysis results are fed back to the ad platform and a test report is generated. Manual Inspection Prompt: If any anomalies are found, the script prompts manual intervention to inspect the anomaly, including ad display anomalies and memory leak anomalies. Manual inspection helps determine the cause of the anomaly and provides optimization suggestions. Automatic Packaging and Installation: The script automatically packages and installs the game on the test device for the next round of testing. A memory detection module is integrated into the packaging and installation process, automating the detection function. By adding the memory leak detection module, the automated test script can comprehensively evaluate the performance and stability of the ad SDK, ensuring that the SDK does not experience memory leaks during operation, consume excessive memory resources, and affect the user experience. The memory detection results and ad display results will form a comprehensive test report, providing a basis for optimizing SDK performance. Furthermore, the integration of the memory detection module into the automated packaging and installation process further improves testing efficiency and ensures SDK quality.

[0069] Specifically, the game sends an ad request to the ad platform through the SDK and waits for a response. Upon receiving the request, the ad platform selects appropriate ad content from its ad library, encapsulates it in JSON format, and returns it to the SDK via HTTP. An automated script sends a check command to the SDK via socket communication. Upon receiving the command, the SDK returns key log data to the script as key-value pairs. The script parses the log data, extracting key metrics such as ad fill rate and impression rate. It also collects the SDK's memory usage every 5 seconds for 100 consecutive times. This collected memory data is used for memory leak detection. A least squares method is used to fit a memory usage growth curve. If the slope of the fitted curve is greater than 1MB / min, a memory leak is identified, and the leak rate is the slope value. The memory leak detection results, along with the ad metrics data, are fed back to the ad platform and a PDF test report is generated. Any abnormalities, such as a memory leak rate exceeding 1MB / min or an ad fill rate below 90%, are highlighted in red in the report and emailed to the relevant personnel. The script automatically calls Android packaging tools such as Gradle, dynamically modifies the game package name, version number and other parameters according to the configuration file, inserts the memory detection module code into the game code, performs packaging and signing, generates an APK file, and automatically installs it to the test device through the ADB tool for the next round of testing.

[0070] In some embodiments, based on the log data, the actual values ​​of the click-through rate, views and dwell time of the advertising content in the current time period are obtained, and the predicted values ​​of the click-through rate, views and dwell time of the advertising content in each time period are obtained through model training. The predicted values ​​and the actual values ​​are compared using statistical analysis methods to obtain the performance of the advertising content in the current time period.

[0071] Based on the display logs from the ad delivery platform, ad screenshot data is obtained to obtain screenshot images of the actual ad display. The creative library within the ad creative management system is used to obtain the original ad creative and determine the original ad image or video to be used for delivery. Image processing techniques are used to extract key element features from the ad screenshots to obtain information such as the title, brand, slogan, and product image. An image similarity algorithm is used to calculate the similarity between the key elements extracted from the ad screenshots and the original ad creative to obtain a matching score. Based on the ad display logs, ad display timestamps are obtained to determine the specific start and end times of the ad display. The user behavior tracking system is used to capture user interactions during the ad display period and determine specific user behavior data such as clicks, hovers, and skips. Ad page structure data is used to obtain the specific placement of the ad within the page or app to determine the placement. Device information is used to identify the device type used when the ad was displayed to determine whether the device used was a mobile phone, computer, or other device. The user data analysis system is used to obtain demographic characteristics of the target audience and determine user profile information, including age, gender, and interests. Based on the data obtained in the above steps, a complete advertising effect analysis system is formed to provide data support for advertising strategy optimization and effect evaluation.

[0072] Specifically, to implement an advertising effectiveness analysis system, first obtain ad screenshot data from the display logs of the advertising platform, for example, by exporting a CSV file containing the URLs of the ad screenshots from the log records. Then, use the creative library in the ad creative management system to download the original ad creatives, including images and videos. For example, the ad creative library contains an image file named "summer_sale_banner.jpg." Next, use image recognition algorithms (such as OpenCV and Tesseract) to extract key element features from the ad screenshots. Suppose the title extracted from the ad screenshot is "Summer Sale," the brand name is "XYZClothing," the slogan is "Up to 50% off," and the product image URL is "product_image_12jpg." Next, use an image similarity calculation algorithm (such as SIFT or ORB feature matching) to calculate the similarity between the key elements extracted from the ad screenshot and the original ad creative. Assume the similarity score calculated by the SIFT algorithm is 85%. We use timestamp data from ad display logs to determine the specific time of ad display, such as the start time of "2023-10-01 14:00:00" and the end time of "2023-10-01 14:05:00." We use user behavior tracking systems, such as Google Analytics' event tracking feature, to obtain user interaction data during the ad display period. For example, we record 150 clicks on the ad, an average hover time of 5 seconds, and a skip rate of 30%. We then use the page structure data from the ad delivery to determine the specific placement of the ad within the page or app, such as the center of the right column of the webpage. We use device information to identify the device type at the time of ad display, for example, identifying that 60% of the devices displayed the ad were mobile phones, 30% were computers, and 10% were tablets. Furthermore, through a user data analysis system, using SQL queries or a dedicated analysis platform, we extract demographic information from the database for the target audience, such as 70% of users are aged 18-34 and 60% are female and 40% are male. Combining all of the above data, using data analysis tools (such as Tableau or Excel), we can develop a comprehensive advertising effectiveness analysis system. For example, by integrating the ad display similarity score, user interaction behavior, display location, and device type, we can conclude that this ad performs best among young women, with high click-through rates and hover times. This provides accurate data support for future advertising strategy optimization and effectiveness evaluation.

[0073] See also Figure 2 This application also proposes a reporting system for game advertising media packages, including:

[0074] First processing module 201: The game terminal sends an advertisement request to the advertisement platform through the SDK. The advertisement platform responds to the advertisement request and transmits the advertisement content of the game to the game terminal.

[0075] Second processing module 202: The script sends a check command to the SDK based on the advertisement content transmitted by the game terminal, and the SDK transmits log data to the script according to the check command;

[0076] Third processing module 203: The script analyzes the log data and reports the analysis results to the advertising platform, and the script determines whether to display the advertising content based on the analysis results;

[0077] Fourth processing module 204: If the analysis result contains abnormal content, the script prompts to check the abnormal content; if the analysis result does not contain abnormal content, the script packages and installs the advertising content on the test device;

[0078] When the test device packages and installs the advertising content, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generates a performance report of the SDK based on the performance data.

[0079] It is understandable that if Figure 1 The contents of the embodiment of the method for reporting and checking the game advertising media package shown in the figure are applicable to the embodiment of the system for reporting and checking the game advertising media package. The functions specifically implemented by the embodiment of the system for reporting and checking the game advertising media package are similar to those in the embodiment of the method for reporting and checking the game advertising media package shown in the figure. Figure 1 The method for reporting and checking the game advertisement media package shown in the embodiment is the same as that in the embodiment shown in the embodiment, and the beneficial effects achieved are the same as those in the embodiment shown in the embodiment. Figure 1 The beneficial effects achieved by the embodiment of the method for reporting and checking game advertisement media packages shown are also the same.

[0080] It should be noted that the information interaction, execution process and other contents between the above-mentioned systems are based on the same concept as the embodiment of the method of the present invention. Their specific functions and technical effects can be found in the method embodiment part and will not be repeated here.

[0081] Those skilled in the art can clearly understand that, for the convenience and brevity of description, only the division of the above-mentioned functional units and modules is used as an example for illustration. In actual applications, the above-mentioned functions can be distributed and completed by 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 embodiment can be integrated into one processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above-mentioned integrated unit can be implemented in the form of hardware or in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing each other, and are not used to limit the scope of protection of this application. The specific working process of the units and modules in the above-mentioned system can refer to the corresponding process in the aforementioned method embodiment, and will not be repeated here.

[0082] See also Figure 3 An embodiment of the present invention further provides a computer device 3, comprising: a memory 302, a processor 301, and a computer program 303 stored in the memory 302. When the computer program 303 is executed on the processor 301, the reporting and checking method of the game advertisement media package as described in any one of the above methods is implemented.

[0083] The computer device 3 may be a desktop computer, a notebook computer, a PDA, a cloud server or other computing devices. 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 This is merely an example of the computer device 3 and does not constitute a limitation on the computer device 3 . The computer device 3 may include more or fewer components than shown in the figure, or a combination of certain components, or different components. For example, the computer device 3 may also include input and output devices, network access devices, etc.

[0084] The processor 301 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor may be a microprocessor or any conventional processor.

[0085] 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 also be an external storage device of the computer device 3, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) card, a Flash Card, etc. equipped on the computer device 3. Furthermore, the memory 302 may include both an internal storage unit of the computer device 3 and an external storage device. The memory 302 is used to store an operating system, application programs, a boot loader, data, and other programs, such as the program code of the computer program. The memory 302 may also be used to temporarily store data that has been output or is about to be output.

[0086] An embodiment of the present invention further provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, the method for reporting and checking game advertisement media packages as described in any one of the above methods is implemented.

[0087] 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, the present application implements all or part of the process of the above-mentioned method embodiment by instructing the relevant hardware through a computer program. The computer program can be stored in a computer-readable storage medium. When the computer program is executed by a processor, it can implement the steps of each of the above-mentioned method embodiments. The computer program includes computer program code, which can be in source code form, object code form, executable file, or some intermediate form. The computer-readable medium can at least include: any entity or device capable of carrying computer program code to the camera / terminal device, recording medium, computer memory, read-only memory (ROM), random access memory (RAM), electric carrier signal, telecommunication signal, and software distribution medium. For example, a USB flash drive, mobile hard drive, magnetic disk, or optical disk. In some jurisdictions, based on legislation and patent practice, computer-readable media cannot be electric carrier signals or telecommunication signals.

[0088] The above-described embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present application, and should all be included in the scope of protection of the present application.

Claims

1. A method for reporting and checking game advertising media packages, characterized in that: include: The game terminal sends an advertisement request to the advertising platform through the SDK, and the advertising platform responds to the advertisement request and transmits the game advertisement content to the game terminal; The script sends a check command to the SDK based on the advertisement content transmitted by the game terminal, and the SDK transmits log data to the script according to the check command; The script analyzes the log data and reports the analysis results to the advertising platform, and the script determines whether to display the advertising content based on the analysis results; If the analysis result contains abnormal content, the script prompts to check the abnormal content; if the analysis result contains no abnormal content, the script packages and installs the advertising content on the test device; When the test device packages and installs the advertising content, the script performs a stress test on the SDK in a simulated stress environment and records performance data of the SDK, and generates a performance report of the SDK based on the performance data; The stress environment includes at least one of low device power, insufficient device memory, and different network environments; the performance data includes at least one of response time, resource usage, and crash rate; Among them, recording the response time includes: setting a time window, extracting data of all response times within the time window from the data of recorded response times; calculating the mean of the response time based on the data of all response times within the time window, and calculating the standard deviation of the response time based on the mean and the data of each response time; calculating the timeout judgment threshold based on the mean and the standard deviation, the timeout judgment threshold = mean of the response time + 3*standard deviation of the response time; based on the data of all response times within the time window, respectively obtaining the number of requests and the number of timed-out requests within the time window, calculating the timeout rate within the time window based on the number of requests and the number of timed-out requests, and adjusting the size of the next time window according to the timeout rate.

2. The method for reporting and checking game advertisement media packages according to claim 1, characterized in that: The script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK. Generating a performance report of the SDK based on the performance data includes: The script simulates different network environments, obtains the performance table data of the SDK under various network conditions, records the response time and success rate of the SDK under different network delay and packet loss rate pressure environments, and obtains the performance report of the SDK in different network environments.

3. The method for reporting and checking game advertisement media packages according to claim 2, characterized in that: The script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generating a performance report of the SDK based on the performance data further includes: The script simulates a stressful environment of low battery and insufficient device memory to obtain the running status of the SDK, record the CPU occupancy and crash rate of the SDK, and obtain a performance report of the SDK under low battery and insufficient device memory.

4. The method for reporting and checking game advertisement media packages according to claim 1, characterized in that: After analyzing the log data, the script also includes memory leak detection. The memory leak detection includes: the script analyzes the log data through a linear regression algorithm to predict the memory growth trend. If the memory usage shows a continuous growth trend, it is determined that there is a memory leak and the memory leakage rate is calculated.

5. The method for reporting and checking game advertisement media packages according to claim 1, characterized in that: Based on the log data, the actual values ​​of the click-through rate, page views and dwell time of the advertising content in the current time period are obtained, and the predicted values ​​of the click-through rate, page views and dwell time of the advertising content in each time period are obtained through model training. The predicted values ​​and the actual values ​​are compared using statistical analysis methods to obtain the performance of the advertising content in the current time period.

6. A reporting system for game advertising media packages, characterized in that: include: First processing module: The game terminal sends an advertisement request to the advertisement platform through the SDK, and the advertisement platform responds to the advertisement request and transmits the advertisement content of the game to the game terminal; Second processing module: a script sends a check command to the SDK based on the advertisement content transmitted by the game terminal, and the SDK transmits log data to the script according to the check command; A third processing module: the script analyzes the log data and reports the analysis results to the advertising platform, and the script determines whether to display the advertising content based on the analysis results; Fourth processing module: if the analysis result contains abnormal content, the script prompts to check the abnormal content; if the analysis result contains no abnormal content, the script packages and installs the advertisement content on the test device; When the test device packages and installs the advertising content, the script simulates a stress environment to perform stress testing on the SDK and records performance data of the SDK, and generates a performance report of the SDK based on the performance data; The stress environment includes at least one of low device power, insufficient device memory, and different network environments; the performance data includes at least one of response time, resource usage, and crash rate; Among them, recording the response time includes: setting a time window, extracting data of all response times within the time window from the data of recorded response times; calculating the mean of the response time based on the data of all response times within the time window, and calculating the standard deviation of the response time based on the mean and the data of each response time; calculating the timeout judgment threshold based on the mean and the standard deviation, the timeout judgment threshold = mean of the response time + 3*standard deviation of the response time; based on the data of all response times within the time window, respectively obtaining the number of requests and the number of timed-out requests within the time window, calculating the timeout rate within the time window based on the number of requests and the number of timed-out requests, and adjusting the size of the next time window according to the timeout rate.

7. A terminal device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the method according to any one of claims 1 to 5 is implemented.

8. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the method according to any one of claims 1 to 5 is implemented.

Images