Пример #1
0
def __BuildTargetLinkLibrariesForDirectExternalDependencies(log: Log, package: Package,
                                                            resolvedDirectExternalDependencies: Union[List[PackageExternalDependency], List[PackagePlatformExternalDependency]],
                                                            ignoreLibs: Optional[List[str]] = None) -> str:
    if ignoreLibs is None:
        ignoreLibs = []

    isExternalLibrary = package.Type == PackageType.ExternalLibrary

    deps = ""
    for entry in resolvedDirectExternalDependencies:
        libraryName = LibUtil.ToUnixLibName(entry.Name)
        if libraryName not in ignoreLibs:
            if entry.Type == ExternalDependencyType.StaticLib or (entry.Type == ExternalDependencyType.DLL and entry.Name.lower().endswith(".so")):
                location = entry.Location if entry.Location is not None and (entry.IsManaged or not isExternalLibrary) else ""
                libraryName = libraryName if len(location) <= 0 else entry.Name
                fullPathLinkDir = Util.ChangeToCMakeEnvVariables(IOUtil.Join(location, libraryName))
                if entry.DebugName != entry.Name:
                    deps += "\n  {0} optimized {1}".format(GetAccessTypeString(package, entry.Access, False), fullPathLinkDir)
                    libraryName = LibUtil.ToUnixLibName(entry.DebugName)
                    fullPathLinkDir = Util.ChangeToCMakeEnvVariables(IOUtil.Join(location, libraryName))
                    deps += "\n  {0} debug {1}".format(GetAccessTypeString(package, entry.Access, False), fullPathLinkDir)
                else:
                    deps += "\n  {0} {1}".format(GetAccessTypeString(package, entry.Access, False), fullPathLinkDir)
            if entry.Type == ExternalDependencyType.Find:
                linkName = "${%s_LIBRARY}" % (libraryName)
                deps += "\n  {0} {1}".format(GetAccessTypeString(package, entry.Access, False), linkName)
        else:
            log.LogPrintVerbose(2, "INFO: Force ignored '{0}'".format(libraryName))
    return deps
 def __ApplyExternalLibNameCorrection(
         self, libraryNameList: List[str]) -> List[str]:
     newList = []
     for libName in libraryNameList:
         libName = LibUtil.ToUnixLibName(libName)
         newList.append(libName)
     return newList
    def __TryAddAsCMakeLib(self, recipe: Optional[PackageExperimentalRecipe],
                           package: Package) -> Optional[AndroidCMakeLib]:
        if recipe is None or recipe.ResolvedInstallPath is None or recipe.Pipeline is None:
            return None
        if not PackageRecipeUtil.CommandListContainsBuildCMake(
                recipe.Pipeline.CommandList):
            return None

        path = "{0}".format(recipe.ResolvedInstallPath)
        staticLibs = []  # type: List[AndroidCMakeLibRecord]
        if recipe.ValidateInstallation is not None and recipe.ValidateInstallation.CommandList is not None:
            for command in recipe.ValidateInstallation.CommandList:
                if command.CommandType == BuildRecipeValidateCommand.AddLib:
                    commandEx = cast(XmlRecipeValidateCommandAddLib, command)
                    libName = LibUtil.ToUnixLibName(
                        IOUtil.GetFileName(commandEx.Name))
                    libPath = IOUtil.Join(path, "${ANDROID_ABI}")
                    libPath = IOUtil.Join(libPath, commandEx.Name)
                    staticLibs.append(AndroidCMakeLibRecord(libName, libPath))


#                elif command.CommandType == BuildRecipeValidateCommand.AddDLL:
#                    dynamicLibs.append(LibUtil.ToUnixLibName(IOUtil.GetFileName(command.Name)))

        return AndroidCMakeLib(path, staticLibs)
def BuildTargetLinkLibrariesForDirectDependencies(
        config: Config,
        package: Package,
        templatePackageDependencyTargetLinkLibraries: str,
        ignoreLibs: Optional[List[str]] = None) -> str:
    if ignoreLibs is None:
        ignoreLibs = []

    if package.ResolvedDirectDependencies is None:
        raise Exception("Invalid package")

    isExternalLibrary = package.Type == PackageType.ExternalLibrary

    deps = ""
    for entry1 in package.ResolvedDirectDependencies:
        if entry1.Package.Type != PackageType.ToolRecipe:
            deps += "\n  {0} {1}".format(
                GetAccessTypeString(package, entry1.Access, False),
                GetPackageName(entry1.Package))


#           deps += "\n  {0} {1}".format(GetAccessTypeString(package, entry1.Access), GetAliasPackageName(entry1.Package))

# FIX: handle debug libraries
    for entry2 in package.ResolvedDirectExternalDependencies:
        libraryName = LibUtil.ToUnixLibName(entry2.Name)
        if libraryName not in ignoreLibs:
            if entry2.Type == ExternalDependencyType.StaticLib:
                location = entry2.Location if entry2.Location and not isExternalLibrary else ""
                fullPathLinkDir = Util.ChangeToCMakeEnvVariables(
                    IOUtil.Join(location, libraryName))
                deps += "\n  {0} {1}".format(
                    GetAccessTypeString(package, entry2.Access, False),
                    fullPathLinkDir)
            if entry2.Type == ExternalDependencyType.Find:
                linkName = "${%s_LIBRARY}" % (libraryName)
                deps += "\n  {0} {1}".format(
                    GetAccessTypeString(package, entry2.Access, False),
                    linkName)
        else:
            config.LogPrintVerbose(
                2, "INFO: Force ignored '{0}'".format(libraryName))

    if len(deps) <= 0:
        return ""

    content = templatePackageDependencyTargetLinkLibraries
    content = content.replace("##PACKAGE_DIRECT_DEPENDENCIES##", deps)
    return content