Target applet

Abstract

The invention discloses a target applet, and belongs to the technical field of computers. The target applet comprises a target engine, the volume of the target engine is smaller than a target volume threshold value, and the target engine is obtained by cutting a standard Flutter engine and retaining functions required for running the target applet; the target applet is used for determining a target function module based on a trigger event in a target scene under the condition that the target applet is started; loading and operating the target function module based on the target engine to obtain instant information corresponding to the target scene; and outputting the instant message. The target applet solves the problem that a cross-platform framework is difficult to adapt to App Clip, is suitable for scenes such as scenic spots needing to provide instant information service, and widens the application scenes.

Description

Technical Field

[0001] This application belongs to the field of computer technology, and in particular relates to a target applet. Background Technology

[0002] iOS introduced the Clip feature, allowing users to access specific parts of an application without fully installing it, such as by scanning a QR code. Flutter is a cross-platform development framework with high-performance rendering capabilities and a rich UI component library. However, the standard Flutter application package is quite large and cannot directly adapt to the size limit of iOS Clips. This limits the applicability of iOS Clips to scenarios that require providing immediate, rich, and highly interactive information services, such as scenic spots, museums, and temporary exhibitions. Summary of the Invention

[0003] This invention aims to at least solve one of the technical problems existing in the prior art. To this end, this invention proposes a target mini-program that solves the problem of cross-platform frameworks being difficult to adapt to App Clips, and is suitable for scenarios such as scenic spots that need to provide real-time information services, thus broadening the applicable scenarios.

[0004] Firstly, this application provides a target mini-program, including a target engine, wherein the size of the target engine is less than a target size threshold, and the target engine is obtained by trimming the standard Flutter engine to retain the functionality required to run the target mini-program; the target mini-program is used for: When the target mini-program is launched, the target functional module is determined based on the triggering events in the target scenario; Based on the target engine, the target functional module is loaded and run to obtain real-time information corresponding to the target scene; Output the real-time information.

[0005] According to the target mini-program provided in the embodiments of this application, the size of the target engine is made smaller than the target size threshold by customizing the target engine, which solves the problem that cross-platform frameworks are difficult to adapt to App Clips. When the target mini-program is launched, the target functional module corresponding to the target scenario is determined, thereby providing users with real-time information corresponding to the target scenario. It is applicable to scenarios such as scenic spots that need to provide real-time information services, thus broadening the applicable scenarios.

[0006] One embodiment of this application targets a mini-program that trims the standard Flutter engine using at least one of the following methods: Remove the just-in-time compiler, development debugging tools, and reflection functionality from the Dart virtual machine, while retaining the pre-compiled mode; Remove the 3D rendering functionality from the Skia rendering engine and reduce the number of image formats supported by the Skia rendering engine; Remove components used in the Flutter framework layer that have a frequency below a preset frequency threshold; Use the -Oz compilation optimization flag and enable link-time optimization and dead code elimination.

[0007] In one embodiment of this application, the target applet obtains the triggering event through the following steps: Receive the first input from the user on the user terminal on which the target mini-program is deployed; In response to the first input, the triggering event is generated.

[0008] In one embodiment of this application, the target mini-program, wherein receiving a first input from a user on a user terminal on which the target mini-program is deployed, includes: Receive image information corresponding to the graphic code captured by the camera set on the user terminal; And / or, The system receives a sensing signal generated by the Near Field Communication (NFC) module located on the user terminal, the sensing signal being generated when the user terminal touches a target object.

[0009] In one embodiment of this application, the target applet obtains the triggering event through the following steps: The trigger event is generated when the location information of the user terminal on which the target mini-program is deployed is detected and it is within the preset location range corresponding to the target scene.

[0010] In one embodiment of this application, the target applet, comprising the module for determining the target function based on triggering events in a target scenario, includes: Based on the target scenario, determine the user needs corresponding to at least one sub-scenario under the target scenario; The target functional module corresponding to the user's needs is determined from multiple candidate functional modules, and each candidate functional module is independent of the others.

[0011] In one embodiment of this application, the target mini-program includes at least one of the following candidate functional modules: UI component definition, business logic code, data model, resource file, routing configuration, and module manifest file.

[0012] In one embodiment of this application, the target applet has a candidate functional module with a standardized lifecycle interface and communication interface.

[0013] One embodiment of this application describes a target applet that loads the target functional module based on the target engine, including: Load the target functional module from the local cache space; or, The target functional module is loaded from the server, which is connected to the user terminal where the target applet is deployed.

[0014] In one embodiment of this application, after outputting the real-time information, the target applet is further configured to: If the triggering event is detected to have ended, delete the real-time information corresponding to the target scene.

