CN116860234A - Method, electronic device and program product for generating iOS dynamic library based on Unity item - Google Patents
Method, electronic device and program product for generating iOS dynamic library based on Unity item Download PDFInfo
- Publication number
- CN116860234A CN116860234A CN202310849102.XA CN202310849102A CN116860234A CN 116860234 A CN116860234 A CN 116860234A CN 202310849102 A CN202310849102 A CN 202310849102A CN 116860234 A CN116860234 A CN 116860234A
- Authority
- CN
- China
- Prior art keywords
- project
- file
- dynamic library
- unity
- ios
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 47
- 230000004048 modification Effects 0.000 claims abstract description 14
- 238000012986 modification Methods 0.000 claims abstract description 14
- 230000003993 interaction Effects 0.000 claims abstract description 10
- 238000004590 computer program Methods 0.000 claims description 15
- 238000010586 diagram Methods 0.000 description 11
- 230000006870 function Effects 0.000 description 9
- 238000003860 storage Methods 0.000 description 5
- 230000005540 biological transmission Effects 0.000 description 3
- 230000002452 interceptive effect Effects 0.000 description 3
- 230000008569 process Effects 0.000 description 3
- 238000003491 array Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000004519 manufacturing process Methods 0.000 description 2
- RYGMFSIKBFXOCR-UHFFFAOYSA-N Copper Chemical compound [Cu] RYGMFSIKBFXOCR-UHFFFAOYSA-N 0.000 description 1
- 229910052802 copper Inorganic materials 0.000 description 1
- 239000010949 copper Substances 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 230000014509 gene expression Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/36—Software reuse
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
- G06F21/12—Protecting executable software
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/76—Adapting program code to run in a different environment; Porting
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Multimedia (AREA)
- Technology Law (AREA)
- Computer Hardware Design (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a method, electronic equipment and a program product for generating an iOS dynamic library based on a Unity project. The method comprises the following steps: acquiring a unique identifier of the iOS native project; modifying a target project according to the unique identifier and a pre-configured modification rule, wherein the target project is an iOS project derived from the Unity project; wherein the preconfigured modification rule comprises: modifying the signature of the target project according to the unique identifier, modifying the configuration file of the target project to bind the data file of the target project with the UnityFramework project in the target project, and writing the head file name acquired from the target project into a head file list of the UnityFramework project; the first file name is the first file name of interaction between the iOS native project and the Unity platform; compiling the modified target engineering to generate a first dynamic library file corresponding to the modified target engineering.
Description
Technical Field
The present application relates to the field of programming technologies, and in particular, to a method, an electronic device, and a program product for generating an iOS dynamic library based on a Unity item.
Background
Many APPs (applications) currently have interactive scenes for real-time 3D (3-dimensional) presentation and 3D interaction. The 3D model is typically developed in a Unity platform, and then the engineering used by the mobile terminal is derived from the Unity project for use by mobile terminal developers. When integrating a Unity with an existing iOS project, it is common to directly drag a Unity-iPhone project derived from the Unity project into the existing iOS project. Because the Unity developer and the iOS developer are different, the Unity developer is required to give the source code of the Unity-iPhone project to the iOS developer, which can cause the source code to be exposed and inconvenient to manage.
Disclosure of Invention
It is an object of the present application to provide a new solution for integrating Unity items in iOS native items.
According to a first aspect of the present application, there is provided a method for generating an iOS dynamic library based on Unity items, comprising:
acquiring a unique identifier of the iOS native project;
modifying a target project according to the unique identifier and a pre-configured modification rule, wherein the target project is an iOS project derived from the Unity project;
wherein the preconfigured modification rule comprises: modifying the signature of the target project according to the unique identifier, modifying the configuration file of the target project to bind the data file of the target project with the UnityFramework project in the target project, and writing the head file name acquired from the target project into a head file list of the UnityFramework project;
the first file name is the first file name of interaction between the iOS native project and the Unity platform;
compiling the modified target engineering to generate a first dynamic library file corresponding to the modified target engineering.
Optionally, the preconfigured modification rule further includes:
and modifying the configuration item of whether the automatic horizontal and vertical screens are supported in the target engineering to be unsupported.
Optionally, after the generating the first dynamic library file corresponding to the modified target project, the method further includes:
and stripping the target debugging symbol in the first dynamic library file to generate a second dynamic library file.
Optionally, after the generating the second dynamic library file, the method further comprises:
and generating a description file corresponding to the second dynamic library file, wherein the description file comprises the size of the second dynamic library file and the size of a sub-file of the second dynamic library file.
Optionally, after the generating the description file corresponding to the second dynamic library file, the method further includes:
uploading the second dynamic library file and the description file to a private server.
Optionally, before said uploading said second dynamic library file and said description file to a private server, said method further comprises:
generating a version number corresponding to the second dynamic library file;
the uploading the second dynamic library file and the description file to a private server includes:
and uploading the second dynamic library file, the version number corresponding to the second dynamic library file and the description file to the private server.
Optionally, the data file includes an application serialization resource.
According to a second aspect of the present application there is provided 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 a method of generating iOS dynamic libraries based on Unity items according to the first aspect of the present application.
According to a third aspect of the present application there is provided a computer program product comprising computer programs/instructions which when executed implement the method according to the first aspect of the present application.
According to the method and the device, the unique identifier of the iOS native project can be automatically operated according to the unique identifier of the iOS native project input by the developer, a dynamic library file which can be used by the iOS native project is generated, only the unique identifier of the iOS native project is required to be input by the developer, other operations are not required by the developer, development time is saved, and development efficiency is improved. Meanwhile, the iOS developer does not need to acquire the source code of the Unity project, and the source code is prevented from being exposed.
Other features of the present application and its advantages will become apparent from the following detailed description of exemplary embodiments of the application, which proceeds with reference to the accompanying drawings.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the application and together with the description, serve to explain the principles of the application.
FIG. 1 is a flow chart of a method of generating an iOS dynamic library based on a Unity project in an embodiment of the application.
FIG. 2 is a flow chart of generating a dynamic library file according to another embodiment of the present application.
Fig. 3 is a schematic diagram of an electronic device in an embodiment of the application.
Detailed Description
Various exemplary embodiments of the present application will now be described in detail with reference to the accompanying drawings. It should be noted that: the relative arrangement of the components and steps, numerical expressions and numerical values set forth in these embodiments do not limit the scope of the present application unless it is specifically stated otherwise.
The following description of at least one exemplary embodiment is merely exemplary in nature and is in no way intended to limit the application, its application, or uses.
Techniques, methods, and apparatus known to one of ordinary skill in the relevant art may not be discussed in detail, but are intended to be part of the specification where appropriate.
In all examples shown and discussed herein, any specific values should be construed as merely illustrative, and not a limitation. Thus, other examples of exemplary embodiments may have different values.
It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further discussion thereof is necessary in subsequent figures.
Before describing embodiments of the present application, the terms involved in the embodiments of the present application will be explained first.
iOS: an operating system for a mobile terminal.
Shell: a scripting language.
3D: three-dimensional perspective view.
Unity: and a real-time 3D interactive content creation and operation platform.
UnityHub: and connecting the desktop end application programs of the Unity.
Unityframe work: a Unity dynamic library for iOS projects.
Mac OS: an operating system for a desktop terminal.
Xcode: an integrated development tool running on the Mac OS can be used to develop iOS projects.
Unity-iPhone: the name of the iOS project exported by the Unity project.
Unityframe work: one of the Unity-iPhone projects.
NET: a free open source development platform for building multiple applications.
READM: and (5) a description file.
strip: xcode removes the specified symbol command.
Cocoapois: means to manage third party dependent libraries.
Github: an open source and private software project oriented hosting platform.
git: the file is uploaded to the commands of the Github platform.
Unityviewcontrollerbase+ios.mm: the name of a class in the Unity-iPhone item.
development/Xcode/development data: and installing a developer data directory of the Xcode.
du: script commands of the file size are counted.
Many iOS APPs currently have interactive scenes for real-time 3D presentation and 3D interaction. For example, for APP of a vehicle manufacturing company, it is necessary to present a 3D model of a vehicle on a mobile terminal, and also to interact with operations of a user, such as opening and closing a door, switching a viewing angle, and the like. The Unity is a 3D development engine which is widely used at present, a 3D model can be developed in the Unity, and then engineering used by a mobile terminal is derived from the Unity project and is used by iOS mobile terminal developers.
When integrating a Unity with an existing iOS project, it is common to directly drag a Unity-iPhone project derived from the Unity project into the existing iOS project. Because the Unity developer and the iOS developer are different, the Unity developer is required to give the source code of the Unity-iPhone project to the iOS developer, which can cause the source code to be exposed and inconvenient to manage. The scheme of the application is specially provided for solving the technical problems.
As shown in FIG. 1, the present embodiment describes a method for generating an iOS dynamic library based on a Unity project, comprising steps 1100-1300.
Step 1100: a unique identifier of the iOS native item is obtained.
Step 1200: and modifying a target project according to the unique identifier and a pre-configured modification rule, wherein the target project is an iOS project derived from the Unity project.
Wherein the preconfigured modification rule comprises: modifying the signature of the target project according to the unique identifier, modifying the configuration file of the target project to bind the data file of the target project with the UnityFramework project in the target project, and writing the head file name acquired from the target project into the head file list of the UnityFramework project.
The first file name is the first file name of interaction between the iOS native project and the Unity platform.
Step 1300: compiling the modified target engineering to generate a first dynamic library file corresponding to the modified target engineering.
The iOS native project is a mobile terminal application program running on the iOS system, and has functions of 3D presentation, 3D interaction and the like which need to use Unity. For example, the iOS native project may be a vehicle presentation application for presenting a 3D model of a vehicle. Before the iOS native project is developed, a developer applies a unique identifier to the iOS authority, each iOS native project having a unique identifier. Upon obtaining the unique identifier of the iOS native project, the unique identifier of the iOS native project may be manually entered by a developer. For example, each step of the method for generating the iOS dynamic library based on the Unity project in the embodiment can be automatically executed by the Shell script, and the developer manually inputs the unique identification of the iOS native project into the Shell script.
As shown in fig. 2, the order of the three steps may be arbitrarily exchanged, such as modifying the signature of the target project, modifying the configuration file of the target project, and writing the header file name into the header file list of the unityframe project. For example, the signature of the target project can be modified first, then the configuration file of the target project with the modified signature is modified, and finally the header file name is written into the unityframe project in the target project with the modified configuration file. For another example, the configuration file of the target project may be modified first, then the signature of the target project after the modification of the configuration file is modified, and finally the header file name is written into the unityframe project in the target project after the modification of the signature.
The target project is an iOS project derived from the Unity project. The Unity developer may use UnityHub to manage Unity projects, such as a target project being a Unity-iPhone project derived from UnityHub. The signature of the Unity-iPhone project is inconsistent with the signature of the iOS native project, and in order to avoid compiling errors of the Unity-iPhone project, the signature of the Unity-iPhone project needs to be modified so that the signature of the Unity-iPhone project is consistent with the signature of the iOS native project. Specifically, the unique identifier of the iOS native project can be directly used as a signature of the Unity-iPhone project.
The data file includes an application serialization resource. The Unity-iPhone project comprises a UnityFramework project and a Data folder, wherein the Data folder comprises files necessary for interaction of the iOS native project with the Unity platform. When the Unity-iPhone project is exported, the Data folder is only bound with the Unity-iPhone project. To enable smooth interaction of iOS native projects with the Unity platform, the Data folder needs to be bound to the unityframe engineering. Specifically, the Data folder of the Unity-iPhone project can be bound with the unityframe project by modifying the configuration file of the Unity-iPhone project.
In the Unity development process, the iOS native project developer will provide the Unity developer with header file names that the iOS native project needs to use when interacting with the Unity platform. After the Unity-iPhone project Condition is exported from the Unity project, the Unity-iPhone project may include these header file names. These header names are written to the header list of the unityframe work project.
Compiling the Unity-iPhone engineering to obtain a dynamic library file corresponding to the Unity-iPhone engineering, for example, obtaining a UnityFramework dynamic library file. The iOS native project may reference the dynamic library file to enable interaction with the Unity platform. The developer may create iOS native projects in Xcode. The Unity-iPhone project derived from the Unity project may also be added to the Xcode. And executing an Xcode compiling command xcodebuild build-project Unity-iPhone.xcodeeproj through a Shell script to generate a dynamic library file.
The steps of the method for generating the iOS dynamic library based on the Unity item in the embodiment can be automatically executed through a Shell script, and the Shell script contains a plurality of commands for realizing the steps in the method. When a certain Unity item needs to be integrated into an iOS native item, the integration of the Unity item into the iOS native item can be realized by inputting a unique identifier of the iOS native item into the Shell script and allowing the script to run automatically.
The method and the device can automatically operate according to the unique identifier of the iOS original project input by the developer, and generate the dynamic library file for the iOS original project, and only the unique identifier of the iOS original project is input by the developer, so that other operations are not required by the developer, the development time is saved, and the development efficiency is improved. Meanwhile, the iOS developer does not need to acquire the source code of the Unity project, and the source code is prevented from being exposed.
In this embodiment, the pre-configured modification rule further includes: and modifying the configuration item of whether the automatic horizontal and vertical screens are supported in the target engineering to be unsupported.
The step of modifying the configuration item of whether to support automatic landscape/portrait screen can be inserted between the three steps of modifying the signature of the target project, modifying the configuration file of the target project and writing the header file name into the header file list of the unityframe project in any order.
When the mobile terminal displays the 3D model through Unity, in order to fully utilize the screen space and obtain a better model display effect, the mobile terminal is displayed in a horizontal screen mode by default. Whereas iOS native items are typically displayed in a portrait screen fashion. In one interface of the iOS native project, a control for entering Unity is displayed. And after clicking the control, the user enters the Unity horizontal screen display. If the automatic horizontal and vertical screen is supported, the display mode of the iOS system is changed into horizontal screen display when the Unity horizontal screen is displayed, and the interface of the iOS original project is displayed in the horizontal screen mode after the Unity is exited, which is different from the original vertical screen display mode, and the user experience is affected. Under the condition that whether the configuration item of the automatic horizontal and vertical screen is supported in the target engineering is changed to be unsupported, the user clicks the control and then enters the Unity horizontal screen display, and after the Unity is exited, the interface of the iOS native project is displayed in a vertical screen mode. The Unity-iPhone engineering comprises a class named UnityViewControllerBase+iOS.mm, wherein the class comprises a parameter used for indicating whether an automatic landscape screen is supported or not, and when the value of the parameter is modified into NO, the parameter does not support the automatic landscape screen.
For example, after a vehicle APP is opened, the main interface of the vehicle APP is displayed in a vertical screen manner. The main interface of the vehicle APP comprises a cloud exhibition hall control, and a user clicks the cloud exhibition hall control to enter Unity, so that a vehicle model is displayed in a horizontal screen mode, and meanwhile an exit button is also displayed. And when the user clicks the exit button, exiting the Unity, and displaying the main interface of the vehicle APP in a vertical screen mode.
According to the method, whether the configuration items of the automatic horizontal and vertical screens are supported or not in the target engineering is changed to be unsupported, so that the influence of the horizontal screen display mode of Unity on the display mode of the iOS original project is avoided, and the user experience is improved.
In this embodiment, after the generating the first dynamic library file corresponding to the modified target project, the method further includes: and stripping the target debugging symbol in the first dynamic library file to generate a second dynamic library file.
A large number of useless debug symbols are included in the generated first dynamic library file, which increase the size of the first dynamic library file. These debug symbols are not used when invoking the dynamic library in the iOS native project. The size of the dynamic library file can be reduced by stripping the useless debug symbols in the dynamic library file.
Specifically, the generated first dynamic library file may be found from the developer data directory of Xcode, deviveddata, and then the unwanted debugger in the first dynamic library file is stripped using a strip command, which is a command in Xcode to remove a specified symbol.
In one example, the size of the first dynamic library file before stripping the debug symbol is 128M and the size of the second dynamic library file after stripping the debug symbol is 63M.
According to the embodiment, the useless debugging symbols in the dynamic library file are stripped, so that the size of the dynamic library file can be reduced, and the operation of the iOS native project is smoother.
In this embodiment, after the generating the second dynamic library file, the method further includes: and generating a description file corresponding to the second dynamic library file, wherein the description file comprises the size of the second dynamic library file and the size of a sub-file of the second dynamic library file.
After the second dynamic library file is generated, the size of the second dynamic library file and the size of each subfile contained in the second dynamic library file are counted. For example, the second dynamic library file includes 10 subfiles, and the size of each subfile can be obtained. Specifically, the size of each file can be counted by running the du command through the Shell script, and an explanation file READM is generated.
The description file can comprise various information such as the size of the second dynamic library file, the size of each sub-file of the second dynamic library file, the version number of the second dynamic library file and the like, and the influence of each sub-file of the second dynamic library file on the size of the second dynamic library file can be intuitively displayed through the description file, so that an optimization idea is provided for Unity developers. For example, a certain sub-file in the second dynamic library file is larger, and the Unity developer can optimize the sub-file when developing the Unity project, so that the size of the sub-file is reduced, and the size of the second dynamic library file is reduced.
In this embodiment, after the generating the second dynamic library file, the method further includes: uploading the second dynamic library file and the description file to a private server.
After the second dynamic library file and the description file are generated, the second dynamic library file and the description file may be uploaded to the private server. A private server is a server that is only used by internal personnel, who cannot be accessed by external personnel. For example, a certain company internally comprises a Unity project development group and an iOS native project development group, after uploading a second dynamic library file and a description file to a private server, a developer of the Unity project development group can acquire the second dynamic library file and the description file, and optimize the second dynamic library file according to the content in the description file. The developer of the iOS native project group may also obtain a second dynamic library file and use the second dynamic library file in the iOS native project. For example, the private server may be a GitHub private server, and the second dynamic library file and the description file are uploaded to the GitHub private server by executing the git command through the Shell script.
In this embodiment, before the uploading the second dynamic library file and the description file to a private server, the method further includes: and generating a version number corresponding to the second dynamic library file. The uploading the second dynamic library file and the description file to a private server includes: and uploading the second dynamic library file, the version number corresponding to the second dynamic library file and the description file to the private server.
For a certain Unity item, there may be multiple different versions. The second dynamic library file corresponding to each version is different. In order to distinguish different second dynamic library files, corresponding version numbers are also generated after each generation of the second dynamic library files. The use of a second, different dynamic library file in the iOS native project has a different display effect. Such as for the V1.0 version of the dynamic library file, only the vehicle model is shown. And for the dynamic library file of V2.0 version, the user can freely select the visual angle, open and close the car door and the like.
In the embodiment, the version number corresponding to the second dynamic library file is generated to manage the version of the second dynamic library file, so that an developer can select the second dynamic library file with the proper version.
As shown in fig. 3, this embodiment describes an electronic device 400, including a processor 401 and a memory 402, where the memory 402 stores a program or instructions executable on the processor 401, and the program or instructions implement steps of a method for generating iOS dynamic library based on Unity items according to any of the embodiments of the present application when executed by the processor 401.
This embodiment describes a computer program product comprising a computer program/instruction which when executed by a processor implements a method according to any of the embodiments of the application.
The methods of the present application may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer programs or instructions. When the computer program or instructions are loaded and executed on a computer, the processes or functions of the present application are performed in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, a network device, a user device, a core network device, an OAM, or other programmable apparatus.
The computer programs/instructions described herein may be downloaded from a computer readable storage medium to the individual computing/processing devices or to an external computer or external storage device via a network, such as the internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmissions, wireless transmissions, routers, firewalls, switches, gateway computers and/or edge servers. The network interface card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium in the respective computing/processing device.
Computer program instructions for carrying out operations of the present application may be assembly instructions, instruction Set Architecture (ISA) instructions, machine-related instructions, microcode, firmware instructions, state setting data, or source or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, c++ or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The computer readable program instructions may be executed entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider). In some embodiments, aspects of the present application are implemented by personalizing electronic circuitry, such as programmable logic circuitry, field Programmable Gate Arrays (FPGAs), or Programmable Logic Arrays (PLAs), with state information for computer readable program instructions, which can execute the computer readable program instructions.
Various aspects of the present application are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the application. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer-readable program instructions.
These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable medium having the instructions stored therein includes an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer, other programmable apparatus or other devices implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions. It is well known to those skilled in the art that implementation by hardware, implementation by software, and implementation by a combination of software and hardware are all equivalent.
The foregoing description of embodiments of the application has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the various embodiments described. The terminology used herein was chosen in order to best explain the principles of the embodiments, the practical application, or the technical improvement of the technology in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein. The scope of the application is defined by the appended claims.
Claims (9)
1. A method for generating iOS dynamic libraries based on Unity items, comprising:
acquiring a unique identifier of the iOS native project;
modifying a target project according to the unique identifier and a pre-configured modification rule, wherein the target project is an iOS project derived from the Unity project;
wherein the preconfigured modification rule comprises: modifying the signature of the target project according to the unique identifier, modifying the configuration file of the target project to bind the data file of the target project with the UnityFramework project in the target project, and writing the head file name acquired from the target project into a head file list of the UnityFramework project;
the first file name is the first file name of interaction between the iOS native project and the Unity platform;
compiling the modified target engineering to generate a first dynamic library file corresponding to the modified target engineering.
2. The method of claim 1, wherein the preconfigured modification rules further comprise:
and modifying the configuration item of whether the automatic horizontal and vertical screens are supported in the target engineering to be unsupported.
3. The method of claim 1, wherein after the generating the first dynamic library file corresponding to the modified target project, the method further comprises:
and stripping the target debugging symbol in the first dynamic library file to generate a second dynamic library file.
4. The method of claim 3, wherein after the generating the second dynamic library file, the method further comprises:
and generating a description file corresponding to the second dynamic library file, wherein the description file comprises the size of the second dynamic library file and the size of a sub-file of the second dynamic library file.
5. The method of claim 4, wherein after the generating the description file corresponding to the second dynamic library file, the method further comprises:
uploading the second dynamic library file and the description file to a private server.
6. The method of claim 5, wherein prior to said uploading said second dynamic library file and said description file to a private server, said method further comprises:
generating a version number corresponding to the second dynamic library file;
the uploading the second dynamic library file and the description file to a private server includes:
and uploading the second dynamic library file, the version number corresponding to the second dynamic library file and the description file to the private server.
7. The method of claim 1, wherein the data file comprises an application serialization resource and a NET program set.
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 a method of generating iOS dynamic library based on Unity items as claimed in any of claims 1 to 7.
9. A computer program product comprising computer programs/instructions which, when executed by the computer program/instruction processor, implement the method of any of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310849102.XA CN116860234A (en) | 2023-07-11 | 2023-07-11 | Method, electronic device and program product for generating iOS dynamic library based on Unity item |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310849102.XA CN116860234A (en) | 2023-07-11 | 2023-07-11 | Method, electronic device and program product for generating iOS dynamic library based on Unity item |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116860234A true CN116860234A (en) | 2023-10-10 |
Family
ID=88231792
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310849102.XA Pending CN116860234A (en) | 2023-07-11 | 2023-07-11 | Method, electronic device and program product for generating iOS dynamic library based on Unity item |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116860234A (en) |
-
2023
- 2023-07-11 CN CN202310849102.XA patent/CN116860234A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107733985B (en) | Method and device for deploying functional components of cloud computing system | |
| US11647250B2 (en) | Methods and systems for remote streaming of a user-customized user interface | |
| CN112068879B (en) | Method and device for constructing client application program development framework based on configuration | |
| WO2024066825A1 (en) | Page project development method, apparatus, device, medium and product | |
| CN115268861B (en) | Introduction method, system, equipment and storage medium of custom component | |
| CN116860234A (en) | Method, electronic device and program product for generating iOS dynamic library based on Unity item | |
| US20220197607A1 (en) | System and method for developing user interface applications | |
| EP3872625A1 (en) | Method and system for managing an app | |
| CN113535037A (en) | Interactive display method and device for command line terminal, computer readable medium and equipment | |
| US20200401381A1 (en) | Virtual reality based computer application development | |
| Andrén et al. | Towards automated engineering and validation of cyber-physical energy systems | |
| CN112052224A (en) | File export method and device | |
| Kovalenko | PhoneGap By Example | |
| US20190347078A1 (en) | Generating Application Mock-Ups Based on Captured User Sessions | |
| CN115309376B (en) | Application creation method and device, electronic equipment and storage medium | |
| Barney | Developing hybrid applications for the iPhone: using HTML, CSS, and JavaScript to build dynamic apps for the iPhone | |
| Singh | Ionic cookbook: Recipes to create cutting-edge, real-time hybrid mobile apps with ionic | |
| KR102382703B1 (en) | Multi-Channel Integration Platform Authoring Device and Method Thereby | |
| US9235322B1 (en) | Systems, methods and computer program products for a cloud application editor | |
| CN112328277B (en) | Resource updating method and device of application and server | |
| CN111694723B (en) | Method for editing nodes and components when product runs under H5 and storage medium | |
| Kütt | Delta Building Visualization–Admin Tool | |
| Lee | Windows Server 2016 Automation with PowerShell Cookbook | |
| Medvedec | Analysis of the usage of specific technologies in Android development | |
| CN115794603A (en) | Resource processing method, device, equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |