Esempio n. 1
0
        private static CommonConfigData GetConfig()
        {
            CommonConfigData config = null;
            try
            {
                config = CommonConfigData.FromFile(ApplicationPaths.CommonConfigFile);
            }
            catch (Exception ex)
            {
                MediaCenterEnvironment ev = Application.MediaCenterEnvironment;
                DialogResult r = ev.Dialog(ex.Message + "\n" + Application.CurrentInstance.StringData("ConfigErrorDial"), Application.CurrentInstance.StringData("ConfigErrorCapDial"), DialogButtons.Yes | DialogButtons.No, 600, true);
                if (r == DialogResult.Yes)
                {
                    config = new CommonConfigData(ApplicationPaths.CommonConfigFile);
                    config.Save();
                }
                else
                {
                    Application.ApplicationContext.CloseApplication();

                }
            }

            return config;
        }
        private static CommonConfigData GetConfig()
        {
            CommonConfigData config = null;

            try
            {
                config = CommonConfigData.FromFile(ApplicationPaths.CommonConfigFile);
            }
            catch (Exception ex)
            {
                MediaCenterEnvironment ev = Application.MediaCenterEnvironment;
                DialogResult           r  = ev.Dialog(ex.Message + "\n" + Application.CurrentInstance.StringData("ConfigErrorDial"), Application.CurrentInstance.StringData("ConfigErrorCapDial"), DialogButtons.Yes | DialogButtons.No, 600, true);
                if (r == DialogResult.Yes)
                {
                    config = new CommonConfigData(ApplicationPaths.CommonConfigFile);
                    config.Save();
                }
                else
                {
                    Application.ApplicationContext.CloseApplication();
                }
            }

            return(config);
        }
        public MainWindow()
        {
            // set up assembly resolution hooks, so earlier versions of the plugins resolve properly 
            AppDomain.CurrentDomain.AssemblyResolve += Kernel.OnAssemblyResolve;

            InitializeComponent();
            //_serviceConfig = ServiceConfigData.FromFile(ApplicationPaths.ServiceConfigFile);
            Async.Queue("Migration", () =>
            {
                var mbphoto = Path.Combine(ApplicationPaths.AppPluginPath, "mbphoto.classic.dll");
                if (File.Exists(mbphoto))
                    try
                    {
                        File.Delete(mbphoto);
                    }
                    catch (Exception e)
                    {
                        Logger.ReportException("Error deleting old MBPhoto plug-in", e);
                    }

                const string chocolate = @"\windows\ehome\chocolate.dll";
                if (File.Exists(chocolate))
                    try
                    {
                        File.Delete(chocolate);
                    }
                    catch (Exception e)
                    {
                        Logger.ReportException("Error deleting old chocolate plug-in", e);
                    }

                if (File.Exists(ApplicationPaths.CommonConfigFile)) _config = CommonConfigData.FromFile(ApplicationPaths.CommonConfigFile);

                if (_config == null) // only do this if a fresh install
                {
                    try
                    {
                        _config = CommonConfigData.FromFile(ApplicationPaths.CommonConfigFile); // create a new one
                        Migrate300();
                    }
                    catch (Exception e)
                    {
                        Logger.ReportException("Error during migration",e);
                    }
                    
                }
                if (_config != null)
                {
                    // Set install directory
                    _config.MBInstallDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase);
                    _config.Save();
                }
                Dispatcher.Invoke(DispatcherPriority.Background, (System.Windows.Forms.MethodInvoker)(Close));
            });
        }
        private void Initialize() {
            Instance = this;
            InitializeComponent();
            Kernel.Init(KernelLoadDirective.ShadowPlugins);
            Logger.ReportVerbose("======= Kernel intialized. Building window...");
            commonConfig = Kernel.Instance.CommonConfigData;
            PopUpMsg = new PopupMsg(alertText);

            //Logger.ReportVerbose("======= Loading combo boxes...");
            lblVersion.Content = lblVersion2.Content = "Version " + Kernel.Instance.VersionStr;

            //Logger.ReportVerbose("======= Refreshing Ext Players...");
            RefreshPlayers();

            //Logger.ReportVerbose("======= Loading Config Settings...");
            LoadConfigurationSettings();
            //Logger.ReportVerbose("======= Config Settings Loaded.");

            for (char c = 'D'; c <= 'Z'; c++) {
                daemonToolsDrive.Items.Add(c.ToString());
            }

            try {
                daemonToolsDrive.SelectedValue = commonConfig.DaemonToolsDrive;
            } catch {
                // someone bodged up the config
            }

            //daemonToolsLocation.Content = config.DaemonToolsLocation; /// old
            daemonToolsLocation.Text = commonConfig.DaemonToolsLocation;


            //Logger.ReportVerbose("======= Refreshing Extender Formats...");
            RefreshExtenderFormats();
            //Logger.ReportVerbose("======= Refreshing Display Settings...");
            RefreshDisplaySettings();
            //Logger.ReportVerbose("======= Saving Config...");
            SaveConfig();

            //Logger.ReportVerbose("======= Initialize Finised.");
        }
        private void EditExternalPlayer(CommonConfigData.ExternalPlayer externalPlayer, bool isNew)
        {
            var form = new ExternalPlayerForm(isNew) {Owner = this, WindowStartupLocation = WindowStartupLocation.CenterOwner};

            form.FillControlsFromObject(externalPlayer);

            if (form.ShowDialog() == true)
            {
                form.UpdateObjectFromControls(externalPlayer);

                if (isNew)
                {
                    commonConfig.ExternalPlayers.Add(externalPlayer);
                }

                SaveConfig();

                RefreshPlayers();

                lstExternalPlayers.SelectedItem = externalPlayer;
            }
        }
        public bool ConnectToServer(CommonConfigData config)
        {
            var connected = false;

            if (config.FindServerAutomatically)
            {
                connected = ConnectAutomatically(config.HttpTimeout);
            }
            else
            {
                //server specified
                var retries = 0;
                while (!connected && retries < 3)
                {
                    connected = Kernel.ConnectToServer(config.ServerAddress, config.ServerPort, config.HttpTimeout);
                    if (!connected) {
                        Logger.ReportInfo("Unable to connect to server at {0}. Will retry...", config.ServerAddress);
                        retries++;
                        Thread.Sleep(1500); //give it some time to wake up
                    }
                }

                if (!connected)
                {
                    Logger.ReportWarning("Unable to connect to configured server {0}:{1}. Will try automatic detection", config.ServerAddress, config.ServerPort);
                    connected = ConnectAutomatically(config.HttpTimeout);
                }
            }

            if (connected)
            {
                config.ServerPort = Kernel.ApiClient.ServerApiPort;
                config.Save();

            }

            return connected;
        }
        private void Initialize() {
            Instance = this;
            InitializeComponent();
            Kernel.Init(KernelLoadDirective.ShadowPlugins);
            if (!Kernel.ServerConnected)
            {
                Async.Queue("error", () => MessageBox.Show("Cannot connect to the MB3 server.  Please start it or configure address.", "Cannot find server"));
                // Hide plug-in tab because we can't get to them
                plugins.Visibility = Visibility.Collapsed;
            }
            else
            {
                var user = Kernel.AvailableUsers.OrderBy(u => u.Name).FirstOrDefault();
                Kernel.CurrentUser = new User { Name = user.Name, Id = new Guid(user.Id ?? ""), Dto = user, ParentalAllowed = user.HasPassword };
            }
            //Kernel.Instance.LoadUserConfig();
            Kernel.Instance.LoadPlugins();
            Logger.ReportVerbose("======= Kernel intialized. Building window...");
            commonConfig = Kernel.Instance.CommonConfigData;
            pluginList.MouseDoubleClick += pluginList_DoubleClicked;
            PopUpMsg = new PopupMsg(alertText);
            //config = Kernel.Instance.ConfigData;

            //Logger.ReportVerbose("======= Loading combo boxes...");
            LoadComboBoxes();
            lblVersion.Content = lblVersion2.Content = "Version " + Kernel.Instance.VersionStr;

            //Logger.ReportVerbose("======= Refreshing Podcasts...");
            //RefreshPodcasts();
            //Logger.ReportVerbose("======= Refreshing Ext Players...");
            RefreshPlayers();

            //Logger.ReportVerbose("======= Loading Config Settings...");
            LoadConfigurationSettings();
            //Logger.ReportVerbose("======= Config Settings Loaded.");

            for (char c = 'D'; c <= 'Z'; c++) {
                daemonToolsDrive.Items.Add(c.ToString());
            }

            try {
                daemonToolsDrive.SelectedValue = commonConfig.DaemonToolsDrive;
            } catch {
                // someone bodged up the config
            }

            //daemonToolsLocation.Content = config.DaemonToolsLocation; /// old
            daemonToolsLocation.Text = commonConfig.DaemonToolsLocation;


            //Logger.ReportVerbose("======= Refreshing Extender Formats...");
            RefreshExtenderFormats();
            //Logger.ReportVerbose("======= Refreshing Display Settings...");
            RefreshDisplaySettings();
            //Logger.ReportVerbose("======= Saving Config...");
            SaveConfig();

            LoadAvailablePlugins();
            //Logger.ReportVerbose("======= Kicking off validations thread...");
            //Async.Queue("Startup Validations", () =>
            //{
            //    //RefreshEntryPoints(false);
            //    ValidateMBAppDataFolderPermissions();
            //});
            //Logger.ReportVerbose("======= Initialize Finised.");
        }
        /// <summary>
        /// Detmines if a given external player configuration is configured to play:
        /// - ALL of MediaTypes supplied. This filter is ignored if an empty list is provided.
        /// - All of the VideoFormats supplied. This filter is ignored if an empty list is provided.
        /// - And is able to play the number of files requested
        /// </summary>
        public static bool CanPlay(CommonConfigData.ExternalPlayer externalPlayer, IEnumerable<MediaType> mediaTypes, IEnumerable<VideoFormat> videoFormats, bool isMultiFile)
        {
            // Check options to see if this is not a match
            if (Application.RunningOnExtender)
            {
                return false;
            }

            // If it's not even capable of playing multiple files in sequence, it's no good
            if (isMultiFile && !externalPlayer.SupportsMultiFileCommandArguments && !externalPlayer.SupportsPlaylists)
            {
                return false;
            }

            // If configuration wants specific MediaTypes, check that here
            // If no MediaTypes are specified, proceed
            foreach (MediaType mediaType in mediaTypes)
            {
                if (!externalPlayer.MediaTypes.Contains(mediaType))
                {
                    return false;
                }
            }

            // If configuration wants specific VideoFormats, check that here
            // If no VideoFormats are specified, proceed
            foreach (VideoFormat format in videoFormats)
            {
                if (!externalPlayer.VideoFormats.Contains(format))
                {
                    return false;
                }
            }

            return true;
        }
        /// <summary>
        /// Determines if a given external player configuration is configured to play a list of files
        /// </summary>
        public static bool CanPlay(CommonConfigData.ExternalPlayer player, IEnumerable<Media> mediaList)
        {
            var types = new List<MediaType>();
            var formats = new List<VideoFormat>();

            foreach (var media in mediaList)
            {
                var video = media as Video;

                if (video != null)
                {
                    if (!string.IsNullOrEmpty(video.VideoFormat))
                    {
                        var format = (VideoFormat)Enum.Parse(typeof(VideoFormat), video.VideoFormat);
                        formats.Add(format);
                    }

                }

                types.Add(media.MediaType);
            }

            bool isMultiFile = mediaList.Count() == 1 ? (mediaList.First().Files.Count() > 1) : (mediaList.Count() > 1);

            return CanPlay(player, types, formats, isMultiFile);
        }
        /// <summary>
        /// Determines if a given external player configuration is configured to play a list of files
        /// </summary>
        public static bool CanPlay(CommonConfigData.ExternalPlayer player, IEnumerable<string> files)
        {
            IEnumerable<MediaType> types = files.Select(f => MediaTypeResolver.DetermineType(f));

            // See if there's a configured player matching the ExternalPlayerType and MediaType. 
            // We're not able to evaluate VideoFormat in this scenario
            // If none is found it will return null
            return CanPlay(player, types, new List<VideoFormat>(), files.Count() > 1);
        }