A method for generating a guide interface component and a related device

Abstract

The present invention provides a method for generating a guide interface component and related equipment, belonging to the field of information processing technology, realizing the addition and removal operations of guide interface components in different live broadcast rooms, and reducing the waste caused by the research and development of guide interface components. The method includes: defining a general protocol for creating a guide interface common component; creating and registering a guide interface common component according to the general protocol; receiving multiple sets of guide interface component creation parameters; parsing the multiple sets of guide interface component creation parameters based on the general protocol, and generating multiple different guide interface components through the guide interface common component according to the parsing results.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method for generating a guide interface component and a related device. Background Art

[0002] With the development of the live broadcast industry, the live broadcast industry has become more and more active, and bubbles often need to be added during the live broadcast process. Bubbles are a guidance solution added to the live broadcast room interface.

[0003] Currently, when adding bubbles to the live broadcast room, it is necessary to write a guide interface component program each time for different live broadcast rooms to adjust the priority of bubble display, bubble setting position, hierarchical addition operations, etc. The above operation process must be performed on the clients of various live broadcast rooms, which is a considerable development and testing burden, resulting in excessive workload for developing live broadcast room bubbles as guide interface components. Summary of the invention

[0004] The purpose of the present invention is to provide a method for optimizing bubbles in a live broadcast room, which alleviates the technical problem in the prior art that when bubbles are added to a live broadcast room, it is necessary to write priorities, set positions, and add levels each time for different live broadcast rooms.

[0005] In a first aspect, the present invention provides a method for generating a boot interface component, comprising the following steps: defining a general protocol for creating a boot interface common component; creating and registering a boot interface common component according to the general protocol; receiving multiple sets of boot interface component creation parameters, parsing the multiple sets of boot interface component creation parameters based on the general protocol, and generating multiple different boot interface components through the boot interface common component according to the parsing results.

[0006] Optionally, the above-mentioned creation and registration of the boot interface common component according to the above-mentioned general protocol also includes:

[0007] Obtaining an identity code of the above-mentioned common component of the guide interface, wherein the above-mentioned identity code is used to distinguish the common component of the guide interface from other functional components;

[0008] Save the above boot interface common components.

[0009] Optionally, the above-mentioned guiding interface component creation parameters are parsed based on the above-mentioned general protocol, and a plurality of different guiding interface components are generated through the above-mentioned guiding interface common components according to the parsing result, specifically including:

[0010] Based on the analysis result, the guide interface common component is registered on multiple platforms where the guide interface component needs to be created by calling the function [DYActManager registerCom:com], wherein DYActManager is a dynamic management program and registerCom:com is a functional statement for implementing the registration operation;

[0011] The analysis result is set in the guide interface common component to generate a guide interface component corresponding to each of the platforms.

[0012] Optionally, before receiving the guidance interface component creation parameter, the method further includes:

[0013] Determine whether there is a position in the boot interface component creation parameters that allows the boot interface component to be set;

[0014] If the boot interface component creation parameters contain a position that allows the boot interface component to be set, then receiving the boot interface component creation parameters;

[0015] If there is no position in the boot interface component creation parameters that allows the boot interface component to be set, the creation of the boot interface component is stopped.

[0016] Optionally, the above-mentioned parsing of the above-mentioned multiple groups of boot interface component creation parameters based on the above-mentioned general protocol, and generating multiple different boot interface components through the above-mentioned boot interface common components according to the parsing results, also includes:

[0017] Determine the type of platform for which the guide interface component needs to be created based on the above creation parameters;

[0018] The above-mentioned common components of the guide interface are set on the platform where the guide interface components need to be created.

[0019] Optionally, the above method further includes:

[0020] When creating and registering a common component of the boot interface according to the general protocol, a function function is used to limit the process of creating and registering the common component of the boot interface to be unique. The function function specifically implements the following functions when limiting the process of creating and registering the common component of the boot interface to be unique:

[0021] Creating a term token, wherein the term token represents the guide interface common component;

[0022] Restrict the process of creating said term token to be unique.

[0023] Optionally, before generating a plurality of different guide interface components, the method further includes:

[0024] The identification information of the guide interface component is created according to the identity identification code, wherein the identification information is used to find and / or remove the guide interface component.

[0025] The second aspect of an embodiment of the present application provides a device for generating a boot interface component, including: a protocol module: used to define a general protocol for creating a boot interface common component; a creation module: used to create and register a boot interface common component according to the above-mentioned general protocol; a data acquisition module: used to receive multiple sets of boot interface component creation parameters; a control module: used to parse the above-mentioned multiple sets of boot interface component creation parameters based on the above-mentioned general protocol, and generate multiple different boot interface components through the above-mentioned boot interface common component according to the parsing results.