[0015] The above-described one or more technical solutions in the embodiments of this application have at least one of the following technical effects: By customizing the target engine to make its size smaller than the target size threshold, the problem of cross-platform frameworks being difficult to adapt to AppClip is solved. By determining the target functional modules corresponding to the target scenario when the target mini-program is launched, the system can provide users with real-time information corresponding to the target scenario. This is suitable for scenarios such as scenic spots that need to provide real-time information services, thus broadening the applicable scenarios.

[0016] Additional aspects and advantages of this application will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0017] The above and / or additional aspects and advantages of this application will become apparent and readily understood from the description of the embodiments taken in conjunction with the following drawings, in which: Figure 1 This is a flowchart illustrating the method executed by the target applet provided in this application embodiment. Detailed Implementation

[0018] The technical solutions of the embodiments of this application will be clearly described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this application. All other embodiments obtained by those skilled in the art based on the embodiments of this application are within the scope of protection of this application.

[0019] The terms "first," "second," etc., used in the specification and claims of this application are used to distinguish similar objects and not to describe a specific order or sequence. It should be understood that such use of data can be interchanged where appropriate so that embodiments of this application can be implemented in orders other than those illustrated or described herein, and the objects distinguished by "first," "second," etc., are generally of the same class and the number of objects is not limited; for example, a first object can be one or more. Furthermore, in the specification and claims, "and / or" indicates at least one of the connected objects, and the character " / " generally indicates that the preceding and following objects are in an "or" relationship.

[0020] The target applet provided in this application will be described below with reference to the accompanying drawings, through specific embodiments and application scenarios.

[0021] The target mini-program includes the target engine, and the size of the target engine is smaller than the target size threshold.

[0022] The target mini-program is a lightweight application that can run without a full installation, such as an iOS App Clip, or may also include applications with similar "lightweight and fast-start" characteristics, such as WeChat mini-programs. This application does not limit the scope of the application.

[0023] The application package size of the App Clip must be limited to 10MB (uncompressed), and the App Clip must start quickly, allowing users to use it within 2-3 seconds after scanning the code. It can be temporarily stored, and the system will automatically clean it up after a period of time.

[0024] The target engine can be a simplified version of the Flutter engine, which is the core software module that drives the application to run.

[0025] In some embodiments, the target engine is a trimmed version of the standard Flutter engine that retains the functionality required to run the target mini-program.

[0026] In this embodiment, the standard Flutter engine includes development and debugging, multiple graphics rendering (2D / 3D), and a rich UI component library.

[0027] Unnecessary codebases, components, and functional modules can be removed from the source code or compilation level, while retaining only those that meet the specific operational requirements of the target mini-program, thus obtaining the target engine.

[0028] By customizing the Flutter engine, you can retain only the core functionality needed to run Clip applications and remove unnecessary features and libraries.

[0029] It can compress and optimize application resources, remove unused resources and dependencies, and reduce the overall size of the application package.

[0030] Flutter is a cross-platform development framework that supports multiple platforms such as iOS and Android. Flutter uses the Dart language and has high-performance rendering capabilities and a rich UI component library.

[0031] The target size threshold can be 10MB (e.g., for Clip under iOS 14, the target size threshold can be 10MB), 12MB or other values, and this application does not limit it.

[0032] The Flutter engine is 3.5MB in size, the core application code is under 2.5MB, necessary resources (such as images and fonts) are under 2.0MB, system libraries and dependencies are under 2.0MB, and the total size of the target engine is approximately 9.8MB, with a safety margin of 200KB.

[0033] The target app can be used to execute the methods shown in steps 110 to 130.

[0034] Step 110: When the target mini-program is launched, determine the target functional modules based on the triggering events in the target scenario; In this step, the target scenario is a specific application environment, such as a scenic spot, museum, exhibition hall, or shopping mall, where real-time information needs to be provided to users.

[0035] Triggering events are signals that launch and guide the mini-program to load specific content. For example, the launch of the target mini-program can be triggered by a QR code, NFC tag, or by detecting that the user has entered a geofence.

[0036] The target functional module is an independent software package that can be dynamically loaded and carries specific content (such as the introduction and guide of a certain attraction).

[0037] Step 120: Load and run the target function module based on the target engine to obtain real-time information corresponding to the target scene; In this step, loading refers to reading the code and data of the functional module from storage into memory, and running refers to the target engine interpreting and executing the module code, and drawing and decryption.

[0038] Real-time information is information that is highly relevant to the time and location of the triggering event. For example, in a scenic spot, real-time information may be the introduction of the attraction corresponding to the currently scanned QR code, or the guide content of the user's location; in a museum, real-time information may be audio guides, detailed focus images of the collection, and related historical pictures.

[0039] Step 130: Output real-time information.

[0040] In this step, the generated real-time information can be displayed to the user, such as on the user's terminal screen or played through a speaker.

