CN117492823B

CN117492823B - Code acquisition method, device, electronic equipment and readable storage medium

Info

Publication number: CN117492823B
Application number: CN202311856975.XA
Authority: CN
Inventors: 郭凯锋; 林永吉; 黎清顾
Original assignee: Gree Electric Appliances Inc of Zhuhai; Zhuhai Lianyun Technology Co Ltd
Current assignee: Gree Electric Appliances Inc of Zhuhai; Zhuhai Lianyun Technology Co Ltd
Priority date: 2023-12-29
Filing date: 2023-12-29
Publication date: 2024-04-05
Anticipated expiration: 2043-12-29
Also published as: CN117492823A

Abstract

The application provides a code acquisition method, a code acquisition device, electronic equipment and a readable storage medium, wherein the method comprises the following steps: acquiring a target interface keyword, wherein the target interface keyword comprises part of characters in a target interface name, and the target interface name is the name of a target interface; determining a target interface corresponding to the target interface keyword according to the target interface keyword and the corresponding relation between the first interface keyword and the first interface; and extracting an object code corresponding to the object interface from a pre-constructed code library according to the object interface, wherein the pre-constructed code library comprises a plurality of codes, each code is provided with a corresponding second interface, and the object interface is one of the second interfaces. The method improves the efficiency of code acquisition.

Description

Code acquisition method, device, electronic equipment and readable storage medium

Technical Field

The application belongs to the technical field of computers, and particularly relates to a code acquisition method, a code acquisition device, electronic equipment and a readable storage medium.

Background

In the process of developing the system, a developer needs to determine the code adapted to the electronic equipment, and system development is performed based on the code adapted to the electronic equipment.

In the related art, in the system development process, codes required by a developer are acquired through a manual selection manner, and a system is developed based on the acquired codes.

According to the method in the related art, there is a problem in that the efficiency of acquiring codes is low, thereby resulting in low system development efficiency.

Disclosure of Invention

The application aims to provide a code acquisition method, a code acquisition device, electronic equipment and a readable storage medium, which at least solve the problem of low processing efficiency of acquiring codes in the prior art.

In a first aspect, an embodiment of the present application discloses a code acquisition method, where the method includes:

acquiring a target interface keyword, wherein the target interface keyword comprises part of characters in a target interface name, and the target interface name is the name of a target interface;

determining a target interface corresponding to the target interface keyword according to the target interface keyword and the corresponding relation between the first interface keyword and the first interface;

and extracting an object code corresponding to the object interface from a pre-constructed code library according to the object interface, wherein the pre-constructed code library comprises a plurality of codes, each code is provided with a corresponding second interface, and the object interface is one of the second interfaces.

In a second aspect, an embodiment of the present application discloses a code acquisition apparatus, the apparatus including:

the first acquisition module is used for acquiring a target interface keyword, wherein the target interface keyword comprises part of characters in a target interface name, and the target interface name is the name of a target interface;

the first determining module is used for determining a target interface corresponding to the target interface keyword according to the target interface keyword and the corresponding relation between the first interface keyword and the first interface;

the first extraction module is used for extracting target codes corresponding to the target interfaces from a pre-built code library according to the target interfaces, the pre-built code library comprises a plurality of codes, each code is provided with a corresponding second interface, and the target interfaces are one of the second interfaces.

In a third aspect, embodiments of the present application also disclose an electronic device comprising a processor and a memory storing a program or instructions executable on the processor, which when executed by the processor, implement the steps of the method as described in the first aspect.

In a fourth aspect, embodiments of the present application also disclose a readable storage medium having stored thereon a program or instructions which, when executed by a processor, implement the steps of the method as described in the first aspect.

In summary, in this embodiment, the target interface keyword is obtained, and according to the target interface keyword and the corresponding relationship between the first interface keyword and the first interface, the target interface may be quickly determined, and according to the target interface, the target code corresponding to the target interface may be quickly obtained from the pre-built code library. Compared with the method in the related art, the embodiment improves the efficiency of acquiring codes.

Drawings

In the drawings:

fig. 1 is a flowchart of steps of a code acquisition method provided in an embodiment of the present application;

FIG. 2 is a flowchart illustrating steps of another code acquisition method according to an embodiment of the present application;

FIG. 3 is a flowchart illustrating steps of a code acquisition method according to an embodiment of the present application;

FIG. 4 is a flowchart illustrating steps of a code acquisition method according to an embodiment of the present application;

FIG. 5 is a block diagram of a code acquisition apparatus provided by an embodiment of the present application;

FIG. 6 is a block diagram of an electronic device of one embodiment provided by embodiments of the present application;

fig. 7 is a block diagram of an electronic device of another embodiment provided by an embodiment of the present application.

Detailed Description

The following description of the embodiments of the present application will be made clearly and fully with reference to the accompanying drawings, in which it is evident that the embodiments described are some, but not all, of the embodiments of the present application. All other embodiments, which can be made by one of ordinary skill in the art based on the embodiments herein without making any inventive effort, are intended to be within the scope of the present application.

The terms first, second and the like in the description and in the claims, are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged, as appropriate, such that embodiments of the present application may be implemented in sequences other than those illustrated or described herein, and that the objects identified by "first," "second," etc. are generally of a type and not limited to the number of objects, e.g., the first object may be one or more. Furthermore, in the description and claims, "and/or" means at least one of the connected objects, and the character "/", generally means that the associated object is an "or" relationship.

Fig. 1 is a flowchart of steps of a code obtaining method provided in this embodiment, and referring to fig. 1, the method may include the following steps:

step 101, obtaining a target interface keyword.

Specifically, the target interface keyword includes a part of characters in a target interface name, and the target interface name is a name of the target interface.

For example, the execution body of the embodiment is a plug-in tool, and the target interface keyword is acquired through the plug-in tool in response to the operation of inputting the target interface keyword in the plug-in tool by a user, so that in a subsequent processing process, the target code is acquired according to the target interface keyword.