[0026] The present invention provides a method for generating a guide interface component and a related device, which define a general protocol for creating a guide interface common component; create and register the guide interface common component according to the general protocol; the guide interface common component created according to the general protocol does not rely on the characteristics of the live broadcast room platform interface, and when facing different live broadcast room platform interfaces, the guide interface common component can be shared, reducing the workload of setting the guide interface component, and receiving multiple groups of guide interface component creation parameters; based on the general protocol, the multiple groups of guide interface component creation parameters are parsed, and multiple different guide interface components are generated through the guide interface common component according to the parsing results, so that after obtaining specific creation parameters, the created guide interface common component can adaptively generate multiple different guide interface components at one time according to different live broadcast room platform interfaces to adapt to the corresponding live broadcast platform interfaces, which solves the technical problem in the prior art that when bubbles are added to the live broadcast room, the corresponding code needs to be adaptively written each time when facing different live broadcast rooms, resulting in excessive workload, and improves the work efficiency of guide interface component creation. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] In order to more clearly illustrate the specific implementation methods of the present invention or the technical solutions in the prior art, the drawings required for use in the specific implementation methods or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some implementation methods of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0028] Figure 1 A comparison diagram of an existing method for generating a guide interface component and a method for generating a guide interface component provided by an embodiment of the present invention;

[0029] Figure 2 A flow chart of a method for generating a guide interface component provided by an embodiment of the present invention;

[0030] Figure 3A schematic diagram of an embodiment of a device for generating a guide interface component provided by an embodiment of the present invention;

[0031] Figure 4 A schematic diagram of an electronic device provided in an embodiment of the present application;

[0032] Figure 5 A schematic diagram of an embodiment of a computer-readable storage medium provided in an embodiment of the present application. DETAILED DESCRIPTION

[0033] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution of the present invention will be clearly and completely described below in conjunction with the accompanying drawings. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0034] The terms "including" and "having" and any variations thereof mentioned in the embodiments of the present invention are intended to cover non-exclusive inclusions. For example, a process, method, system, product or device including a series of steps or units is not limited to the listed steps or units, but may optionally include other steps or units that are not listed, or may optionally include other steps or units that are inherent to these processes, methods, products or devices.

[0035] like Figure 1 As shown, the generation method of the guide interface component in the prior art requires operations such as writing priorities, setting positions, iphonx adaptation, and adding levels. When adding bubbles in different live broadcast rooms, the above operations such as writing priorities, setting positions, iphonx adaptation, and adding levels need to be performed once in the half-screen live broadcast room, the appearance live broadcast room, the audio live broadcast room, the anchor's appearance, and the anchor's half-screen ports, which brings a heavy development and testing burden.

[0036] The method for generating a guide interface component provided by an embodiment of the present invention optimizes the process of generating a guide interface component through an activity framework, and replaces the above-mentioned operations such as writing priority, setting position, iphonx adaptation, and adding levels through code. In addition, the process of generating a guide interface component through code does not need to set the position and priority of the bubble later, but only needs to set the configuration of the above-mentioned code, thereby reducing the workload of generating a guide interface component, alleviating the workload of an internal processor, and further reducing the development and testing burden of generating a guide interface component.

[0037] like Figure 2 As shown, a method for generating a guide interface component provided by an embodiment of the present invention includes the following steps:

[0038] 101. Define a common protocol for creating common components of the boot interface;

[0039] In some examples, the general protocol defines a framework of an activity management class and requires implementation of container variables and information variables within the DYActComProtocol protocol.

[0040] The framework of the activity management class is defined within the general protocol. The activity management class is the basic reference data type. As the basic parent class, the activity management class has general properties, and further defines the general protocol for creating common components of the guide interface. After the common components of the guide interface are created, the above-mentioned common components of the guide interface do not depend on a specific live broadcast room, and the above-mentioned common components of the guide interface can be added and extracted on different live broadcast platforms.

[0041] 102. Create and register a boot interface public component according to the above general protocol;

[0042] In a possible implementation, the specific method for ensuring implementation of the container variable Container and the information variable Info in the DYActComProtocol protocol in the above-mentioned common component of the guidance interface is:

[0043] @synthesize compContainer=_compContainer;

[0044] @synthesize compInfo=_compInfo;

[0045] The above @synthesize compInfo is a functional statement to ensure the implementation of information variables in the protocol, and @synthesize compContainer is a functional statement to ensure the implementation of container variables in the protocol.

[0046] When creating and registering the boot interface public component according to the general protocol, a function function is used to limit the process of creating and registering the boot interface public component to be unique. The function function specifically implements the following functions when limiting the process of creating and registering the boot interface public component to be unique:

[0047] Create a term token, wherein the term token represents the common component of the guide interface;

[0048] Restrict the process of creating the above term token to be unique.

[0049] The above function creates a static term token; dispatch_once(&onceToken, ^{

[0050] Then use the memory allocation method to create a new component containing the above term token;

[0051] Call the function [DYActManagerregisterCom:com] to register the new component, where DYActManager is the dynamic management program and registerCom:com is the functional statement for implementing the registration operation.

[0052] Exemplarily, the above method for registering a new component is:

[0053] Register in the boxload method of each component and complete the registration through the function [DYBubbleComregistDYBubbleCom]. DYBubbleCom is the public component of the above boot interface, and registDYBubbleCom implements the registration of the public component of the above boot interface.

[0054] The above-mentioned creation and registration of the guide interface common component according to the general protocol also includes: obtaining the identity identification code of the above-mentioned guide interface common component, wherein the above-mentioned identity identification code is used to distinguish the guide interface common component from other functional components; and saving the above-mentioned guide interface common component.

[0055] To search for the new components, the client

[0056] (DYBubbleCom*)getDYBubbleCom

[0057] DYBubbleCom is the common component of the above-mentioned guide interface, and getDYBubbleCom realizes the search for the common component of the above-mentioned guide interface.

[0058] Method to obtain the identity code of the new component;

[0059] Set in the new component above

[0060] function return[DYActManager comForId:@"DYBubbleCom"]

[0061] Among them, DYActManager is a dynamic management program, comForId:@"DYBubbleCom" is a functional statement for searching in DYBubbleCom, and return is a feedback statement.

[0062] It is used to feed back the identity code of the new component to the client and save the new component.

[0063] 103. Receive multiple sets of boot interface component creation parameters;

[0064] 104. Parsing the plurality of sets of boot interface component creation parameters based on the general protocol, and generating a plurality of different boot interface components through the boot interface common component according to the parsing result. In a possible implementation, parsing the boot interface component creation parameters based on the general protocol, and generating a plurality of different boot interface components through the boot interface common component according to the parsing result, specifically includes:

[0065] The above analysis result is each set of creation parameters after analysis. Based on each set of creation parameters after analysis, the above guidance interface common components are registered respectively on multiple platforms where guidance interface components need to be created; each set of creation parameters after analysis is set in the above guidance interface common components to generate guidance interface components corresponding to each of the above platforms.

[0066] The guide interface components corresponding to different platforms are generated according to the creation parameters of different platforms, so that the generated guide interface components correspond to the above platforms, and further the generated guide interface components can be added on the corresponding platforms.

[0067] Before the above receiving the boot interface component creation parameter, it also includes:

[0068] Determine whether there is a position in the boot interface component creation parameters that allows the boot interface component to be set;

[0069] If the boot interface component creation parameters contain a position that allows the boot interface component to be set, then receiving the boot interface component creation parameters;

[0070] If there is no position in the boot interface component creation parameters that allows the boot interface component to be set, the creation of the boot interface component is stopped to avoid wasting memory resources and avoiding system crashes.

[0071] If there is a place to add the above boot interface components on the above platform, use the function:

[0072] [[DYBubbleComgetDYBubbleCom].compContaineractViewLayoutReadyWithKey:key view:view info:info]

[0073] Wherein, DYBubbleCom is the above-mentioned common component of the guide interface, Container is a container variable, and info is an information variable. The container variable and information variable of the above-mentioned common component of the guide interface are obtained, and the addition of the above-mentioned guide interface component on the above-mentioned platform is completed according to the above-mentioned container variable and information variable;

[0074] At the same time, you can add an interface for the above function to implement cross-platform calls of the above function. The above interface function is:

[0075] DYBActControllerInterface.

[0076] Add an interface removal method in the above interface, specifically:

[0077] (void)needRemoveActViewKey:(NSString*)key

[0078] (void)nemoveActViewKey is a function statement, (NSString*)key is a specific function statement for removing the key, and the above key value is the identification information of the guide interface component;

[0079] Through the function:

[0080] [[DYBubbleComgetDYBubbleCom].compContainer

[0081] needRemoveActViewKey:key]

[0082] .compContainer is the container variable of the above public guide interface.

[0083] needRemoveActViewKey:key is the function statement for removing the guide interface according to the key to realize the removal of the interface;

[0084] Creating identification information of a guide interface component according to the above-mentioned identity identification code, searching for the above-mentioned guide interface component according to the above-mentioned identification information and removing the above-mentioned guide interface component, specifically:

[0085] pass

[0086] DYBActControllerInterface, @selector(needRemoveActViewKey:), needRemoveActViewKey:kVoiceEffectTip)

[0087] method, wherein DYBubbleCom is the common component of the above-mentioned guide interface, @selector is the number of the class method, needRemoveActViewKey:kVoiceEffectTip) is the function code, which realizes the removal of the guide interface component. Only the generation of the above-mentioned guide interface component is set, and there is no need to set the container variable and information variable of the above-mentioned guide interface component separately, thereby reducing the workload in setting the guide interface component.