[0041] During the research and development process, the inventors discovered that in related technologies, feature-rich cross-platform frameworks (such as Flutter) have an irreconcilable contradiction due to their inherent size (such as 25MB+) and the hard limitations of lightweight containers (such as 10MB), forcing developers to choose between the two.

[0042] In this application, by integrating a streamlined target engine, the technical obstacle that cross-platform frameworks cannot be applied to lightweight containers is solved, and a target mini-program with a very small body and extremely fast startup is built. The target mini-program dynamically loads modules through event-driven mechanisms, and can ultimately provide users with a service that instantly obtains high-quality and rich interactive information, while providing developers with an efficient and reusable dynamic lightweight application architecture.

[0043] The inventors' tests revealed that the target engine provided in this application embodiment is 50-67% smaller than that of a standard Flutter application (typically 15-30MB), allowing users to quickly download and launch the application. Through QR code scanning and location services, users can obtain real-time scenic spot information and interactive experiences related to their current location, enhancing user convenience and engagement. Specifically, this includes: rapid response: scenic spot information is available within 1-3 seconds of scanning; accurate positioning: positioning accuracy is 5-10 meters outdoors and 1-5 meters indoors (with Bluetooth Beacon devices); intelligent recommendations: automatically recommending nearby scenic spots based on location; rich content: providing various formats such as text descriptions, images, and audio guides; interactive experience: supporting interactive functions such as AR displays and 3D model viewing; route planning: providing navigation guidance to the target scenic spot; and seamless experience: no need to download the full application, simply scan the code to use.

[0044] According to the inventor's research, user satisfaction is high, with 92% of users finding the experience satisfactory; user engagement time has increased: the average time spent at each attraction has increased from 1 minute to 4.5 minutes; coverage is also high, with usage increasing by 300% compared to traditional signboards; and conversion rates have improved, with 35% of users choosing to download the full application after using it.

[0045] According to the target mini-program provided in the embodiments of this application, the size of the target engine is made smaller than the target size threshold by customizing the target engine, which solves the problem that cross-platform frameworks are difficult to adapt to App Clips. When the target mini-program is launched, the target functional module corresponding to the target scenario is determined, thereby providing users with real-time information corresponding to the target scenario. It is applicable to scenarios such as scenic spots that need to provide real-time information services, thus broadening the applicable scenarios.

[0046] In some embodiments, the standard Flutter engine can be trimmed in at least one of the following ways: Remove the just-in-time compiler, development debugging tools, and reflection functionality from the Dart virtual machine, while retaining the pre-compiled mode; Remove the 3D rendering function from the Skia rendering engine and reduce the number of image formats supported by the Skia rendering engine; Remove components used in the Flutter framework layer that have a frequency below a preset frequency threshold; Use the -Oz compilation optimization flag and enable link-time optimization and dead code elimination.

[0047] In this embodiment, the Dart virtual machine is the core runtime environment for the Dart language and one of the underlying execution engines of Flutter.

[0048] Just-in-Time (JIT) compilers are technologies that compile code into machine code only at runtime.

[0049] Reflection allows a program to analyze or modify its own structure at runtime.

[0050] The Advanced Over-the-Air (AOT) model compiles all code into efficient machine code before the application is released.

[0051] The Dart virtual machine can be streamlined in several ways. For example, the JIT (Just-In-Time) compilation mode can be removed, leaving only the AOT (Ahead-of-Time) compilation mode; development and debugging tools, such as the Observatory performance analysis tool and debugging protocol, can be removed; the garbage collection mechanism can be simplified, adopting a more lightweight GC strategy; and reflection and mirroring APIs can be removed.

[0052] By performing the above simplification steps, the size of the Dart virtual machine can be reduced from approximately 8MB to approximately 3MB.

[0053] Skia rendering engine is the underlying 2D graphics library for Flutter used to draw all UI elements (text, shapes, and images).

[0054] The Skia rendering engine can be optimized. For example, 3D rendering functionality can be removed, leaving only 2D graphics rendering capabilities; image format support can be simplified, retaining only the three commonly used formats: PNG, JPEG, and WebP; the font rendering engine can be simplified, using the system font service; and complex graphic effects and filter functions can be removed.

[0055] Through the above optimizations, the size of the Skia engine can be reduced from approximately 5MB to approximately 2MB.

[0056] The Flutter framework layer provides a vast codebase of ready-made UI components (widgets), such as Material Design (Android style) and Cupertino (iOS style) component libraries.

[0057] The frequency of component usage is the probability of each UI component being used in a specific application such as the target mini-program.

[0058] The preset frequency threshold is a pre-defined percentage value (such as 70% or 75%). Components with a usage rate higher than the preset frequency threshold are considered "frequently used" and retained; components with a usage rate lower than the preset frequency threshold are considered "low-frequency" and deleted.