Wherein the target interface name may include a plurality of characters for the plug-in tool to determine the target interface from the target interface key by typing the target interface key in the plug-in tool.

Step 102, determining a target interface corresponding to the target interface keyword according to the target interface keyword and the corresponding relation between the first interface keyword and the first interface.

For example, the target interface keywords are compared with the first interface keywords in the corresponding relation, the first interface keywords matched with the target interface keywords are determined, and the first interfaces corresponding to the matched first interface keywords are determined to be target interfaces corresponding to the target interface keywords.

The first interface keyword has a corresponding first interface name, the first interface name is used for identifying a first interface corresponding to the first interface name, the first interface keyword matched with the target interface keyword is determined by comparing the target interface keyword with the first interface keyword in the corresponding relation, the first interface name corresponding to the first interface keyword matched with the target interface keyword is determined as the target interface name, and the interface identified by the target interface name is determined as the target interface.

And step 103, extracting the target code corresponding to the target interface from a pre-constructed code library according to the target interface.

Specifically, the pre-built code library comprises a plurality of codes, each code is provided with a corresponding second interface, and the target interface is one of the second interfaces.

Illustratively, the pre-built code library includes adaptation code, system source code. Wherein the adaptation code includes a function code extracted from the developer document and an interface code extracted from the interface document. Further, the developer document includes a plurality of function codes corresponding to the different functions, respectively, and the interface document has interface codes corresponding to the plurality of different interfaces, respectively. Further, the interface is used for realizing a preset function corresponding to the interface, and the function code is a code for describing the preset function realized by the interface.

The target interfaces are compared, and the second interfaces of each code in the pre-constructed code library are obtained, the second interfaces matched with the target interfaces are obtained, and the codes corresponding to the second interfaces matched with the target interfaces are determined to be target codes.

In summary, in this embodiment, the target interface keyword is obtained, and according to the target interface keyword and the corresponding relationship between the first interface keyword and the first interface, the target interface may be quickly determined, and according to the target interface, the target code corresponding to the target interface may be quickly obtained from the pre-built code library. Compared with a method for manually acquiring codes required by developers in the related art, the code acquisition efficiency is improved. In addition, in practical application, the name of the interface is generally longer, compared with the target interface name of the target interface, according to the method for determining the target code from the pre-constructed code library according to the target interface name, the embodiment obtains the target code from the pre-constructed code library based on the target interface key word formed by part of characters in the target interface name, thereby saving the time for obtaining the target code name and improving the efficiency of obtaining the target code.

Referring to fig. 2, the code acquisition method may further include the steps of:

step 201, a target interface keyword is obtained, where the target interface keyword includes a part of characters in a target interface name, and the target interface name is a name of the target interface.

The method of this step is described in the foregoing step 101, and will not be described here again.

Step 202, determining a target interface corresponding to the target interface keyword according to the target interface keyword and the corresponding relation between the first interface keyword and the first interface.

The method of this step is described in the foregoing step 102, and will not be described herein.

In one embodiment, the pre-built code library includes system source code for a plurality of different system versions, and the target interface includes an interface for extracting the system source code.

And 203, extracting system source codes comprising a plurality of different system versions from a pre-constructed code base according to the target interface.

Illustratively, the system source code in the pre-built code library may be system source code obtained from an open source code item (Android Open Source Project, AOSP) by web crawler technology.

For example, the system source code in the AOSP is the system source code of the system developer, after releasing the new version of the system, updating the old version of the system and uploading the AOSP. By way of example, the system source code may be system source code of an Android (Android) system.

Step 204, a target system version is obtained.

The target system version is, for example, a system version of a system that a user needs to use when developing a system for an electronic device.

In practical applications, the system developer updates the operating system, and the historical operating system before update and the current operating system after update have different system versions respectively.

Step 205, determining the target system source code from the system source codes of various different system versions according to the target system version, and determining the target system source code as the target code.

Illustratively, each system source code corresponds to a system version of the plurality of system source codes.

For example, the system versions of different system source codes and the target system version can be compared, the system version matched with the target system version is determined, and the system source code corresponding to the system version matched with the target system version is determined as the target system source code in the step.

Illustratively, the target system version has a corresponding target system version identification (e.g., version number), and the pre-built code library includes a system version of system source code having a corresponding system version identification (e.g., version number). And comparing the target system version identifier with the system version identifier, and determining the system version identifier matched with the target system version identifier, wherein the system version corresponding to the system version identifier is the system version matched with the target system version.

In one embodiment, the plugin tool displays system source codes of different system versions in the display module, and a user selects a target system version from among the system versions of the system source codes displayed by the display module and performs a selection operation. And the plug-in tool responds to the selection operation of the user and determines the source code of the target system corresponding to the version of the target system.

In summary, in this embodiment, a target interface keyword is acquired, according to the target interface keyword and a corresponding relationship between the first interface keyword and the first interface, a target interface may be quickly determined, according to the target interface, a system source code is extracted from a pre-constructed code library, and according to a target system version, a target system source code corresponding to the target system version may be quickly determined from a plurality of system source codes. Compared with the method in the related art, the embodiment improves the efficiency of acquiring codes.

In one embodiment, the pre-built code library includes interface codes of a plurality of different interface types, and the target interface includes an interface for extracting the interface codes.

After step 202, further comprising:

step 206, extracting interface codes comprising a plurality of different interface types from the pre-constructed code base according to the target interface.

Specifically, the interface code may include: interface code corresponding to the system that the developer needs to develop. Further, the interface code may include information such as configuration parameters of the interface.

Step 207, obtain the target interface type.

The target interface type is, for example, an interface type of an interface that a user needs to use when developing a system for an electronic device. Further, interfaces of different interface types are used to implement different functions.

