예제 #1
0
        public override void Run()
        {
            this.Init();

            PluginLinker.CopyNativeCode(this.SourcePath, new[] { "c3p", "cordova" }, this.TargetOutputPath);

            string scriptOutputPath = Path.Combine(this.TargetOutputPath, "www");

            this.CopyLibTypeScript(scriptOutputPath);

            File.Copy(
                Path.Combine(this.SourcePath, "ts", "node_modules", "cordova.d.ts"),
                Path.Combine(scriptOutputPath, "cordova.d.ts"));
            File.Copy(
                Path.Combine(this.SourcePath, "ts", "node_modules", "es6-promise.d.ts"),
                Path.Combine(scriptOutputPath, "es6-promise.d.ts"));

            this.FixTSModuleReferences(scriptOutputPath, false);
            Utils.CompileTypeScript(scriptOutputPath);

            this.GeneratePluginXml(this.TargetOutputPath, scriptOutputPath);
            this.CopyPackageJson();

            Utils.PackNpmPackage(this.TargetOutputPath);
        }
예제 #2
0
        public override void Run()
        {
            this.Init();

            PluginLinker.CopyNativeProjects(this.SourcePath, new[] { "c3p", "reactnative" }, this.TargetOutputPath);

            string scriptOutputPath = Path.Combine(this.TargetOutputPath, "js");

            this.CopyLibTypeScript(scriptOutputPath);

            string modulesOutputPath = Path.Combine(scriptOutputPath, "node_modules");

            Directory.CreateDirectory(modulesOutputPath);
            File.Copy(
                Path.Combine(this.SourcePath, "ts", "node_modules", "react-native.d.ts"),
                Path.Combine(modulesOutputPath, "react-native.d.ts"));

            // React Native supports (most) ES6 language features, particularly Promises.
            string tsconfigFilePath = Path.Combine(scriptOutputPath, "tsconfig.json");

            File.WriteAllText(tsconfigFilePath, File.ReadAllText(tsconfigFilePath).Replace("\"es5\"", "\"es6\""));

            this.FixTSModuleReferences(scriptOutputPath, true);
            Utils.CompileTypeScript(scriptOutputPath);

            this.CopyPackageJson();

            Utils.PackNpmPackage(this.TargetOutputPath);
        }
예제 #3
0
파일: PluginLinker.cs 프로젝트: runt18/c3p
        internal static void CopyNativeCode(string sourcePath, string[] sourceSubdirectories, string targetPath)
        {
            foreach (string platform in new[]
            {
                PluginInfo.AndroidPlatformName,
                PluginInfo.IOSPlatformName,
            })
            {
                string platformSourcePath = Path.Combine(sourcePath, platform);
                if (!Directory.Exists(platformSourcePath))
                {
                    continue;
                }

                string platformTargetPath = Path.Combine(targetPath, platform);
                if (!Directory.Exists(platformTargetPath))
                {
                    Directory.CreateDirectory(platformTargetPath);
                }

                ICollection <string> includeExtensions  = GetFileExtensionsForNativeCode(platform);
                ICollection <string> excludeDirectories = new List <string>(new[] { "build" });

                if (sourceSubdirectories != null)
                {
                    foreach (string sourceSubdirectory in sourceSubdirectories)
                    {
                        string sourceSubPath = Path.Combine(platformSourcePath, sourceSubdirectory);
                        PluginLinker.CopyFiles(
                            sourceSubPath, platformTargetPath, false, includeExtensions, excludeDirectories);
                    }
                }
                else
                {
                    foreach (string frameworkSourceDirectory in Directory.GetDirectories(platformSourcePath, "*.framework"))
                    {
                        string frameworkName = Path.GetFileName(frameworkSourceDirectory);
                        excludeDirectories.Add(frameworkName);

                        string frameworkTargetDirectory = Path.Combine(platformTargetPath, frameworkName);
                        if (!Directory.Exists(frameworkTargetDirectory))
                        {
                            Directory.CreateDirectory(frameworkTargetDirectory);
                        }

                        PluginLinker.CopyFiles(frameworkSourceDirectory, frameworkTargetDirectory, true);
                    }

                    PluginLinker.CopyFiles(
                        platformSourcePath, platformTargetPath, false, includeExtensions, excludeDirectories);
                }
            }
        }
예제 #4
0
        internal static void CollectSourceFilesInfo(string sourceDirectoryPath, PluginInfo pluginInfo)
        {
            foreach (string platform in new[]
            {
                PluginInfo.AndroidPlatformName,
                PluginInfo.IOSPlatformName,
                PluginInfo.WindowsPlatformName
            })
            {
                PluginInfo.PlatformInfo platformInfo =
                    pluginInfo.Platforms.FirstOrDefault(p => p.Name == platform);
                if (platformInfo == null)
                {
                    continue;
                }

                string platformSourcePath = Path.Combine(sourceDirectoryPath, platform);
                if (Directory.Exists(platformSourcePath))
                {
                    ICollection <string> extensions = PluginLinker.GetFileExtensionsForNativeCode(platform);
                    foreach (string sourceFilePath in Directory.GetFiles(platformSourcePath))
                    {
                        string relativeFilePath = Path.GetFullPath(sourceFilePath)
                                                  .Substring(Path.GetFullPath(sourceDirectoryPath).Length + 1);
                        if (extensions.Any(e => sourceFilePath.EndsWith(e, StringComparison.OrdinalIgnoreCase)))
                        {
                            PluginInfo.SourceFileInfo sourceFileInfo =
                                new PluginInfo.SourceFileInfo
                            {
                                SourceFilePath = relativeFilePath.Replace("\\", "/"),
                            };

                            if (sourceFilePath.EndsWith(".java", StringComparison.OrdinalIgnoreCase))
                            {
                                string javaPackage = CordovaPluginLinker.GetJavaSourceFilePackage(sourceFilePath);
                                if (javaPackage != null)
                                {
                                    sourceFileInfo.TargetDirectoryPath = "src/" + javaPackage.Replace('.', '/');
                                }
                            }

                            if (!platformInfo.ResourceFiles.Any(r => String.Equals(
                                                                    r.SourceFilePath, sourceFileInfo.SourceFilePath, StringComparison.OrdinalIgnoreCase)))
                            {
                                platformInfo.SourceFiles.Add(sourceFileInfo);
                            }
                        }
                    }
                }
            }
        }
예제 #5
0
파일: PluginLinker.cs 프로젝트: runt18/c3p
        protected static void CopyFiles(
            string sourcePath,
            string targetPath,
            bool preserveDirectories,
            ICollection <string> includeExtensions  = null,
            ICollection <string> excludeDirectories = null)
        {
            PluginLinker.CopyFiles(sourcePath, targetPath, preserveDirectories, relativePath =>
            {
                if (excludeDirectories != null)
                {
                    char slash = Path.DirectorySeparatorChar;
                    foreach (string excludeDirectory in excludeDirectories)
                    {
                        if (relativePath.StartsWith(excludeDirectory + slash, StringComparison.OrdinalIgnoreCase) ||
                            relativePath.IndexOf(slash + excludeDirectory + slash, StringComparison.OrdinalIgnoreCase) > 0)
                        {
                            return(false);
                        }
                    }
                }

                if (includeExtensions != null)
                {
                    foreach (string includeExtension in includeExtensions)
                    {
                        if (relativePath.EndsWith(includeExtension, StringComparison.OrdinalIgnoreCase))
                        {
                            return(true);
                        }
                    }

                    return(false);
                }

                return(true);
            });
        }
예제 #6
0
        public override void Run()
        {
            this.Init();
            ClrApi pluginApi = this.MergeApis(this.LoadApis());

            PluginLinker.CopyNativeProjects(this.SourcePath, null, this.TargetOutputPath);

            string scriptOutputPath = Path.Combine(this.TargetOutputPath, "js");

            if (!Directory.Exists(scriptOutputPath))
            {
                Directory.CreateDirectory(scriptOutputPath);
            }

            this.CreateTypeScriptBindings(
                pluginApi, true, true, c3pReactNativePackageName, scriptOutputPath);

            string modulesDirectoryPath = Path.Combine(scriptOutputPath, "node_modules");

            Directory.CreateDirectory(modulesDirectoryPath);
            this.CreateBridgeModuleTypeScriptDefinition(modulesDirectoryPath);
            Utils.ExtractResource("NativeObject.ts", modulesDirectoryPath);
            Utils.ExtractResource("NativeBridge.ts", modulesDirectoryPath);
            Utils.ExtractResource("react-native.d.ts", modulesDirectoryPath);
            Utils.ExtractResource("tsconfig.json", scriptOutputPath);

            this.GeneratePluginModule(pluginApi, scriptOutputPath);

            this.RemoveES6PromiseImports(scriptOutputPath);

            Utils.CompileTypeScript(scriptOutputPath);

            Log.Message(Utils.EnsureTrailingSlash(Path.GetFullPath(this.TargetOutputPath)));
            this.GeneratePackageJson(c3pReactNativePackageName, new[] { "    \"main\": \"js/plugin.js\"" });
            Utils.PackNpmPackage(this.TargetOutputPath);
        }
예제 #7
0
        public override void Run()
        {
            this.Init();
            ClrApi pluginApi = this.MergeApis(this.LoadApis());

            PluginLinker.CopyNativeCode(this.SourcePath, null, this.TargetOutputPath);

            if (this.PluginInfo.WindowsPlatform != null)
            {
                string windowsSourcePath = Path.Combine(
                    this.SourcePath,
                    "windows" + (this.windowsLanguage != null ? "-" + this.windowsLanguage : null));
                if (Directory.Exists(windowsSourcePath))
                {
                    string windowsOutputPath = Path.Combine(this.TargetOutputPath, "windows");
                    if (!Directory.Exists(windowsOutputPath))
                    {
                        Directory.CreateDirectory(windowsOutputPath);
                    }

                    PluginLinker.CopyProjectDirectory(windowsSourcePath, windowsOutputPath);
                }
            }

            CordovaPluginLinker.CollectSourceFilesInfo(this.TargetOutputPath, this.PluginInfo);
            this.CreateAndroidConfigFileInfo();
            this.CreateIOSConfigFileInfo();
            this.CreateWindowsConfigFileInfo();

            this.AddProjectReferences();

            string scriptOutputPath = Path.Combine(this.TargetOutputPath, "www");

            if (Directory.Exists(scriptOutputPath))
            {
                Directory.Delete(scriptOutputPath, true);
            }

            Directory.CreateDirectory(scriptOutputPath);
            this.CreateTypeScriptBindings(
                pluginApi, true, false, c3pPluginId + "." + c3pCordovaModuleName, scriptOutputPath);

            string modulesDirectoryPath = Path.Combine(scriptOutputPath, "node_modules");

            Directory.CreateDirectory(modulesDirectoryPath);

            // This is messy, because Cordova's implementation of module resolution
            // doesn't respect the 'main' property from the package.json.
            this.CreateBridgeModuleTypeScriptDefinition(Path.Combine(
                                                            modulesDirectoryPath, c3pPluginId + "." + c3pCordovaModuleName + ".d.ts"));
            Utils.ExtractResource(
                "es6-promise.d.ts",
                modulesDirectoryPath,
                c3pPluginId + "." + "es6-promise.d.ts");

            foreach (string tsFile in new[] { "NativeObject.ts", "NativeBridge.ts" })
            {
                Utils.ExtractResource(tsFile, modulesDirectoryPath, c3pPluginId + "." + tsFile);
                string fixTsCode = File.ReadAllText(Path.Combine(
                                                        modulesDirectoryPath, c3pPluginId + "." + tsFile));
                fixTsCode = fixTsCode.Replace("\"es6-promise\"", "\"" + c3pPluginId + ".es6-promise\"")
                            .Replace("\"./NativeObject\"", "\"" + c3pPluginId + ".NativeObject\"");
                File.WriteAllText(
                    Path.Combine(modulesDirectoryPath, c3pPluginId + "." + tsFile), fixTsCode);
            }

            Utils.ExtractResource("tsconfig.json", scriptOutputPath);
            Utils.CompileTypeScript(scriptOutputPath);

            Log.Message(Utils.EnsureTrailingSlash(Path.GetFullPath(this.TargetOutputPath)));
            this.GeneratePluginXml(scriptOutputPath);
            this.GeneratePackageJson(c3pCordovaPackageName);
            Utils.PackNpmPackage(this.TargetOutputPath);
        }
예제 #8
0
파일: PluginLinker.cs 프로젝트: runt18/c3p
        internal static void CopyNativeProjects(string sourcePath, string[] includeProjects, string targetPath)
        {
            foreach (string platform in new[]
            {
                PluginInfo.AndroidPlatformName,
                PluginInfo.IOSPlatformName,
                PluginInfo.WindowsPlatformName
            })
            {
                string platformSourcePath = Path.Combine(sourcePath, platform);
                if (!Directory.Exists(platformSourcePath))
                {
                    continue;
                }

                string platformTargetPath = Path.Combine(targetPath, platform);
                if (!Directory.Exists(platformTargetPath))
                {
                    Directory.CreateDirectory(platformTargetPath);
                }

                if (platform == PluginInfo.AndroidPlatformName)
                {
                    Log.Message(Utils.EnsureTrailingSlash(Path.GetFullPath(platformTargetPath)));
                    foreach (string projectFile in new[]
                    {
                        "build.gradle",
                        "gradle.properties",
                        "gradlew",
                        "gradlew.bat",
                        "settings.gradle",
                    })
                    {
                        Log.Message("    " + projectFile);
                        File.Copy(
                            Path.Combine(platformSourcePath, projectFile),
                            Path.Combine(platformTargetPath, projectFile),
                            true);
                    }

                    foreach (string projectDirectory in Directory.GetDirectories(platformSourcePath))
                    {
                        string directoryName = Path.GetFileName(projectDirectory);
                        if (directoryName != "build" && directoryName != ".idea" && directoryName != ".gradle" &&
                            (directoryName == "gradle" || includeProjects == null ||
                             includeProjects.Any(p => p.Equals(directoryName, StringComparison.OrdinalIgnoreCase))))
                        {
                            PluginLinker.CopyProjectDirectory(
                                projectDirectory, Path.Combine(platformTargetPath, directoryName));
                        }
                    }
                }
                else if (platform == PluginInfo.IOSPlatformName)
                {
                    foreach (string projectDirectory in Directory.GetDirectories(platformSourcePath))
                    {
                        string directoryName = Path.GetFileName(projectDirectory);
                        string projectName   = directoryName;

                        if (projectName.EndsWith(".xcodeproj"))
                        {
                            projectName = projectName.Substring(0, projectName.Length - ".xcodeproj".Length);
                        }

                        if (projectName.StartsWith("C3P") && projectName != "C3P")
                        {
                            projectName = projectName.Substring("C3P".Length);
                        }

                        if (directoryName != "build" && directoryName != "sharpie-build" && (includeProjects == null ||
                                                                                             includeProjects.Any(p => p.Equals(projectName, StringComparison.OrdinalIgnoreCase))))
                        {
                            PluginLinker.CopyProjectDirectory(
                                projectDirectory, Path.Combine(platformTargetPath, directoryName));
                        }
                    }
                }
                else if (platform == PluginInfo.WindowsPlatformName)
                {
                    // TODO: Copy Windows project files.
                }
            }
        }
예제 #9
0
파일: Program.cs 프로젝트: runt18/c3p
        public static int Main(string[] args)
        {
            try
            {
                Arguments parsedArgs = new Arguments();
                if (!ParseArgs(args, parsedArgs) || parsedArgs.ShowHelp ||
                    (parsedArgs.CompilePlatform == null && parsedArgs.LinkTarget == null && parsedArgs.Pack == null))
                {
                    ShowHelp(parsedArgs.ShowHelp);
                    return(parsedArgs.ShowHelp ? 0 : 1);
                }

                Log.IsVerboseOutputEnabled = parsedArgs.VerboseConsoleOutput;

                if (parsedArgs.CompilePlatform != null)
                {
                    string[]    compilePlatformParts = parsedArgs.CompilePlatform.Split('-');
                    ApiCompiler apiCompiler          = ApiCompiler.Create(compilePlatformParts[0]);
                    apiCompiler.SourcePath         = parsedArgs.SourcePath;
                    apiCompiler.DebugConfiguration = !parsedArgs.ReleaseConfiguration;
                    apiCompiler.IntermediatePath   = parsedArgs.IntermediatePaths.FirstOrDefault();
                    apiCompiler.SkipNativeBuild    = parsedArgs.SkipNativeBuild;

                    if (compilePlatformParts.Length == 2)
                    {
                        apiCompiler.Language = compilePlatformParts[1];
                    }

                    apiCompiler.Run();
                }

                if (parsedArgs.LinkTarget != null)
                {
                    PluginLinker pluginLinker = PluginLinker.Create(parsedArgs.LinkTarget);
                    pluginLinker.SourcePath         = parsedArgs.SourcePath;
                    pluginLinker.IntermediatePaths  = parsedArgs.IntermediatePaths;
                    pluginLinker.OutputPath         = parsedArgs.OutputPath;
                    pluginLinker.DebugConfiguration = !parsedArgs.ReleaseConfiguration;
                    pluginLinker.Run();
                }

                if (parsedArgs.Pack != null)
                {
                    PluginLibPackager packager = PluginLibPackager.Create(parsedArgs.Pack);
                    packager.SourcePath = parsedArgs.SourcePath;
                    packager.OutputPath = parsedArgs.OutputPath;
                    packager.Run();
                }

                return(0);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Error.WriteLine(ex);
                Console.ResetColor();
                return(1);
            }
            finally
            {
#if DEBUG
                if (System.Diagnostics.Debugger.IsAttached)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("Press enter to quit.");
                    Console.ResetColor();
                    Console.ReadLine();
                }
#endif
            }
        }