[0059] The Framework layer can be streamlined. For example, the frequency of Widget usage can be analyzed, and commonly used components with a usage rate of over 70% can be retained; low-frequency components in the Material and Cupertino design libraries can be removed; the animation system can be streamlined, retaining only basic tween animations; and full internationalization support can be removed, adopting an on-demand language pack loading approach.

[0060] Through the above simplification, the size of the Framework can be reduced from approximately 4MB to approximately 1.5MB.

[0061] The -Oz compiler optimization flag is an optimization level option provided by the compiler. -Oz means "extremely optimized size", which can compress the size of binary code to the extreme.

[0062] Link-time optimization (LTO) is a global analysis and optimization performed across multiple code files in the final stage of compilation (linking stage). It can discover and eliminate more redundant code across files, further reducing the size and potentially improving runtime efficiency.

[0063] Dead code elimination is the compiler's automatic identification and removal of code that will never be executed in any possible execution path.

[0064] It allows for compilation optimization configurations, such as using the -Oz compilation optimization flag to prioritize size over speed; enabling symbol stripping to remove debugging information; enabling link-time optimization (LTO) for cross-module optimization; enabling dead code elimination to automatically delete unused code; and using the high-compression-ratio LZMA algorithm to compress resources.

[0065] Through the above comprehensive optimizations, the size of the Flutter engine can be reduced from the standard 25MB to about 3.5MB, leaving ample space for application code and resources.

[0066] In some embodiments, application resources can be compressed and optimized, and unused resources and dependencies can be removed to reduce the overall size of the application package.

[0067] For example, image resources can be optimized based on the following steps: convert all images to WebP format, which can reduce the size by 30-50% compared to PNG; perform lossy compression on the images, setting the quality to 85%; remove unused image resources; use an appropriate resolution to avoid excessively high resolution that would result in excessively large files; and keep the size of individual images below 500KB.

[0068] Font resources can be streamlined by following these steps: include only the commonly used simplified Chinese character set (approximately 3500 characters); remove unnecessary characters such as traditional Chinese, Japanese, and Korean; use font subsetation technology to streamline font files; and prioritize the use of system fonts to reduce the use of custom fonts.

[0069] Audio and video resources can be processed based on the following steps: audio can be in AAC format with a bitrate of 64kbps (voice) or 128kbps (music); video is not packaged in the application but dynamically loaded over the network; necessary audio files are compressed.

[0070] Code resource optimization can be performed based on the following steps: remove unused third-party libraries and dependencies; simplify logging output code; merge duplicate functional code; and reduce code size using code obfuscation.

[0071] In this application, the target engine is obtained by trimming the standard Flutter engine and retaining the functions required to run the target mini-program. This allows the size of the Clip application to be controlled within the target size threshold while maintaining the integrity of the application functions. This enables the target engine to meet the code limitations of APP Clip, while ensuring the integrity of the application functions and the user experience.

[0072] In some embodiments, the triggering event can be obtained through the following steps: Receive the user's first input on the user terminal where the target mini-program is deployed; In response to the first input, a trigger event is generated.

[0073] In this embodiment, the user terminal can be the user's mobile device, such as a smartphone or tablet.

[0074] The user terminal is a mobile phone that has the APP Clip installed or can load the target mini-program in a timely manner.

[0075] The target mini-program can exist on the terminal in some form, such as pre-installed or system-level support like APP Clip, or it may be cloud-ready.

[0076] The hardware (such as cameras and touchscreens) and operating system of the user terminal can receive the user's initial input.

[0077] In some embodiments, receiving first input from a user on a user terminal on which the target mini-program is deployed may include: Receive image information corresponding to the graphic code captured by the camera set on the user terminal.

[0078] In this embodiment, the graphic code can be a QR code, and the user terminal can include a camera. The user can use the camera to scan the QR code to achieve the first input.

[0079] In some embodiments, receiving first input from a user on a user terminal on which the target mini-program is deployed may include: It receives sensing signals generated by the Near Field Communication (NFC) module located in the user terminal.

[0080] In this embodiment, the sensing signal is generated when the user terminal touches the target object.

[0081] The target object can be an NFC tag in the scenic area, another NFC terminal, or a specific physical contact point.

[0082] For example, the first input can be achieved by the user touching the NFC tag with their user terminal.

[0083] Alternatively, the first input can be implemented in other ways, which are not limited in this application.

[0084] In response to the first input, the raw hardware signal can be converted into an internal software event containing semantic information, i.e., a trigger event.

[0085] The triggering event can be a structured message or a signal.

[0086] In actual implementation, for example, when the target scenario is a scenic spot, a QR code can be generated for each attraction. The QR code links to a specific module of the Clip application. When a user scans the QR code, the Clip application can provide relevant scenic spot information and interactive experiences.

[0087] The QR code can encode the following information: Scenic Area ID, a unique identifier for the scenic area; Spot ID, a unique identifier for the specific spot; Module ID, used to specify which content module to load; Version, the content version used for cache management; Location, such as the latitude and longitude coordinates of the spot; Timestamp, the time the QR code was generated; Signature, a digital signature to prevent forgery; and Extra information, which are optional additional parameters, such as language settings.

[0088] The information encoded in the QR code can be organized into JSON format, and binary encoding can be used with MessagePack to save space; Base64 encoding can be performed to convert it into a URL-safe string; a custom URLScheme prefix can be added, such as scenic: / / spot?data=xxx; and a QR code image can be generated with the error correction level set to H (30% error tolerance).

[0089] It can integrate with the system's camera API to request camera permissions to scan QR codes. It uses a high-performance QR code recognition library (such as ZXing) to process camera preview frames in real time, detect QR codes, and provide vibration feedback to the user upon successful recognition. Then, it parses the QR code data and verifies the signature validity (where the HMAC-SHA256 algorithm can be used to generate a digital signature, the key is stored securely on the server side, and the signature is verified on the client side). It can also check the timestamp and reject expired QR codes (more than 30 days old) to prevent the QR codes from being reused.

[0090] In some embodiments, it can be verified whether the user's location matches the QR code's location to prevent the QR code from being used in a different location.

[0091] In some embodiments, the QR code can be updated and expire periodically.

[0092] In some embodiments, the triggering event can be obtained through the following steps: When the location information of a user terminal with the target mini-program deployed is detected and it is within the preset location range corresponding to the target scene, a trigger event is generated.

[0093] In this embodiment, the location data of the user terminal obtained by GPS positioning technology, Wi-Fi positioning technology and Bluetooth Beacon positioning technology can be acquired separately, and then the location data of each positioning data can be merged to obtain the location information of the user terminal.

[0094] The GPS positioning accuracy is 5-10 meters in outdoor environments, making it suitable for open scenic areas. It can use the iOS CoreLocation framework and set appropriate accuracy requirements (kCLLocationAccuracyBest) to handle situations with weak GPS signals.

[0095] Wi-Fi positioning is usable both indoors and outdoors, with an accuracy of 10-50 meters. It can scan for surrounding Wi-Fi hotspots, query the hotspot location database, and then calculate the positioning data through trilateration.

[0096] Bluetooth Beacon positioning is suitable for high-precision indoor positioning with an accuracy of 1-5 meters. Bluetooth Beacon devices can be deployed in scenic areas to estimate distance based on signal strength (RSSI). Trilateration or fingerprint matching can be used for positioning.

[0097] In some embodiments, base station positioning can also be used with an accuracy of 100-1000 meters. For example, when other positioning methods are not available, base station positioning can be used to provide coarse location information.

[0098] The Kalman filter algorithm can be used to fuse data from multiple positioning sources. Weights can be assigned based on the accuracy of each positioning source. For example, higher weights can be assigned to data from positioning sources with higher accuracy, and lower weights can be assigned to data from positioning sources with lower accuracy.

[0099] It can filter out abnormal positioning data points, smooth the position trajectory, avoid jumps, and then output the fused high-precision position, that is, the position information of the user terminal.

[0100] A database of scenic spot locations can be pre-established to store the location and range of each scenic spot. The system can query the nearest scenic spot based on the user's terminal location information (e.g., using geospatial indexing) and determine whether the user (user terminal) is within the preset location range of the scenic spot (e.g., the preset location range can be set to a range with a radius of 50-200 meters centered on the scenic spot). It supports geofencing and automatically pushes information when it detects that the user has entered the scenic spot (e.g., it can send a text message containing a link to the user terminal, and after the user clicks the link, the real-time information can be displayed on the user terminal). It can also perform location prediction and prepare content about scenic spots that the user may visit in advance.

[0101] By obtaining the user's current location, real-time information such as introductions to relevant attractions, map navigation, and interactive content can be displayed based on the location.

[0102] For example, it can display an overall map of the scenic area and mark the location of each attraction; it can display the user's current location and orientation; it can provide route planning functions to calculate the route to the target attraction; it can support walking navigation and update the location and direction in real time; and it can mark scenic area facilities (restrooms, restaurants, and exits, etc.).

[0103] In some embodiments, step 110 may further include: Based on the target scenario, determine the user needs corresponding to at least one sub-scenario under the target scenario; The target functional module corresponding to the user's needs is determined from multiple candidate functional modules, and each candidate functional module is independent of the others.

[0104] In this embodiment, a sub-scene is a smaller unit within the target scene that has different attributes and may correspond to different user needs.

[0105] For example, when the target scene is the Forbidden City, sub-scenes can be divided by function, such as "Hall of Supreme Harmony Historical Explanation Area", "Imperial Garden Tour Route Area" and "Artifact AR Interaction Area"; by user attributes, sub-scenes can be divided by user attributes, such as "Adult In-Depth Tour Mode", "Parent-Child Fun Guided Tour Mode" and "Expert Academic Mode"; and by time / event, sub-scenes can be divided by time, such as "Daily Opening Hours", "During Specific Exhibitions", and "Nighttime Light Show Hours".

[0106] User needs are used to characterize the type of information or service that a user is most likely to want to obtain in a specific sub-scenario.

[0107] Application functionality can be broken down into multiple independent Flutter modules (i.e., candidate function modules), each responsible for specific functions or content. For example, based on functional responsibility, application functionality can be divided into: attraction details module, audio guide module, and map navigation module, etc.; based on content area, such as different attractions having their own modules; based on usage frequency, high-frequency functions can be packaged in the main application, while low-frequency functions can be separated into independent modules; based on control module size, individual modules can be set between 1-5MB for easy and fast download.

[0108] Each functional module is independent of the others, self-contained, and has clear boundaries. It can run without depending on the internal code of other modules; and individual modules can be developed, tested, deployed, and updated independently without affecting other modules.

[0109] When the application starts, the server can dynamically download and load modules and their resources. For example, a module list can be obtained, which can be used to represent the correspondence between candidate functional modules and user requirements. Based on user requirements, the target functional module corresponding to the user requirements can be determined from the module list.

[0110] In some embodiments, candidate functional modules may include at least one of the following: UI component definitions, business logic code, data models, resource files, routing configurations, and module manifest files.

[0111] In this embodiment, the UI component defines the Widget structure to represent the user interface; the business logic code is used to handle user interaction and data operations; the data model is used to define data structures and serialization methods; the resource file is a dedicated resource for this module, such as images and audio; the routing configuration is used to define page navigation within the module; and the module manifest file is used to describe the module's metadata (ID, version, and dependencies, etc.).

[0112] In some embodiments, the candidate functional modules have standardized lifecycle interfaces and communication interfaces.

[0113] In this embodiment, candidate functional modules can communicate through a unified interface. For example, standard module lifecycle interfaces (initialization, startup, pause, and destruction, etc.) can be defined, and inter-module communication can be implemented using an event bus mechanism. Common services can be shared through the service locator pattern to avoid direct dependencies between modules and reduce coupling.

[0114] In some embodiments, loading a target functional module based on a target engine may include: Load the target functional module from the local cache space; or, The target functional module is loaded from the server, and the server connects to the user terminal where the target mini-program is deployed.

[0115] In this embodiment, modules and their resources can be dynamically downloaded and loaded from the server, data transmission can be performed using HTTP requests or other network protocols, and downloaded content can be cached locally to improve performance.

[0116] When the application starts, it can obtain a list of modules from the server, determine the modules to be loaded (target functional modules) based on user actions (such as scanning QR codes), and check whether the target functional modules have been cached in the local cache space. If the target functional modules have been cached and the versions match, they can be used directly.

[0117] If the target functional module is not cached in the local cache space or the version is outdated, the module file can be downloaded from the CDN (Content Delivery Network) server. Progress prompts are displayed during the download process, and cancellation is supported. After the download is completed, the file integrity can be verified (e.g., SHA-256 can be used to verify file integrity). The module file can be unzipped to the application's Documents directory, and the local module index database can be updated.

[0118] Network transmission optimization can be achieved through the following steps: ensuring transmission security using the HTTPS protocol; supporting breakpoint resumption, allowing data to resume from the point of interruption; compressing transmitted data using compression algorithms such as gzip or br; using CDN acceleration and selecting the node closest to the user; implementing a failure retry mechanism, with a maximum of 3 retries (or other numbers, not limited by this application); and adjusting the timeout period according to network conditions (e.g., 30 seconds under Wi-Fi, 60 seconds under 4G).

[0119] A three-level caching mechanism can be established: L1 memory cache, used to store currently used module data for the fastest access; L2 disk cache, used to store recently used modules for persistent storage; and L3 remote cache, used to store the complete module library on the server.

[0120] The LRU (Least Recently Used) algorithm can be used to manage cache space, and a total cache limit can be set (e.g., 200MB). Once the limit is exceeded, the cache will be automatically cleaned up. Cache files can be named using module ID and version number to avoid conflicts. Expired caches (e.g., those that have not been used for more than 30 days) can be cleaned up periodically.

[0121] Module version management can be performed using the following steps: using semantic version numbers (such as 1.2.3) to identify module versions; supporting incremental updates of modules, downloading only the changed parts; maintaining a module dependency graph on the server side; automatically checking for module updates on the client side and prompting users to upgrade; retaining the previous version of the module and supporting rollback operations.

[0122] In some embodiments, Flutter’s dynamic routing system can be used to manage the loading and display of modules, ensuring that users can seamlessly switch between and access different functional modules.

[0123] In this embodiment, a route registration mechanism can be set up: the main application maintains a global route table; after the module is loaded, it dynamically registers the routes it contains; it uses named routing, such as " / scenic / spot / detail"; it supports passing route parameters, such as carrying the attraction ID; the route table supports priority settings and handles route conflicts.

[0124] Controlling page navigation: Implementing a unified navigation interceptor to handle permission verification; supporting page jump animations to provide smooth transition effects; implementing page stack management to support back and forward operations; handling deep links to support external jumps; and implementing page preloading to prepare data for the next page in advance.

[0125] Configure lazy loading for modules: load modules only when they are first used, instead of loading them all when the application starts; implement loading placeholder pages and display loading progress; preload modules that users may access in the background; unload modules that have not been used for a long time to free up memory; monitor module usage and optimize loading strategies.

[0126] In this application, by designing a modular architecture, the functions are split into independent modules, realizing network download and local caching of modules, and realizing dynamic loading of application function modules. This allows users to dynamically download and load function modules from the server when needed, and only download the content that users need, saving traffic and time, and realizing on-demand loading. It can support an unlimited number of attractions and functional modules. Content updates do not require redeploying the application; server-side updates are sufficient. Adding new attractions or functions only requires uploading the new module without modifying the main application, thus improving the application's flexibility and scalability.

[0127] According to the inventor's tests, the download time of a single module in this application is: an average of 2 seconds under Wi-Fi and an average of 5 seconds under 4G; the module loading success rate is >99%; the cache hit rate is: 90% of the content comes from the cache when visiting the same scenic spot for the second time; and the network traffic is saved: compared with the full application, about 70% of the traffic is saved.

[0128] In some embodiments, after outputting real-time information, the target mini-program can also be used for: If the triggering event is detected to have ended, delete the real-time information corresponding to the target scene.

[0129] In this embodiment, for actively triggered events, such as when the user clicks the close button or exits the mini-program, or when the information interface continues to display for more than a preset period of misoperation time, the trigger event can be determined to have ended.

[0130] For automatically triggered events, such as when a user leaves a preset geofence, or even if the user is still within the geofence but the service has been provided for a period of time (e.g., the complete audio explanation has finished playing) and there is no further interaction, the trigger event can be determined to end.

[0131] Upon detecting the end of the triggering event, the UI can be removed from the user terminal's screen, and the target functional module and its related data (such as code and resources) loaded for this service can be unloaded from memory and / or temporary storage.

[0132] It can delete temporary data generated during model execution, as well as memory and computing resources used during model execution.

[0133] In this application, upon detecting the end of the triggering event, the real-time information corresponding to the target scenario is deleted, ensuring efficient utilization of system resources and improving the user experience.

[0134] To ensure the streamlined Clip application and dynamic loading function run stably on different devices and environments, the Clip application can be comprehensively tested, such as functional testing, performance testing, compatibility testing, and stress testing.

[0135] Functional testing can be conducted in the following aspects: testing all functionalities of the application to ensure complete functionality after simplification; testing the download, installation, and loading processes of modules; testing the accuracy of QR code scanning and recognition; testing the accuracy and response speed of location services; testing degradation handling under network anomalies; and testing the effectiveness of the caching mechanism.

[0136] Performance testing can be conducted in the following aspects: test application startup time, target <2 seconds; test module loading time, target <5 seconds (under 4G network); test UI rendering performance, ensure smooth 60fps; test memory usage, control it within 80MB; test network traffic consumption; test battery consumption.

[0137] Compatibility testing can be conducted in the following ways: testing on different iOS versions (such as iOS 14, 15, and 16); testing on different devices (such as iPhone SE, iPhone 12, iPhone 13, and iPhone 14); testing in different network environments (Wi-Fi, 4G, 3G, and weak network); testing adaptation to different screen sizes; and testing landscape and portrait switching.

[0138] Stress testing can be conducted in the following ways: testing stability during long-term operation; testing scenarios involving frequent module switching; testing scenarios with a large number of users accessing the server simultaneously; testing extreme network conditions (packet loss and latency); and testing scenarios with insufficient storage space.

[0139] It can also collect user feedback to optimize the content and functions of the Clip app, thereby improving the user experience.