[0088] When the above-mentioned guide interface component builds the completed view, it needs to build a dictionary of values. The above-mentioned dictionary of values ​​is specifically:

[0089] NSDictionary*dic=@{@"pointType":@(1)}; where pointType is the point type and NSDictionary*dic is the dictionary assignment statement.

[0090] Use the interface calling method to determine the platform where the boot interface component needs to be added, specifically:

[0091] (DYBActControllerInterface,

[0092] @selector(actViewLayoutReadyWithKey:view:info:), actViewLayoutReadyWithKey:kVoiceEffectTip view:tipsView info:dic)

[0093] in,

[0094] DYBActControllerInterface is the added function of the interface.

[0095] @selector(actViewLayoutReadyWithKey:view:info:)

[0096] It is a functional statement for obtaining the basic information of the above-mentioned guide component, wherein the above-mentioned basic information includes: graphics and content, etc.

[0097] actViewLayoutReadyWithKey is the interface function that needs to be called.

[0098] actViewLayoutReadyWithKey:kVoiceEffectTip view:tipsView info:dic

[0099] It is based on the above basic information including graphics and content to finally implement the functional statement of calling the above new components.

[0100] Where dic is the dictionary of the passed value, and kVoiceEffectTip is the key value of the above guide interface component.

[0101] Determine the type of platform for which the guide interface component needs to be created based on the above creation parameters;

[0102] The above-mentioned common components of the guiding interface are set on the platform where the guiding interface components need to be created, and different guiding interface components are created according to different platform types.

[0103] This avoids the need to adaptively write corresponding codes every time facing different live broadcast rooms. It only needs to create the above-mentioned guide interface components according to the parameters of different live broadcast platforms to meet the operation of adding guide interface components in different live broadcast rooms.

[0104] The identification information of the guide interface component is generated according to the above-set identity code and the creation parameters. The above-mentioned identification information is the key value, and is set according to the above-mentioned key value and the above-mentioned creation parameters:

[0105] (void)actViewLayoutReadyWithKey:(NSString*)keyview:(UIView*)viewinfo:(NSDictionary*)info

[0106] In the above characters, key is the above identification information, view is the view that the component needs to create, and info is some configuration information, where the configuration information refers to container variables and information variables; (void)actViewLayoutReadyWithKey:(NSString*)keyview realizes the generation of the guide interface component graphics; (UIView*)view info:(NSDictionary*)info realizes the generation of the guide interface component information, and the generation process of the above guide interface component is encapsulated and saved. By calling the method of the above new component, the new component can operate on different live broadcast platforms, that is, it is possible to create guide interface components for multiple different live broadcast platforms, and obtaining the location of the guide interface component and adding the guide interface component are all set up without additional settings, avoiding the need to adaptively write corresponding code every time in different live broadcast rooms, resulting in technical problems such as excessive workload, and improving the work efficiency of creating guide interface components.

[0107] At the same time, if you need to remove the bubble, you only need to call one line of code:

[0108] DYBActControllerInterface,

[0109] @selector(needRemoveActViewKey:),needRemoveActViewKey:kVoiceEffectTip);

[0110] The above function can realize the removal of the guide interface component, @selector(needRemoveActViewKey:), needRemoveActViewKey:kVoiceEffect Tip); is a functional statement for removing bubbles according to the Key value. When the bubble needs to be removed, the above line of code can be used to implement it.

[0111] The general protocol for creating a guide interface public component is defined; the guide interface public component is created and registered according to the general protocol; the guide interface public component created according to the general protocol does not rely on the characteristics of the live broadcast platform interface. When facing different live broadcast platform interfaces, the guide interface public component can be shared, which reduces the workload of setting the guide interface component, and receives multiple sets of guide interface component creation parameters; the multiple sets of guide interface component creation parameters are parsed based on the general protocol, and multiple different guide interface components are generated through the guide interface public component according to the parsing results, so that after obtaining specific creation parameters, the created guide interface public component can adaptively generate multiple different guide interface components at one time according to different live broadcast platform interfaces to adapt to the corresponding live broadcast platform interfaces, which solves the technical problem in the prior art that when bubbles are added to the live broadcast room, the corresponding code needs to be adaptively written each time when facing different live broadcast rooms, resulting in excessive workload, and improves the work efficiency of guide interface component creation.

[0112] The above describes the guiding interface component method in the embodiment of the present application. The following describes the picture display device in the embodiment of the present application.

[0113] See also Figure 3 In one embodiment of the device for generating the guide interface component in the present application, the image display device includes:

[0114] 301. Protocol module: used to define the general protocol for creating common components of the boot interface;

[0115] 302. Create module: create and register the boot interface common component according to the above general protocol;

[0116] 303. Data collection module: receiving multiple sets of guide interface component creation parameters;

[0117] 304. Control module: Parse the plurality of guide interface component creation parameters based on the general protocol, and generate a plurality of different guide interface components through the guide interface common component according to the parsing result.

[0118] See also Figure 4 , Figure 4 A schematic diagram of an embodiment of an electronic device provided in an embodiment of the present application.

[0119] like Figure 4 As shown, the embodiment of the present application provides an electronic device, including a memory 410, a processor 420, and a computer program 411 stored in the memory 410 and executable on the processor 420. When the processor 420 executes the computer program 411, the following steps are implemented: defining a general protocol for creating a common component of a boot interface; creating and registering a common component of a boot interface according to the general protocol; receiving multiple sets of parameters for creating a common component of a boot interface; parsing the multiple sets of parameters for creating a common component of a boot interface based on the general protocol, and generating multiple different common components of a boot interface through the common component of a boot interface according to the parsing result.

[0120] Optionally, in a possible embodiment, the processor 420 is specifically used for: creating and registering the boot interface common component according to the general protocol, and also includes: obtaining an identity code of the boot interface common component, wherein the identity code is used to distinguish the boot interface common component from other functional components; and saving the boot interface common component.

[0121] Exemplarily, the new component is searched. Specifically, the client searches for the new component by

[0122] (DYBubbleCom*)getDYBubbleCom

[0123] Method to obtain the identity code of the new component;

[0124] Set in the new component above

[0125] function return[DYActManager comForId:@"DYBubbleCom"]

[0126] It is used to feed back the identity code of the new component to the client and save the new component.

[0127] Optionally, in a possible embodiment, the processor 420 is specifically used to: parse the boot interface component creation parameters based on the general protocol, and generate a plurality of different boot interface components through the boot interface common component according to the parsing result, specifically including:

[0128] The above parsing result is each set of creation parameters after parsing, and based on each set of creation parameters after parsing, the above guidance interface common component is registered on multiple platforms where the guidance interface component needs to be created; each set of creation parameters after parsing is set in the above guidance interface common component to generate a guidance interface component corresponding to each of the above platforms. Optionally, in a possible embodiment, the above processor 420 is specifically used to: before receiving the guidance interface component creation parameters, it also includes:

[0129] Determine whether there is a position in the boot interface component creation parameters that allows the boot interface component to be set;

[0130] If the boot interface component creation parameters contain a position that allows the boot interface component to be set, then receiving the boot interface component creation parameters;

[0131] If there is no position in the boot interface component creation parameters that allows the boot interface component to be set, the creation of the boot interface component is stopped.

[0132] If there is a place to add the above boot interface components on the above platform, use the function:

[0133] [[DYBubbleComgetDYBubbleCom].compContainer

[0134] actViewLayoutReadyWithKey:key view:view info:info]

[0135] Complete the addition of the above-mentioned guide interface components on the above-mentioned platform;

[0136] At the same time, add an interface for the above function to realize the cross-platform call of the above function. The above interface function is:

[0137] DYBActControllerInterface.

[0138] Add an interface removal method in the above interface, specifically:

[0139] (void)needRemoveActViewKey:(NSString*)key

[0140] The above key value is the identification information of the boot interface component;

[0141] Through the function:

[0142] [[DYBubbleComgetDYBubbleCom].compContainer

[0143] needRemoveActViewKey:key]

[0144] Implement the removal of the interface;

[0145] When the above-mentioned guide interface component builds the completed view, it needs to build a dictionary of values. The above-mentioned dictionary of values ​​is specifically:

[0146] NSDictionary*dic=@{@"pointType":@(1)}

[0147] Use the interface calling method to determine the platform where the boot interface component needs to be added, specifically:

[0148] (DYBActControllerInterface,

[0149] @selector(actViewLayoutReadyWithKey:view:info:), actViewLayoutReadyWithKey:kVoiceEffectTip view:tipsView info:dic)

[0150] in,

[0151] DYBActControllerInterface is the added function of the interface.

[0152] @selector(actViewLayoutReadyWithKey:view:info:), actViewLayoutReadyWithKey is the interface function that needs to be called.

[0153] actViewLayoutReadyWithKey:kVoiceEffectTip view:tipsView info:dic

[0154] This is the final method to call the above new components.

[0155] Where dic is the dictionary of the passed value, and kVoiceEffectTip is the key value of the above guide interface component.

[0156] Optionally, in a possible embodiment, the processor 420 is specifically used to: parse the multiple groups of boot interface component creation parameters based on the general protocol, generate multiple different boot interface components through the boot interface common component according to the parsing result, and further include:

[0157] Determine the type of platform for which the guide interface component needs to be created based on the above creation parameters;

[0158] The above-mentioned common components of the guide interface are set on the platform where the guide interface components need to be created.

[0159] Optionally, in a possible embodiment, the processor 420 is specifically configured to:

[0160] When creating and registering common components of the boot interface according to the above general protocol, use the following function to limit the process of creating and registering common components of the boot interface to be unique:

[0161] static dispatch_once_t onceToken;