And step 208, determining the target interface code from a plurality of interface codes with different interface types according to the target interface type, and determining the target interface code as the target code.

Illustratively, each interface code of the plurality of interface codes of the pre-built code library corresponds to one interface type.

For example, the interface types of different interface codes and the target interface type may be compared, the interface type matched with the target interface type is determined, and the interface code corresponding to the interface type is determined as the target interface code in the step.

In one embodiment, the plug-in tool displays interface codes of different interface types in the display module, and the user selects a target interface type from a plurality of interface types of the plurality of interface codes displayed in the display module and performs a selection operation. And the plug-in tool responds to the selection operation of the user and determines the target interface code corresponding to the target interface type.

In one embodiment, in the pre-constructed code library, a plurality of interface codes corresponding to the target interface type are provided, and each interface code corresponding to the target interface type has a corresponding interface version;

step 208 may include the following sub-steps:

a substep 2081, obtaining a target interface version;

the target interface version is, for example, an interface version that a user needs to use in developing a system for an electronic device.

Sub-step 2082 determines the target interface code corresponding to the target interface version from a plurality of interface codes corresponding to the target interface type.

For example, the system source code of the interface version corresponding to the target interface version can be determined as the target interface code in the step by comparing the interface versions of different system source codes and the target interface version.

In practical application, the system developer updates the interface, and the history interface before update and the current interface after update have different interface versions respectively. Correspondingly, a pre-constructed code base is obtained according to the updated interface data of the system developer, and the obtained pre-constructed code base comprises various interface codes corresponding to different interface versions.

In one embodiment, the plugin tool displays system source codes of different interface versions in the display module, and a user selects a target interface version from a plurality of interface versions of the plurality of interface source codes displayed by the display module and performs a selection operation. And the plug-in tool responds to the selection operation of the user and determines the target interface source code corresponding to the target interface version.

In one embodiment, the pre-built code library includes function codes of a plurality of different function types, and the target interface includes an interface for extracting the function codes;

after step 202, further comprising:

step 209, extracting the function codes including a plurality of different function types from the pre-constructed code library according to the target interface.

By way of example, the functional code may include: functional code corresponding to a system that the developer needs to develop.

Illustratively, by web crawler technology, a developer document uploaded by a developer of a system is crawled on an open source platform, wherein the developer document comprises a plurality of functional modules, and the functional modules comprise functional codes, description of the functional codes and other information. And extracting and storing the function codes from the developer document to obtain the function codes in the pre-constructed code library.

Step 210, obtain the target function type.

The target function type is, for example, a function type in which a user needs to use a function when developing a system for an electronic device.

The types of the function types may be various, and may include a photographing function, a rights setting function, or other function types, for example.

Step 211, determining a target function code from the function codes of a plurality of different function types according to the target function type, and determining the target function code as the target code.

Illustratively, each function code of the plurality of function codes of the pre-constructed code library corresponds to a function type. The function code is, for example, code describing the function of the interface.

For example, the function types of different function codes and the target function type may be compared, the function type corresponding to the target function type is determined, and the function code corresponding to the function type is determined as the target function code in the step.

In one embodiment, in the pre-constructed code library, a plurality of function codes corresponding to the target function type are provided, and each function code corresponding to the target function type has a corresponding function version;

Step 211 may comprise the following sub-steps:

sub-step 2111, obtaining a target function version;

the target function version is, for example, a function version that a user needs to use when developing a system for an electronic device.

In practical application, a system developer updates a developer document, and correspondingly, function codes in the developer document are correspondingly updated, wherein the history function codes before updating and the current function codes after updating respectively have different function versions. And acquiring function codes of different functional versions according to the updated developer document, and acquiring a pre-constructed code library based on the function codes of the different functional versions.

Sub-step 2112, determining a target function code corresponding to the target function version from a plurality of function codes corresponding to the target function type.

For example, the functional versions of different functional codes may be compared with the target functional version, the functional version corresponding to the target functional version is determined, and the functional code corresponding to the functional version is determined as the target functional code in this step.

In one embodiment, the plugin tool displays the function code of the different function versions in the display module, and the user selects the target function version from among the plurality of function versions of the function code displayed by the display module. And the plug-in tool responds to the selection operation of the user and determines the target function code corresponding to the target function version.

In one embodiment, the pre-built code library includes interface codes of a plurality of different device information, and functional codes of the different device information; the target interface includes an interface for extracting an interface code, and an interface for extracting a function code.

After step 202, further comprising:

step 212, extracting interface codes and function codes from the pre-constructed code base according to the target interface.

Illustratively, the interface code and the function code in the pre-built code library are extracted from the interface document and the developer document, respectively. Wherein the interface document and the developer document are obtained from an open source platform, the developer document comprising functional code.

Step 213, obtaining the target device information.

Illustratively, the target device information includes a manufacturer identification, device version, or other device information of the target device. Further, the target device is a device that the developer needs to perform system development, for example, the target device may be a mobile phone.

Step 214, determining the target interface code from the interface codes of the different device information according to the target device information, and determining the target function code from the function codes of the different device information.

For example, after the interface code and the function code are acquired, an adaptation code is generated according to the interface code and the function code, the adaptation code has corresponding equipment information, equipment information corresponding to the target equipment information is determined from the equipment information respectively corresponding to the plurality of adaptation codes according to the target equipment information, the adaptation code corresponding to the equipment information is determined to be the target adaptation code, and the interface code and the function code included in the target adaptation code are respectively determined to be the target interface code and the target function code in the step.

Illustratively, following step 212, further comprising:

step 215, obtain the developer's document, extract the function code from the developer's document.

The method comprises the steps of obtaining a developer document from an open source platform of the developer document uploaded by a system developer, and extracting functional codes from the developer document.

Step 216, an interface document is obtained, and an interface code is extracted from the interface document.

