/// <exception cref="SocketException" />
        /// <exception cref="UnableToResolveHostNameException" />
        /// <exception cref="BuildFailed" />
        /// <exception cref="RunFailed" />
        public void BuildAndRunExported(PreviewArguments args, IMessagingService client, IFileSystem shell, IFuse fuse)
        {
            var buildEvents = new Subject <IBinaryMessage>();

            var builder = UnoBuildWrapper.Create(
                shell, fuse.Version, buildEvents, false,
                new MissingRequiredPackageReferences(),
                new InstallAndroidRequired());

            var projectId = ProjectIdComputer.IdFor(args.Project);

            using (PushEventsToDaemon.Start(buildEvents, client, args.Project, projectId, GetBuildTarget(args.Target)))
                using (buildEvents.Subscribe(_output.WriteBuildEvent))
                {
                    if (args.Endpoints.Count == 0)
                    {
                        args = args.AddEndpoints(GetProxyEndPoints());
                    }

                    var build = builder
                                .LoadOrBuildRunnable(args, CancellationToken.None)
                                .GetResultAndUnpackExceptions();

                    if (args.CompileOnly == false)
                    {
                        build.Run(buildEvents.ToProgress());
                    }
                }
        }
Exemple #2
0
        Task <IMessagingService> GetMessagingService(PreviewArguments args)
        {
            if (args.CompileOnly)
            {
                return(Task.FromResult((IMessagingService) new NullMessagingService()));
            }

            return(_fuse.ConnectOrSpawnAsync(
                       identifier: "Preview " + args.Project.NativePath));
        }
Exemple #3
0
        async Task LaunchDesignerAndSubscribe(PreviewArguments args)
        {
            var client = await GetMessagingService(args);

            var projectId = ProjectIdComputer.IdFor(args.Project);
            var closed    = SubscribeForProjectClosed(client, projectId);

            SubscribeForBuildStarted(client, projectId);
            SubscribeForLog(client, projectId);

            var openArgs = args.Project.ToString().Yield()
                           .Concat(args.Defines.Select(d => "-D" + d))
                           .Concat(args.IsVerboseBuild ? Optional.Some("-v") : Optional.None())
                           .ToArray();

            _fuse.Report.Info("Opening " + string.Join(",", openArgs.Select(a => "'" + a + "'")), ReportTo.LogAndUser);
            _fuse.StartFuse("open", openArgs);
            await closed;
        }
Exemple #4
0
        /// <exception cref="FailedToSpawnDaemon" />
        /// <exception cref="FailedToConnectToDaemon" />
        /// <exception cref="FailedToGreetDaemon" />
        /// <exception cref="FailedToCreateOutputDir"></exception>
        public void Preview(PreviewArguments args)
        {
            _fuse.Report.Info("Starting preview for " + args.Project + ", target " + args.Target, ReportTo.LogAndUser);

            if (args.PrintUnoConfig)
            {
                UnoConfigCommand.PrintUnoConfig(UnoConfig.Current, _textWriter);
            }

            if (args.Target == PreviewTarget.Local)
            {
                LaunchDesignerAndSubscribe(args).Wait();
                return;
            }

            var client = GetMessagingService(args).ToObservable().Switch();

            _exportedPreview.BuildAndRunExported(args, client, _shell, _fuse);
        }
        public static async System.Threading.Tasks.Task <ExportBuild> LoadOrBuildRunnable(this UnoBuildWrapper self, PreviewArguments args, CancellationToken cancellationToken)
        {
            var id          = Guid.NewGuid();
            var buildResult = await self.BuildUno(id,
                                                  new BuildProject(
                                                      args.Project.NativePath,
                                                      args.Defines.ToImmutableList(),
                                                      args.BuildLibraries,
                                                      args.IsVerboseBuild),
                                                  args.Target,
                                                  args.DirectToDevice,
                                                  cancellationToken,
                                                  args.QuitAfterApkLaunch);

            return(new ExportBuild(buildResult, id));
        }