[0162] dispatch_once(&onceToken, ^{

[0163] Where Token is a term token, tatic dispatch_once_t onceToken is used to create a static term token, and dispatch_once(&onceToken,^{ is used to ensure that the common components of the boot interface are created only once.

[0164] Exemplarily, when creating and registering the boot interface public component according to the above general protocol, use

[0165] function DYBubbleCom*com = [[DYBubbleCom alloc]init];

[0166] Make sure that the process of creating a new component is done only once.

[0167] Optionally, in a possible embodiment, the processor 420 is specifically configured to: before generating a plurality of different guide interface components, further include:

[0168] Creating identification information of a guide interface component according to the above-mentioned identity identification code, searching for the above-mentioned guide interface component according to the above-mentioned identification information and removing the above-mentioned guide interface component, specifically:

[0169] pass

[0170] DYBActControllerInterface, @selector(needRemoveActViewKey:), needRemoveActViewKey:kVoiceEffectTip)

[0171] The method realizes the removal of the guide interface component, only sets the generation of the guide interface component, and does not need to separately set the container variable and information variable of the guide interface component, thereby reducing the workload when setting the guide interface component.

[0172] like Figure 5 As shown, this embodiment provides a computer-readable storage medium 500, on which a computer program 511 is stored. When the computer program 511 is executed by a processor, the following steps are implemented: defining a general protocol for creating a common component of a boot interface; creating and registering a common component of a boot interface according to the general protocol; receiving multiple sets of creation parameters of the boot interface component; parsing the multiple sets of creation parameters of the boot interface component based on the general protocol, and generating multiple different boot interface components through the common component of the boot interface according to the parsing results.

[0173] Optionally, in a possible embodiment, when the computer program 511 is executed by the processor, it is specifically used to implement the following steps: When the computer program 511 is executed by the processor, it is specifically used to implement the following steps:

[0174] The above-mentioned creation and registration of the guide interface common component according to the general protocol also includes: obtaining the identity identification code of the above-mentioned guide interface common component, wherein the above-mentioned identity identification code is used to distinguish the guide interface common component from other functional components; and saving the above-mentioned guide interface common component.

[0175] Exemplarily, the new component is searched. Specifically, the client searches for the new component by

[0176] (DYBubbleCom*)getDYBubbleCom

[0177] Method to obtain the identity code of the new component;

[0178] Set in the new component above

[0179] function return[DYActManager comForId:@"DYBubbleCom"]

[0180] It is used to feed back the identity code of the new component to the client and save the new component.

[0181] Optionally, in a possible embodiment, the computer program 511 is specifically used to implement the following steps when executed by the processor: parsing the boot interface component creation parameters based on the general protocol, and generating multiple different boot interface components through the boot interface common components according to the parsing results, specifically including:

[0182] The above analysis result is each set of creation parameters after analysis. Based on each set of creation parameters after analysis, the above common components of the guide interface are registered on multiple platforms where the guide interface components need to be created; each set of creation parameters after analysis is set in the above common components of the guide interface to generate a guide interface component corresponding to each of the above platforms. For example,

[0183] Optionally, in a possible embodiment, the computer program 511 is specifically used to implement the following steps when executed by a processor: before receiving the guidance interface component creation parameter, it also includes:

[0184] Determine whether there is a position in the boot interface component creation parameters that allows the boot interface component to be set;

[0185] If the boot interface component creation parameters contain a position that allows the boot interface component to be set, then receiving the boot interface component creation parameters;

[0186] If there is no position in the boot interface component creation parameters that allows the boot interface component to be set, the creation of the boot interface component is stopped.

[0187] If there is a place to add the above boot interface components on the above platform, use the function:

[0188] [[DYBubbleComgetDYBubbleCom].compContainer

[0189] actViewLayoutReadyWithKey:key view:view info:info]

[0190] Complete the addition of the above-mentioned guide interface components on the above-mentioned platform;

[0191] At the same time, add an interface for the above function to realize the cross-platform call of the above function. The above interface function is:

[0192] DYBActControllerInterface.

[0193] Add an interface removal method in the above interface, specifically:

[0194] (void)needRemoveActViewKey:(NSString*)key

[0195] The above key value is the identification information of the boot interface component;

[0196] Through the function:

[0197] [[DYBubbleComgetDYBubbleCom].compContainer

[0198] needRemoveActViewKey:key]

[0199] Implement the removal of the interface;

[0200] When the above-mentioned guide interface component builds the completed view, it needs to build a dictionary of values. The above-mentioned dictionary of values ​​is specifically:

[0201] NSDictionary*dic=@{@"pointType":@(1)}

[0202] Use the interface calling method to determine the platform where the boot interface component needs to be added, specifically:

[0203] (DYBActControllerInterface,

[0204] @selector(actViewLayoutReadyWithKey:view:info:), actViewLayoutReadyWithKey:kVoiceEffectTip view:tipsView info:dic)

[0205] in,

[0206] DYBActControllerInterface is the added function of the interface.

[0207] @selector(actViewLayoutReadyWithKey:view:info:), actViewLayoutReadyWithKey is the interface function that needs to be called.

[0208] actViewLayoutReadyWithKey:kVoiceEffectTip view:tipsView info:dic

[0209] This is the final method to call the above new components.

[0210] Where dic is the dictionary of the passed value, and kVoiceEffectTip is the key value of the above guide interface component.

[0211] Optionally, in a possible embodiment, when the computer program 511 is executed by the processor, it is specifically used to implement the following steps: parsing the above-mentioned multiple groups of boot interface component creation parameters based on the above-mentioned general protocol, generating multiple different boot interface components through the above-mentioned boot interface common components according to the parsing results, and also including:

[0212] Determine the type of platform for which the guide interface component needs to be created based on the above creation parameters;

[0213] The above-mentioned common components of the guide interface are set on the platform where the guide interface components need to be created.

[0214] Optionally, in a possible embodiment, when the computer program 511 is executed by a processor, it is specifically used to implement the following steps:

[0215] When creating and registering common components of the boot interface according to the above general protocol, use the following function to limit the process of creating and registering common components of the boot interface to be unique:

[0216] static dispatch_once_t onceToken;

[0217] dispatch_once(&onceToken, ^{

[0218] Where Token is a term token, tatic dispatch_once_t onceToken is used to create a static term token, and dispatch_once(&onceToken,^{ is used to ensure that the common components of the boot interface are created only once.

[0219] Exemplarily, when creating and registering the boot interface public component according to the above general protocol, use

[0220] function DYBubbleCom*com = [[DYBubbleCom alloc]init];

[0221] Make sure that the process of creating a new component is done only once.

[0222] Optionally, in a possible embodiment, the computer program 511 is specifically used to implement the following steps when executed by a processor: before generating a plurality of different guide interface components through the guide interface common component according to the analysis result, it also includes:

[0223] Creating identification information of a guide interface component according to the above-mentioned identity identification code, searching for the above-mentioned guide interface component according to the above-mentioned identification information and removing the above-mentioned guide interface component, specifically:

[0224] pass

[0225] DYBActControllerInterface, @selector(needRemoveActViewKey:), needRemoveActViewKey:kVoiceEffectTip)

[0226] The method realizes the removal of the guide interface component, only sets the generation of the guide interface component, and does not need to separately set the container variable and information variable of the guide interface component, thereby reducing the workload when setting the guide interface component.

[0227] In several embodiments provided by the present invention, it should be understood that the disclosed devices and methods can also be implemented in other ways. The device embodiments described above are merely schematic. For example, the flowcharts and block diagrams in the accompanying drawings show the possible architecture, functions and operations of the devices, methods and computer program products according to multiple embodiments of the present invention. In this regard, each box in the flowchart or block diagram can represent a module, a program segment or a part of a code, and the above-mentioned module, a program segment or a part of a code contains one or more executable instructions for implementing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order from the order marked in the accompanying drawings. For example, two consecutive boxes can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flowchart, and the combination of boxes in the block diagram and / or flowchart can be implemented with a dedicated hardware-based system that performs a specified function or action, or can be implemented with a combination of dedicated hardware and computer instructions.

[0228] For another example, the division of the above units is only a logical function division, and there may be other division methods in actual implementation. For another example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some communication interface, device or unit, which can be electrical, mechanical or other forms.

[0229] The units described above as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0230] In addition, each functional unit in the embodiment provided by the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0231] If the above functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium, including several instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the above methods of each embodiment of the present invention. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM), random access memory (RAM), disk or optical disk, etc., various media that can store program codes.

[0232] It should be noted that similar numbers and letters represent similar items in the following figures. Therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures. In addition, the terms "first", "second", "third", etc. are only used to distinguish the description and are not to be understood as indicating or implying relative importance.

[0233] Finally, it should be noted that the above embodiments are only specific implementations of the present invention, which are used to illustrate the technical solutions of the present invention, rather than to limit them. The protection scope of the present invention is not limited thereto. Although the present invention is described in detail with reference to the above embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solutions recorded in the above embodiments within the technical scope disclosed by the present invention, or can easily think of changes, or make equivalent replacements for some of the technical features therein; and these modifications, changes or replacements do not make the essence of the corresponding technical solutions deviate from the scope of the technical solutions of the embodiments of the present invention. They should all be covered within the protection scope of the present invention. Therefore, the protection scope of the present invention shall be based on the protection scope of the claims.

Claims

1. A method for generating a guide interface component, characterized in that: The following steps are involved: Defines a common protocol for creating common components of the guide interface; Create and register the boot interface public component according to the general protocol; Receive multiple sets of boot interface component creation parameters; Parsing the plurality of groups of creation parameters of the guide interface components based on the general protocol, and generating a plurality of different guide interface components through the guide interface common component according to the parsing result; The step of creating and registering a common component of the guide interface according to the general protocol also includes: Obtaining an identity code of the guide interface common component, wherein the identity code is used to distinguish the guide interface common component from other functional components; Saving the common components of the guide interface; The step of parsing the creation parameters of the guide interface component based on the general protocol and generating a plurality of different guide interface components through the guide interface common component according to the parsing result specifically includes: Based on the analysis result, the guide interface common component is registered on multiple platforms where the guide interface component needs to be created by calling the function [DYActManager registerCom:com], wherein DYActManager is a dynamic management program, registerCom:com is a functional statement to implement the registration operation, and the registration is performed in the boxload method of each component, and the registration is completed by the function [DYBubbleCom registDYBubbleCom], DYBubbleCom is the above-mentioned guide interface common component, and registDYBubbleCom implements the registration of the above-mentioned guide interface common component; The parsing result is set in the common component of the guide interface to generate a guide interface component corresponding to each platform, wherein the parsing result is each group of creation parameters after parsing; Before receiving the boot interface component creation parameters, it also includes: Determine whether there is a position in the creation parameters of the guide interface component that allows the guide interface component to be set; If the guide interface component creation parameter contains a position that allows the guide interface component to be set, receiving the guide interface component creation parameter; If there is no position in the boot interface component creation parameters that allows the boot interface component to be set, then the creation of the boot interface component is stopped; The step of parsing the plurality of guide interface component creation parameters based on the general protocol and generating a plurality of different guide interface components through the guide interface common component according to the parsing result further includes: Determining the type of platform for which the guide interface component needs to be created according to the creation parameters; The guide interface common component is arranged on the platform where the guide interface component needs to be created; The method further comprises: When creating and registering a common component of the boot interface according to the general protocol, a function function is used to limit the process of creating and registering the common component of the boot interface to be unique. The function function specifically implements the following functions when limiting the process of creating and registering the common component of the boot interface to be unique: Creating a term token, wherein the term token represents the guide interface common component; The process of creating the term token is limited to be unique; the function creates a static term token; and a new component containing the term token is created using a memory allocation method; Before generating multiple different boot interface components, it also includes: The identification information of the guide interface component is created according to the identity identification code, wherein the identification information is used to find and / or remove the guide interface component.

2. An electronic device, comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor is used to implement the steps of the method for generating a guide interface component as claimed in claim 1 when executing the computer program stored in the memory.

3. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the method for generating a guide interface component according to claim 1 are implemented.

Images