The method comprises the steps of obtaining an interface document from an open source platform of the interface document uploaded by a system developer, and extracting an interface code from the interface document.

Fig. 3 is a flowchart of steps of another code obtaining method according to an embodiment of the present invention, and referring to fig. 3, the method may include the following steps:

Step S11, a developer document and an interface document are acquired, and initial adaptation codes developed by the system are acquired according to the developer document and the interface document.

Illustratively, the developer document and the interface document are different documents. Specifically, the developer document is used for guiding a system development user to develop the system and guiding the use method of each function in the system. The interface document is used to expose all API interfaces in the system.

Specifically, after a new system is released, a system developer updates a new version of the software development kit. For example, after a new Android (Android) system is released, a software development kit (Android Software Development Kit, android SDK) of the Android system is updated, and development characteristics and related parameters of the new version of the Android system are updated to a developer document of the old version.

The developer document is used for guiding a user to adaptively release the system in the system development process, and relevant modifications are updated on the interface document.

For example, the developer document may be obtained from the open source developer document by internet crawler technology, and the developer document is taken as the local document.

The developer document is reorganized according to the function of the function code in the developer document. Specifically, in the web document of the developer document, each page corresponds to a function module for realizing the corresponding function. The developer document has a catalog including a catalog of functional modules. After the developer document is obtained, the different functional modules in the developer document are organized at a page level according to a catalog, wherein each page of document has a corresponding title, which may include, for example, a functional description of the corresponding page document. Further, a title of each page is acquired, and a title paragraph is generated from a plurality of titles.

Reorganizing the developer document includes: functional modules related to functions are organized together and classified according to functions. The function module has corresponding function codes for realizing different functions, such as a photographing function, a permission setting function, a file storage function, and the like.

In practical applications, the system developer may update the function codes of the important functions, which may be the function codes for setting the rights, the function codes for storing the files, or other function codes for implementing the important functions.

Because the function code is updated in actual application, it is necessary to determine suitability of the function code in an electronic device using the development system when system development is performed based on the function code in the developer document.

After updating the function codes, there may be different function code versions of the same function type, and the function codes may be ordered in the order from high version to low version, so that in the subsequent processing process, the target function code corresponding to the target function code version is determined according to the ordering result.

By way of example, the interface document may be an Android API document. And after the Android API document is acquired and the Android API document is local through a crawler technology, the Android API document can be reorganized.

For example, after the system developer issues a new version of the Android system, some new version of the API interfaces are added, and the old version of the API interfaces are deactivated. Therefore, after the new version of the Android system is released, different interface versions exist in the same interface code in the Android API document.

The interface codes in the Android API document can be sequenced according to the sequence of the interface versions from high to low, so that in the subsequent processing process, the target interface code is determined from the sequenced interface codes according to the target interface version.

And sequencing the function codes according to the function and the function code version, and sequencing the interface codes according to the interface code version to obtain the function documents and the interface documents classified according to the function and the system version. And converting the function document and the interface document into an adaptation code of a system development, wherein the system development can be an Android system.

Illustratively, updating the developer document and the interface document includes: and comparing the documents of the same target sub page in different document versions, and when determining that the document contents of the same sub page are different, carrying out version marking on the document directory sub page and putting the documents of the same sub page together for updating the subsequent reference document.

Illustratively, the developer document includes function codes, the interface document includes interface codes, and the function codes and the interface codes are extracted to obtain the adaptation codes.

Further, the adaptive code obtained after extracting the function code and the interface code does not include the function description. In actual application, the functional code and interface code may be extracted into an integrated development environment (Integrated Development Environment, IDE) integrated development tool and the adapted code uploaded into a software project hosting platform (GitHub).

And S12, acquiring system source codes.

After a system developer issues a new version of the system (for example, an Android system), an Android AOSP is updated, and system source codes of the new version of the Android system are updated in the AOSP.

And downloading the Android system source codes of each generation, comparing the Android system source codes of each generation by using a code comparison tool, recording the differences among the Android system source codes of each generation, and generating a code update document of the Android system source codes according to the differences.

In the system development process, when developing a system strong association project, the system source code can be used for a system developer to perform better system development and system adaptation so as to ensure that errors caused by system updating are avoided when the system strong association interface is developed.

For example, a distributed version control system (Git) with an open source may be used to download system source codes, and the Git is used to compare codes of different branches in different versions of system source codes, and according to the comparison result, an updated portion of the system source codes is determined.

When the system strong association project is developed, the updating part of the system source code can be determined according to the system source code document, and then the updating part is directly transplanted into the application to be developed without comparing the code in the application to be developed with the updated system source code.

Step S13, acquiring the adapting codes of the plurality of device information.

Electronic devices (e.g., mobile phones) of no manufacturer have Read Only Memory (ROM) corresponding to respective device information, and operating systems corresponding to respective device information. For some operating systems in early development, the documents of developers are not perfect, and the operating systems cannot be applied when a problem occurs. However, for the same developer document, the method cannot be applied to all electronic devices with device information, when the problem that the system is incompatible with the electronic devices is encountered in the actual system development process, the developer document is modified, and then the modified developer document is updated to a compatibility document corresponding to the electronic device information and an adaptation code of the system. The developer updates the encountered problems and solutions into the adaptive code, and after the verification is passed, the adaptive code is updated into the adaptive code developed by the system.

Illustratively, the developer submits a merge code application in the Github, which merges the submitted code and document into the adapted code of the Github after the audit passes.

Specifically, an example code (demo) for suitability verification may be obtained, the demo including an error capture module and a network upload interface. When uploading codes, a developer needs to download the demo, then the codes to be submitted are imported into an error capturing module of the demo, branch numbers for uploading the adaptive codes are filled in, then the demo is operated to an electronic device which needs to be subjected to system development, and the error capturing module of the demo is operated in the electronic device.

Further, the demo has no relation with the system source code, the developer document or the API document, and the demo only verifies the adapting code; the demo code is uploaded on the GutHub, and when a developer submits a merged code application in the GitHub, the merged code can be downloaded to the demo code.

If the error capturing module identifies that the code runs incorrectly, the network interface in the demo does not upload the adaptive code, if the error capturing module identifies that the code runs successfully, the adaptive code, a manufacturer identification corresponding to the adaptive code, a system version, a branch number of the adaptive code to be uploaded and an information uploading server of successful running, the server of the Github receives information of successful uploading, the branch number is matched with the branch number submitted and combined in the Github, the system version and the manufacturer identification are matched, if the branch number, the system version and the manufacturer identification are consistent, the submitted adaptive code is determined to be correct, and the server of the Github merges the submitted adaptive code with the existing adaptive code.

Step S14, generating an example adaptation code according to the initial adaptation code and the adaptation codes of the plurality of pieces of equipment information, and verifying the suitability of the system version of the adaptation code and the equipment information.

Specifically, the initial adapting code obtained in step S11 and the adapting code obtained in step S13 are arranged into an example adapting code (adapting demo), and in the electronic device of the system version and the device information corresponding to the example adapting code, whether the adapting demo is correct is verified, whether the adapting problem is solved is determined, and when the adapting problem exists, the code with the problem is modified, and the adapting to the system version and the device information is completed. Wherein the device information includes a model number of the electronic device.

In this step, the system source code acquired in step S12 is not verified.

Illustratively, in verifying the suitability, the problem code is deleted when the problem code is identified as being present in the adaptation code.

Illustratively, in step S13, the match of the branch number, vendor identification and system version of the adaptation code is performed using demo, and in case these several parameters all match, it is determined that the suitability verification passes.

It should be noted that, for electronic devices with different system versions and different device information, developers are limited by problems such as development resources, and the same adapting code cannot be used for all electronic devices. The method comprises the steps of finding out the problems of the adaptive codes of different system versions and different electronic devices in the actual system development process, and uploading the problems of the adaptive codes and the modified adaptive codes to the Github so as to update the adaptive codes.

And S15, generating a plug-in tool according to the adaptive code, inputting a target interface keyword in the plug-in tool, obtaining a target interface, and determining the target code according to the target interface.

Specifically, the plug-in tool is an integrated development environment (Android Studio) plug-in tool. The plug-in tool has an API association function, after a developer inputs a target interface keyword (can be a few characters in a target interface name), the plug-in tool determines a complete target interface name according to the target interface keyword, and displays codes corresponding to the target interface name to a user in a list form.

Illustratively, the plug-in tool is generated according to the adapting code, and the plug-in tool comprises the adapting code, wherein the adapting code comprises the function code and the interface code, and the function code and the interface code are equivalent to those in the pre-constructed code library in the previous embodiment. In addition, the plug-in tool further includes the system source code acquired in step S12, where the system source code is equivalent to the system source code in the pre-constructed code library in the foregoing embodiment.

The code presented to the user by the plug-in may include the adaptation code acquired in step S11, the system source code acquired in step S12, and/or the adaptation code corresponding to the device information acquired in step S13.

The developer selects the adapting code in S11, can automatically complement the adapting code of the system, and is suitable for developing application layers and weakly-correlated applications of the system. The developer selects the system source code in S12, and will complement the API of the system version indicated by the target software development kit (target SDK) and view the indicated system source code. The developer selects S3 the adapted code corresponding to the device information of the electronic device to be automatically complemented.

After obtaining the Android Studio plug-in tool according to the embodiment, the Android Studio plug-in tool of the adapting code may be published to a plug-in market.

For example, step S15 may include the following sub-steps:

and sub-step S151, the developer types in a target interface keyword, acquires and displays all interfaces corresponding to the target interface keyword through an Android Studio plug-in tool, selects a target interface, and types in a complete target interface name.

Specifically, all APIs are exposed through the code association function tool carried by the Android Studio plug-in tool.

Illustratively, determining a target interface keyword corresponding to a target interface according to an API (application program interface) to be used by a developer in developing an actual function;

specifically, a specific API may be typed according to the needs of a developer in actual development. Illustratively, the target interface key is the first few characters in the target interface name. After the target interface keywords are typed, all corresponding target interfaces are determined according to the target interface keywords through the code complement function of the Android Studio plug-in tool of the integrated development tool, and the target interfaces are presented to the user.

Specifically, the plug-in tool reads the target interface name of the complete target interface after the Android Studio plug-in tool code is complemented, then uses the target interface name to traverse the whole adaptation code document, finds the target interface with the same target interface name, and then displays the adaptation code corresponding to the target interface.

The code in the adaptation code document is the adaptation code, the adaptation code document is traversed and searched according to the target interface, the target interface with the same name as the target interface in the adaptation document is obtained, and the code in the adaptation code document corresponding to the target interface is the adaptation code corresponding to the target interface.

Substep S152, determining, by the plugin tool, an adaptation code document according to the typed API, and according to and displaying the adaptation code acquired in step S11, the system source code acquired in step S12, and the adaptation code corresponding to the device information acquired in step S13.

It should be noted that, if there is no code corresponding to the typed target interface, it is not shown.

Substep S153, the developer selects the initial adapting code, and the plugin tool automatically enters the initial adapting code acquired in step S11 into the IDE of the developer to complement the android system adapting code.

Specifically, the developer selects target adaptation code according to development needs. For example, in the case where a plurality of android system versions need to be adapted, a desired target adaptation code may be selected from the initial adaptation codes acquired in step S11.

Sub-step S154, the developer selects system source code.

Specifically, a system source code reference document is opened through a plug-in tool, and a code update document of the Android system source code of the API indicated by the targetSDK is displayed.

Specifically, the developer selects specific adaptation code according to development needs. For example, if an application strongly associated with the system is developed, the system source code in step S12 may be selected.

The system source code document includes system source code, and the system source code reference document, the developer document and the API document in step S11 are independent documents, and there are system source code and updated parts thereof in the system source code document.

In sub-step S155, the developer selects the adapting code corresponding to the electronic device information, and the adapting code corresponding to the target device information of the electronic device acquired in step S13 is automatically entered into the IDE of the developer through the plug-in tool, so as to complement the electronic device adapting code.

Specifically, the developer selects a specific adapting code according to the development requirement, and if the device information (such as the handset model) of a plurality of vendors needs to be adapted, the developer selects to determine the target adapting code in step S13.

Referring to fig. 4, the code acquisition method may include the steps of:

step S21, crawling the Android developer document and the API document through the web crawler.

Illustratively, android developer documents and API documents are documents that the system developer publishes on an open source platform.

Step S22, sorting documents according to functions and system versions.

Illustratively, the developer document is processed according to the function, and specifically, a catalog of function codes of the same function in the developer document is put together. For the function codes of the same function, the function codes are ordered from high to low in function version. Illustratively, the functional version is the same as the system version of the system corresponding to the functional code.

Illustratively, the interface codes are ordered in order of interface version from high to low.

Illustratively, the function code and the interface code are ranked to obtain a ranked document.

Step S23, extracting and converting Android development adaptation codes.

Illustratively, the codes in the ranked documents are extracted, resulting in an adapted code.

And step S24, downloading and comparing ASOP system source codes.

Wherein, ASOP is the open source platform that is used for depositing system source code. And downloading the system source code corresponding to the target system version from the open source platform.

Step S25, the source code and the API update document are made.

Illustratively, the source code and API update document are made from system source code.

Step S26, acquiring the adaptation codes of the read-only memory and the operating system in the development process.

Illustratively, a developer determines, during development, the adapted code corresponding to the read-only memory of the electronic device and the system version of the operating system for which system development is desired.

Wherein the read-only memory may represent device information of the electronic device.

Step S27, acquiring the adaptation codes of the read-only memory and the operating system provided by other developers.

For example, the adapting code of the read-only memory and the operating system provided by other developers is stored in the open source platform, and the adapting code of the read-only memory and the operating system provided by other developers is downloaded from the open source platform.

And S28, acquiring an adaptation code passing the verification.

By way of example, loading the demo in the electronic equipment which needs to be subjected to system development, running the adaptive code in the demo, and determining that the adaptive code passes the audit under the condition that no error reporting condition exists in the running process and the adaptive code is matched with information such as the branch number of the adaptive code in the open source platform.

Step S29, test verifies the adaptation code.

For example, the adaptation code is run in the electronic device that needs to be developed in the system, and in the case of no abnormality in the running, it is determined that the adaptation code test verification passes.

Step S30, correct and modify the adaptive problem code.

For example, the adaptive code is run in the electronic device which needs to be developed in the system, and in the case of abnormal running, the problem code which causes the abnormal running is determined from the adaptive code and corrected.

And S31, acquiring an Android Studio plug-in according to the adaptive code.

Illustratively, the adaptation code is added to a pre-built code library used when the Android Studio plug-in obtains the object code.

Referring to fig. 5, which shows a code obtaining apparatus 50 provided in an embodiment of the present application, the code obtaining apparatus 50 includes:

a first obtaining module 501, configured to obtain a target interface keyword, where the target interface keyword includes a part of characters in a target interface name, and the target interface name is a name of a target interface;

the first determining module 502 is configured to determine, according to the target interface keyword and a correspondence between the first interface keyword and the first interface, a target interface corresponding to the target interface keyword;

The first extracting module 503 is configured to extract, according to the target interface, a target code corresponding to the target interface from a pre-built code library, where the pre-built code library includes a plurality of codes, each code has a corresponding second interface, and the target interface is one of the second interfaces.

Optionally, the pre-constructed code library includes system source codes of a plurality of different system versions, and the target interface includes an interface for extracting the system source codes; the first extraction module 503 includes:

the first extraction submodule is used for extracting system source codes comprising a plurality of different system versions from a pre-constructed code library according to a target interface;

the first acquisition sub-module is used for acquiring a target system version;

the first determining submodule is used for determining target system source codes from a plurality of system source codes of different system versions according to the target system version and determining the target system source codes as target codes.

Optionally, the pre-built code library includes interface codes of a plurality of different interface types, and the target interface includes an interface for extracting the interface codes; the first extraction module 503 includes:

the second extraction submodule is used for extracting interface codes comprising a plurality of different interface types from a pre-constructed code library according to the target interface;

The second acquisition sub-module is used for acquiring the type of the target interface;

and the second determining submodule is used for determining a target interface code from a plurality of interface codes with different interface types according to the target interface type and determining the target interface code as the target code.

Optionally, in the pre-constructed code library, a plurality of interface codes corresponding to the target interface type are provided, and each interface code corresponding to the target interface type has a corresponding interface version; a second determination sub-module, comprising:

the first acquisition unit is used for acquiring the target interface version;

and the first determining unit is used for determining the target interface code corresponding to the target interface version from a plurality of interface codes corresponding to the target interface type.

Optionally, the pre-built code library comprises function codes of a plurality of different function types, and the target interface comprises an interface for extracting the function codes; the first extraction module 503 includes:

the third extraction submodule is used for extracting functional codes comprising a plurality of different functional types from a pre-constructed code library according to the target interface;

the third acquisition sub-module is used for acquiring the target function type;

and the third determining submodule is used for determining a target function code from the function codes of a plurality of different function types according to the target function type and determining the target function code as the target code.

Optionally, in the pre-constructed code library, a plurality of function codes corresponding to the target function type are provided, and each function code corresponding to the target function type has a corresponding function version; a third determination sub-module, comprising:

a second acquisition unit configured to acquire a target function version;

and the second determining unit is used for determining the target function code corresponding to the target function version from the plurality of function codes corresponding to the target function type.

Optionally, the pre-constructed code library comprises interface codes of a plurality of different device information and functional codes of different device information; the target interface comprises an interface for extracting an interface code and an interface for extracting a function code; the first extraction module 503 includes:

a fourth extraction sub-module, configured to extract an interface code and a function code from a pre-constructed code library according to the target interface;

a fourth obtaining sub-module, configured to obtain target device information;

and the fourth determining submodule is used for determining a target interface code from interface codes of various different equipment information according to the target equipment information and determining a target function code from function codes of the various different equipment information.

Illustratively, the code acquisition apparatus 50 further comprises:

and the second acquisition module is used for acquiring the developer document and extracting the function code from the developer document.

And the third acquisition module is used for acquiring the interface document and extracting the interface code from the interface document.

In this embodiment, the target interface keyword is obtained, and according to the target interface keyword and the corresponding relationship between the first interface keyword and the first interface, the target interface may be quickly determined, and according to the target interface, the target code corresponding to the target interface may be quickly obtained from the pre-constructed code library. Compared with the method in the related art, the embodiment improves the efficiency of acquiring codes.

Referring to fig. 6, an electronic device 600 may include one or more of the following components: a processing component 602, a memory 604, a power component 606, a multimedia component 608, an audio component 610, an input/output (I/O) interface 612, a sensor component 614, and a communication component 616.

The processing component 602 generally controls overall operation of the electronic device 600, such as operations associated with display, telephone calls, data communications, camera operations, and recording operations. The processing component 602 may include one or more processors 620 to execute instructions to perform all or part of the steps of the methods described above. Further, the processing component 602 can include one or more modules that facilitate interaction between the processing component 602 and other components. For example, the processing component 602 may include a multimedia module to facilitate interaction between the multimedia component 608 and the processing component 602.

The memory 604 is used to store various types of data to support operations at the electronic device 600. Examples of such data include instructions for any application or method operating on the electronic device 600, contact data, phonebook data, messages, pictures, multimedia, and so forth. The memory 604 may be implemented by any type or combination of volatile or nonvolatile memory devices such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disk.

The power supply component 606 provides power to the various components of the electronic device 600. The power supply components 606 can include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power for the electronic device 600.

The multimedia component 608 includes an interface that provides an output interface between the electronic device 600 and a user. In some embodiments, the interface may include a Liquid Crystal Display (LCD) and a Touch Panel (TP). If the interface includes a touch panel, the interface may be implemented as a touch screen to receive input signals from a user. The touch panel includes one or more touch sensors to sense touches, swipes, and gestures on the touch panel. The touch sensor may not only sense demarcations of touch or sliding actions, but also detect durations and pressures associated with touch or sliding operations. In some embodiments, the multimedia component 608 includes a front camera and/or a rear camera. When the electronic device 600 is in an operational mode, such as a shooting mode or a multimedia mode, the front-facing camera and/or the rear-facing camera may receive external multimedia data. Each front camera and rear camera may be a fixed optical lens system or have focal length and optical zoom capabilities.

The audio component 610 is for outputting and/or inputting audio signals. For example, the audio component 610 includes a Microphone (MIC) for receiving external audio signals when the electronic device 600 is in an operational mode, such as a call mode, a recording mode, and a voice recognition mode. The received audio signals may be further stored in the memory 604 or transmitted via the communication component 616. In some embodiments, audio component 610 further includes a speaker for outputting audio signals.

The input/output I/O interface 612 provides an interface between the processing component 602 and peripheral interface modules, which may be a keyboard, click wheel, buttons, etc. These buttons may include, but are not limited to: homepage button, volume button, start button, and lock button.

The sensor assembly 614 includes one or more sensors for providing status assessment of various aspects of the electronic device 600. For example, the sensor assembly 614 may detect an on/off state of the electronic device 600, a relative positioning of the components, such as a display and keypad of the electronic device 600, the sensor assembly 614 may also detect a change in position of the electronic device 600 or a component of the electronic device 600, the presence or absence of a user's contact with the electronic device 600, an orientation or acceleration/deceleration of the electronic device 600, and a change in temperature of the electronic device 600. The sensor assembly 614 may include a proximity sensor configured to detect the presence of nearby objects in the absence of any physical contact. The sensor assembly 614 may also include a light sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, the sensor assembly 614 may also include an acceleration sensor, a gyroscopic sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.

The communication component 616 is utilized to facilitate communication between the electronic device 600 and other devices, either in a wired or wireless manner. The electronic device 600 may access a wireless network based on a communication standard, such as WiFi, an operator network (e.g., 2G, 3G, 4G, or 5G), or a combination thereof. In one exemplary embodiment, the communication component 616 receives broadcast signals or broadcast-related information from an external broadcast management system via a broadcast channel. In one exemplary embodiment, the communication component 616 further includes a Near Field Communication (NFC) module to facilitate short range communications. For example, the NFC module may be implemented based on Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, ultra Wideband (UWB) technology, bluetooth (BT) technology, and other technologies.

In an exemplary embodiment, the electronic device 600 may be implemented by one or more Application Specific Integrated Circuits (ASICs), digital Signal Processors (DSPs), digital Signal Processing Devices (DSPDs), programmable Logic Devices (PLDs), field Programmable Gate Arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic elements for implementing a code acquisition method as provided by embodiments of the present application.

In an exemplary embodiment, a non-transitory computer-readable storage medium is also provided, such as memory 604, including instructions executable by processor 620 of electronic device 600 to perform the above-described method. For example, the non-transitory storage medium may be ROM, random Access Memory (RAM), CD-ROM, magnetic tape, floppy disk, optical data storage device, etc.

Fig. 7 is a block diagram of an electronic device 700 in accordance with another embodiment of the invention. For example, the electronic device 700 may be provided as a server. Referring to fig. 7, electronic device 700 includes a processing component 722 that further includes one or more processors and memory resources represented by memory 732 for storing instructions, such as application programs, executable by processing component 722. The application programs stored in memory 732 may include one or more modules that each correspond to a set of instructions. Further, the processing component 722 is configured to execute instructions to perform a code acquisition method provided by embodiments of the present application.

The electronic device 700 may also include a power component 726 configured to perform power management of the electronic device 700, a wired or wireless network interface 750 configured to connect the electronic device 700 to a network, and an input/output (I/O) interface 758. The electronic device 700 may operate based on an operating system stored in memory 732, such as Windows Server, mac OS XTM, unixTM, linuxTM, freeBSDTM, or the like.

Other embodiments of the present application will be apparent to those skilled in the art from consideration of the specification and practice of the application disclosed herein. This application is intended to cover any variations, uses, or adaptations of the application following, in general, the principles of the application and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the application being indicated by the following claims.

It is to be understood that the present application is not limited to the precise arrangements and instrumentalities shown in the drawings, which have been described above, and that various modifications and changes may be effected without departing from the scope thereof. The scope of the application is limited only by the appended claims.

Claims

1. A code acquisition method, comprising:

typing in a target interface keyword in a plug-in tool, wherein the target interface keyword comprises part of characters in a target interface name, and the target interface name is the name of a target interface;

comparing the target interface keywords with first interface keywords in a corresponding relation, determining first interface keywords matched with the target interface keywords, determining first interface names corresponding to the first interface keywords matched with the target interface keywords as target interface names, wherein in the corresponding relation, the first interface keywords are provided with corresponding first interface names, and the first interface names are used for identifying first interfaces corresponding to the first interface names; determining a first interface identified by a target interface name as a target interface;

Extracting an object code corresponding to the object interface from a pre-constructed code library according to the object interface, wherein the pre-constructed code library comprises a plurality of codes, each code is provided with a corresponding second interface, and the object interface is one of the second interfaces;

the pre-constructed code library comprises interface codes of a plurality of different interface types, and the target interface comprises an interface for extracting the interface codes;

the extracting, according to the target interface, the target code corresponding to the target interface from a pre-constructed code library, including:

extracting interface codes comprising a plurality of different interface types from a pre-constructed code library according to the target interface;

obtaining a target interface type;

and determining a target interface code from a plurality of interface codes with different interface types according to the target interface type, and determining the target interface code as the target code.

2. The method of claim 1, wherein the pre-built code library comprises system source code for a plurality of different system versions, and the target interface comprises an interface for extracting system source code;

Extracting system source codes comprising a plurality of different system versions from the pre-constructed code library according to the target interface;

acquiring a target system version;

and determining target system source codes from the system source codes of various different system versions according to the target system version, and determining the target system source codes as the target codes.

3. The method of claim 1, wherein in the pre-built code library, there are a plurality of interface codes corresponding to the target interface type, each interface code corresponding to the target interface type having a corresponding interface version;

and determining a target interface code from a plurality of interface codes with different interface types according to the target interface type, wherein the method comprises the following steps:

acquiring a target interface version;

and determining the target interface code corresponding to the target interface version from a plurality of interface codes corresponding to the target interface type.

4. The method of claim 1, wherein the pre-built code library includes function codes of a plurality of different function types, and the target interface includes an interface for extracting the function codes;

extracting functional codes comprising a plurality of different functional types from a pre-constructed code library according to the target interface;

acquiring a target function type;

and determining a target function code from a plurality of function codes with different function types according to the target function type, and determining the target function code as the target code.

5. The method of claim 4, wherein in the pre-built code library, there are a plurality of function codes corresponding to the target function type, each function code corresponding to the target function type having a corresponding function version;

and determining the target function code from the function codes of a plurality of different function types according to the target function type, wherein the method comprises the following steps:

acquiring a target function version;

and determining the target function code corresponding to the target function version from a plurality of function codes corresponding to the target function type.

6. The method of claim 1, wherein the pre-built code library comprises interface codes of a plurality of different device information, and function codes of different device information; the target interface comprises an interface for extracting the interface code and an interface for extracting the function code;

extracting interface codes and function codes from a pre-constructed code library according to the target interface;

acquiring target equipment information;

and determining a target interface code from the interface codes of various different equipment information according to the target equipment information, and determining a target function code from the function codes of various different equipment information.

7. A code acquisition apparatus, the apparatus comprising:

the first acquisition module is used for typing a target interface keyword in the plug-in tool, wherein the target interface keyword comprises part of characters in a target interface name, and the target interface name is the name of a target interface;

the first determining module is used for comparing the target interface keywords with first interface keywords in the corresponding relation, determining the first interface keywords matched with the target interface keywords, determining first interface names corresponding to the first interface keywords matched with the target interface keywords as target interface names, wherein in the corresponding relation, the first interface keywords are provided with corresponding first interface names, and the first interface names are used for identifying the first interfaces corresponding to the first interface names; determining an interface identified by the name of the target interface as the target interface;

The first extraction module is used for extracting target codes corresponding to the target interfaces from a pre-constructed code library according to the target interfaces, wherein the pre-constructed code library comprises a plurality of codes, each code is provided with a corresponding second interface, and the target interface is one of the second interfaces;

the pre-constructed code library comprises interface codes of a plurality of different interface types, and the target interface comprises an interface for extracting the interface codes; a first extraction module comprising:

8. An electronic device comprising a processor and a memory storing a program or instructions executable on the processor, which when executed by the processor, implement the steps of the method of any one of claims 1 to 6.

9. A readable storage medium, characterized in that it has stored thereon a program or instructions which, when executed by a processor, implement the steps of the method according to any of claims 1 to 6.