[0140] The feedback collection mechanism can be set up as follows: providing a feedback entry point within the application; collecting user ratings and reviews; recording user behavior data (page visits and function usage, etc.); monitoring anomaly and crash logs; and setting up user survey questionnaires.

[0141] Feedback data analysis can be conducted from the following aspects: analyze user usage paths to optimize feature layout; count feature usage frequency to determine optimization priorities; analyze loading failure rates to optimize network strategies; count user dwell time to evaluate content quality; and analyze churn rates to identify problem areas.

[0142] We can quickly fix bugs based on feedback, optimize slow-loading modules, improve features with poor user experience, adjust content display methods, and continuously optimize attractions and resources by updating them.

[0143] It allows for A / B testing of key functions, comparing the effectiveness of different solutions, selecting the optimal solution based on data, and continuously iterating and optimizing.

[0144] In this application, a single codebase can be reused across multiple scenic areas, reducing development costs; content updates are completed on the server side, eliminating the need for version releases and reducing maintenance costs; only QR code signs need to be deployed, resulting in low costs and reduced deployment costs; the content of real-time information can be adjusted according to seasons and events, providing greater operational flexibility; and user behavior data can be collected to optimize operational strategies.

[0145] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element. Furthermore, it should be noted that the scope of the methods and apparatuses in the embodiments of this application is not limited to performing functions in the order shown or discussed, but may also include performing functions substantially simultaneously or in the reverse order, depending on the functions involved. For example, the described methods may be performed in a different order than described, and various steps may be added, omitted, or combined. Additionally, features described with reference to certain examples may be combined in other examples.

[0146] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the related technology, can be embodied in the form of a computer software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal (which may be a mobile phone, computer, server, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0147] The embodiments of this application have been described above with reference to the accompanying drawings. However, this application is not limited to the specific embodiments described above. The specific embodiments described above are merely illustrative and not restrictive. Those skilled in the art can make many other forms under the guidance of this application without departing from the spirit and scope of the claims, and all of these forms are within the protection scope of this application.

[0148] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "illustrative embodiment," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0149] Although embodiments of this application have been shown and described, those skilled in the art will understand that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of this application, the scope of which is defined by the claims and their equivalents.

Claims

1. An object applet, characterized by, The target engine has a volume less than a target volume threshold, the target engine being obtained by cutting a standard Flutter engine to retain functions required for running the target applet; the target applet is used for: In the case where the target applet is started, a target function module is determined based on a trigger event in a target scene; The target function module is loaded and run based on the target engine to obtain instant information corresponding to the target scene; The instant information is output.

2. The target applet according to claim 1, wherein, The standard Flutter engine is cut in at least one of the following ways: The just-in-time compiler, development debugging tools, and reflection functions of the Dart virtual machine are deleted, and the pre-compiled mode is retained; The 3D rendering function of the Skia rendering engine is deleted, and the image formats supported by the Skia rendering engine are reduced; Components in the Flutter framework layer with a usage frequency lower than a preset frequency threshold are deleted; The -Oz compilation optimization flag is used, and link-time optimization and dead code elimination are enabled.

3. The target applet of claim 1, wherein, The trigger event is obtained by the following steps: Receiving a first input of a user to a user terminal on which the target applet is deployed; In response to the first input, the trigger event is generated.

4. The target applet of claim 3, wherein, The receiving of the first input of the user to the user terminal on which the target applet is deployed includes: Receiving image information corresponding to a graphical code collected by a camera provided on the user terminal; And / or, Receiving an induction signal generated by a near-field communication (NFC) module provided on the user terminal, the induction signal being generated when the user terminal touches a target object.

5. The target applet according to any one of claims 1 to 4, wherein, The trigger event is obtained by the following steps: In the case where the position information of the user terminal on which the target applet is deployed is detected to be within a preset position range corresponding to the target scene, the trigger event is generated.

6. The target applet according to any one of claims 1 to 4, wherein, The target function module is determined based on the trigger event in the target scene, including: Based on the target scene, a user demand corresponding to at least one sub-scene in the target scene is determined; From a plurality of candidate function modules, a target function module corresponding to the user demand is determined, and each candidate function module is independent of each other.

7. The target applet of claim 6, wherein, The candidate function module includes at least one of a UI component definition, business logic code, a data model, a resource file, a routing configuration, and a module manifest file.

8. The target applet of claim 6, wherein, The candidate function module has a standardized life cycle interface and a communication interface.

9. The target applet according to any one of claims 1 to 4, wherein, The target function module is loaded based on the target engine, including: The target function module is loaded from a local cache space; Or, The target function module is loaded from a server connected to the user terminal on which the target applet is deployed.

10. The target applet according to any one of claims 1 to 4, wherein, After the instant information is output, the target applet is further used for: In the case where the trigger event is detected to end, the instant information corresponding to the target scene is deleted.

Images