/// <summary>
/// Initializes the singleton intances of the mod manager.
/// </summary>
/// <param name="p_gmdGameMode">The current game mode.</param>
/// <param name="p_eifEnvironmentInfo">The application's envrionment info.</param>
/// <param name="p_mrpModRepository">The mod repository from which to get mods and mod metadata.</param>
/// <param name="p_dmrMonitor">The download monitor to use to track task progress.</param>
/// <param name="p_frgFormatRegistry">The <see cref="IModFormatRegistry"/> that contains the list
/// of supported <see cref="IModFormat"/>s.</param>
/// <param name="p_mrgModRegistry">The <see cref="ModRegistry"/> that contains the list
/// of managed <see cref="IMod"/>s.</param>
/// <param name="p_futFileUtility">The file utility class.</param>
/// <param name="p_scxUIContext">The <see cref="SynchronizationContext"/> to use to marshall UI interactions to the UI thread.</param>
/// <param name="p_ilgInstallLog">The install log tracking mod activations for the current game mode.</param>
/// <param name="p_pmgPluginManager">The plugin manager to use to work with plugins.</param>
/// <returns>The initialized mod manager.</returns>
/// <exception cref="InvalidOperationException">Thrown if the mod manager has already
/// been initialized.</exception>
public static ModManager Initialize(IGameMode p_gmdGameMode, IEnvironmentInfo p_eifEnvironmentInfo, IModRepository p_mrpModRepository, DownloadMonitor p_dmrMonitor, ActivateModsMonitor p_ammMonitor, IModFormatRegistry p_frgFormatRegistry, ModRegistry p_mrgModRegistry, FileUtil p_futFileUtility, SynchronizationContext p_scxUIContext, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager)
{
if (m_mmgCurrent != null)
throw new InvalidOperationException("The Mod Manager has already been initialized.");
m_mmgCurrent = new ModManager(p_gmdGameMode, p_eifEnvironmentInfo, p_mrpModRepository, p_dmrMonitor, p_ammMonitor, p_frgFormatRegistry, p_mrgModRegistry, p_futFileUtility, p_scxUIContext, p_ilgInstallLog, p_pmgPluginManager);
return m_mmgCurrent;
}
private IEnumerable<IFileProvider> GetPluginFileProviders(IPluginManager pluginManager, string subfolder)
{
foreach (var pluginInfo in pluginManager.LoadedPlugins)
{
yield return new PluginFileProvider(pluginInfo, subfolder, null);
}
}
public SettingsManager(IApplicationState state, IPluginManager pluginManager, IApplicationConfig config, ApplicationSettingsBase settings)
{
_settings = settings;
_state = state;
_pluginManager = pluginManager;
_config = config;
}
public void Init(HttpApplication context)
{
context.PreRequestHandlerExecute += ContextOnBeginRequest;
_pluginManager = Services.Get<IPluginManager>();
_pluginManager.AfterConfigurationChanged += PluginManagerAfterConfigurationChanged;
}
public PluginCompositeFileProvider(IPluginManager pluginManager, IFileProvider defaultFileProvider, string subfolder=null)
{
var pluginsFileProviders = new List<IFileProvider>(pluginManager.LoadedPlugins.Count()+1);
pluginsFileProviders.Add(defaultFileProvider);
pluginsFileProviders.AddRange(GetPluginFileProviders(pluginManager, subfolder));
_fileProvider = new CompositeFileProvider(pluginsFileProviders);
}
/// <summary>
/// A simple constructor that initializes the object with its dependencies.
/// </summary>
/// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param>
/// <param name="p_modMod">The mod being installed.</param>
/// <param name="p_ilgInstallLog">The install log to use to log file installations.</param>
/// <param name="p_pmgPluginManager">The plugin manager.</param>
/// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param>
/// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param>
/// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param>
/// <param name="p_UsesPlugins">Game using plugin or mods (True for plugins).</param>
public ModFileUpgradeInstaller(IGameModeEnvironmentInfo p_gmiGameModeInfo, IMod p_modMod, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, IDataFileUtil p_dfuDataFileUtility, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate, bool p_UsesPlugins)
: base(p_gmiGameModeInfo, p_modMod, p_ilgInstallLog, p_pmgPluginManager, p_dfuDataFileUtility, p_tfmFileManager, p_dlgOverwriteConfirmationDelegate, p_UsesPlugins, null)
{
OriginallyInstalledFiles = new Set<string>(StringComparer.OrdinalIgnoreCase);
foreach (string strFile in InstallLog.GetInstalledModFiles(Mod))
OriginallyInstalledFiles.Add(strFile.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
}
public MenuViewModel(IApplicationState state, IPluginManager pluginManager, IApplicationConfig config, IPresetsManager presetManager)
{
_pluginManager = pluginManager;
_state = state;
_config = config;
_presetsManager = presetManager;
//Commands
_openCommand = new DelegateCommand(Open);
_openFileCommand = new DelegateCommand(OpenFile);
_openStreamCommand = new DelegateCommand(OpenStream);
_openDiscCommand = new DelegateCommand(OpenDisc);
_openDeviceCommand = new DelegateCommand(OpenDevice);
_openProcessCommand = new DelegateCommand(OpenProcess);
_browseSamplesCommand = new DelegateCommand(BrowseSamples);
_exitCommand = new DelegateCommand(Exit);
_changeFormatCommand = new DelegateCommand(SetStereoInput);
_changeProjectionCommand = new DelegateCommand(SetProjection);
_changeEffectCommand = new DelegateCommand(SetEffect);
_changeLayoutCommand = new DelegateCommand(SetStereoOutput);
_changeDistortionCommand = new DelegateCommand(SetDistortion);
_changeTrackerCommand = new DelegateCommand(SetTracker);
_saveMediaPresetCommand = new DelegateCommand(SaveMediaPreset);
_saveDevicePresetCommand = new DelegateCommand(SaveDevicePreset);
_saveAllPresetCommand = new DelegateCommand(SaveAllPreset);
_loadMediaPresetCommand = new DelegateCommand(LoadMediaPreset);
_resetPresetCommand = new DelegateCommand(ResetPreset);
_settingsCommand = new DelegateCommand(ShowSettings);
_launchWebBrowserCommand = new DelegateCommand(LaunchWebBrowser);
_aboutCommand = new DelegateCommand(ShowAbout);
}
/// <summary>
/// Performs all the operations needed to init the plugin/App
/// </summary>
/// <param name="user">singleton instance of UserPlugin</param>
/// <param name="rootPath">path where the config files can be found</param>
/// <returns>true if the user is already logged in; false if still logged out</returns>
public static bool InitApp(UserClient user, string rootPath, IPluginManager pluginManager)
{
if (user == null)
return false;
// initialize the config file
Snip2Code.Utils.AppConfig.Current.Initialize(rootPath);
log = LogManager.GetLogger("ClientUtils");
// login the user
bool res = user.RetrieveUserPreferences();
bool loggedIn = false;
if (res && ((!BaseWS.Username.IsNullOrWhiteSpaceOrEOF()) || (!BaseWS.IdentToken.IsNullOrWhiteSpaceOrEOF())))
{
LoginPoller poller = new LoginPoller(BaseWS.Username, BaseWS.Password, BaseWS.IdentToken, BaseWS.UseOneAll,
pluginManager);
LoginTimer = new System.Threading.Timer(poller.RecallLogin, null, 0, AppConfig.Current.LoginRefreshTimeSec * 1000);
loggedIn = true;
}
System.Threading.ThreadPool.QueueUserWorkItem(delegate
{
user.LoadSearchHistoryFromFile();
}, null);
//set the empty profile picture for search list results:
PictureManager.SetEmptyProfilePic(rootPath);
return loggedIn;
}
public ZvsEngine(IFeedback<LogEntry> feedback, IAdapterManager adapterManager, IPluginManager pluginManager,
IEntityContextConnection entityContextConnection, TriggerRunner triggerRunner, ScheduledTaskRunner scheduledTaskRunner)
{
if (entityContextConnection == null)
throw new ArgumentNullException("entityContextConnection");
if (feedback == null)
throw new ArgumentNullException("feedback");
if (adapterManager == null)
throw new ArgumentNullException("adapterManager");
if (pluginManager == null)
throw new ArgumentNullException("pluginManager");
if (triggerRunner == null)
throw new ArgumentNullException("triggerRunner");
if (scheduledTaskRunner == null)
throw new ArgumentNullException("scheduledTaskRunner");
EntityContextConnection = entityContextConnection;
Log = feedback;
AdapterManager = adapterManager;
PluginManager = pluginManager;
TriggerRunner = triggerRunner;
ScheduledTaskRunner = scheduledTaskRunner;
Log.Source = "Zvs Engine";
AppDomain.CurrentDomain.SetData("DataDirectory", Utils.AppDataPath);
}
/// <summary>
/// Initializes the singleton intances of the mod manager.
/// </summary>
/// <param name="p_gmdGameMode">The current game mode.</param>
/// <param name="p_mprManagedPluginRegistry">The <see cref="PluginRegistry"/> that contains the list
/// of managed <see cref="Plugin"/>s.</param>
/// <param name="p_aplPluginLog">The <see cref="ActivePluginLog"/> tracking plugin activations for the
/// current game mode.</param>
/// <param name="p_polOrderLog">The <see cref="IPluginOrderLog"/> tracking plugin order for the
/// current game mode.</param>
/// <param name="p_povOrderValidator">The object that validates plugin order.</param>
/// <exception cref="InvalidOperationException">Thrown if the plugin manager has already
/// been initialized.</exception>
public static IPluginManager Initialize(IGameMode p_gmdGameMode, PluginRegistry p_mprManagedPluginRegistry, ActivePluginLog p_aplPluginLog, IPluginOrderLog p_polOrderLog, IPluginOrderValidator p_povOrderValidator)
{
if (m_pmgCurrent != null)
throw new InvalidOperationException("The Plugin Manager has already been initialized.");
m_pmgCurrent = new PluginManager(p_gmdGameMode, p_mprManagedPluginRegistry, p_aplPluginLog, p_polOrderLog, p_povOrderValidator);
return m_pmgCurrent;
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
/// <param name="application">The photon application instance the game belongs to.</param>
/// <param name="gameId">The game id.</param>
/// <param name="roomCache">The room cache the game belongs to.</param>
/// <param name="pluginManager">plugin creator</param>
/// <param name="pluginName">Plugin name which client expects to be loaded</param>
/// <param name="environment">different environment parameters</param>
/// <param name="executionFiber">Fiber which will execute all rooms actions</param>
public Game(
GameApplication application,
string gameId,
Hive.Caching.RoomCacheBase roomCache = null,
IPluginManager pluginManager = null,
string pluginName = "",
Dictionary<string, object> environment = null,
ExtendedPoolFiber executionFiber = null
)
: base(gameId,
roomCache,
null,
GameServerSettings.Default.MaxEmptyRoomTTL,
pluginManager,
pluginName,
environment,
GameServerSettings.Default.LastTouchSecondsDisconnect * 1000,
GameServerSettings.Default.LastTouchCheckIntervalSeconds * 1000,
DefaultHttpRequestQueueOptions,
executionFiber)
{
this.Application = application;
if (this.Application.AppStatsPublisher != null)
{
this.Application.AppStatsPublisher.IncrementGameCount();
}
this.HttpForwardedOperationsLimit = GameServerSettings.Default.HttpForwardLimit;
}
public void Initialize(IPluginManager pluginManager)
{
foreach (var instance in pluginManager.Plugins<IBaseAjaxNamespace>().Select(ajaxNamespace => ajaxNamespace.Value))
{
this.RegisterNamespace(instance.PluginInfo["namespace"], instance);
}
}
public TestGame(string roomId, Caching.RoomCacheBase parent, int emptyRoomTTL, IPluginManager eManager, string pluginName)
: base(roomId, parent, new TestGameStateFactory(), emptyRoomTTL, eManager, pluginName)
{
//this.IsOpen = true;
//this.IsVisible = true;
//this.EventCache.SetGameAppCounters(NullHiveGameAppCounters.Instance);
//this.EventCache.AddSlice(0);
}
public LoginPoller(string username, string password, string identToken, bool useOneAll, IPluginManager pluginManager)
{
this.username = username;
this.password = password;
this.identToken = identToken;
this.useOneAll = useOneAll;
this.pluginManager = pluginManager;
}
/// <summary>
/// A sinmple constructor that initializes the object with the given values.
/// </summary>
/// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param>
/// <param name="p_mfiFileInstaller">The installer to use to install files.</param>
/// <param name="p_iniIniInstaller">The installer to use to install INI values.</param>
/// <param name="p_gviGameSpecificValueInstaller">The installer to use to install game specific values.</param>
/// <param name="p_pmgPluginManager">The manager to use to manage plugins.</param>
public InstallerGroup(IDataFileUtil p_dfuDataFileUtility, IModFileInstaller p_mfiFileInstaller, IIniInstaller p_iniIniInstaller, IGameSpecificValueInstaller p_gviGameSpecificValueInstaller, IPluginManager p_pmgPluginManager)
{
DataFileUtility = p_dfuDataFileUtility;
FileInstaller = p_mfiFileInstaller;
IniInstaller = p_iniIniInstaller;
GameSpecificValueInstaller = p_gviGameSpecificValueInstaller;
PluginManager = p_pmgPluginManager;
}
public SettingsWindowViewModel(IApplicationState state, IApplicationConfig config, IPluginManager pluginManager)
{
_state = state;
_config = config;
_pluginManager = pluginManager;
_changeSamplePathCommand = new DelegateCommand(ChangeSamplePath);
}
public ViewModelFactory(IApplicationConfig config, IPluginManager pluginManager, IApplicationState state, IPresetsManager presetsManager, IMediaService mediaService)
{
_config = config;
_pluginManager = pluginManager;
_state = state;
_presetsManager = presetsManager;
_mediaService = mediaService;
}
public StebsHub(IConstants constants, IMpm mpm, IProcessorManager manager, IFileManager fileManager, IPluginManager pluginManager)
{
this.Constants = constants;
this.Mpm = mpm;
this.Manager = manager;
this.FileManager = fileManager;
this.PluginManager = pluginManager;
}
/// <summary>
/// A simple constructor that initializes the object with the given values.
/// </summary>
/// <param name="p_modMod">The mod being installed.</param>
/// <param name="p_gmdGameMode">The the current game mode.</param>
/// <param name="p_mfiFileInstaller">The file installer to use.</param>
/// <param name="p_pmgPluginManager">The plugin manager.</param>
/// <param name="p_booSkipReadme">Whether to skip the installation of readme files.</param>
/// <param name="p_rolActiveMods">The list of active mods.</param>
public BasicInstallTask(IMod p_modMod, IGameMode p_gmdGameMode, IModFileInstaller p_mfiFileInstaller, IPluginManager p_pmgPluginManager, bool p_booSkipReadme, ReadOnlyObservableList<IMod> p_rolActiveMods)
{
Mod = p_modMod;
GameMode = p_gmdGameMode;
FileInstaller = p_mfiFileInstaller;
PluginManager = p_pmgPluginManager;
SkipReadme = p_booSkipReadme;
ActiveMods = p_rolActiveMods;
}
public DevelopmentManager(IEventManager eventManager, IPluginManager pluginManager)
{
// Create the logged in user's specific instance of the user manager proxy.
// The actual implementation class could be changed in configuration
// or using dependency injection (if we want to implement that)...
_eventManager = eventManager;
_pluginManager = pluginManager;
_commonManagerProxy = new CommonManagerProxy(this);
}
private async Task Work(IMacroEngine Macro, IPluginManager Plugins)
{
foreach (var c in Enumerable.Range(0, this.Loop))
{
await this.SendAndWait(Macro, this.Word, 50);
Macro.Display(c.ToString());
}
Macro.Display("completed");
}
public static RazorViewEngineOptions ConfigurePluginsView( this RazorViewEngineOptions options, IPluginManager pluginManager)
{
options.ViewLocationExpanders.Insert(0, new PluginViewLocationExtender());
foreach (var pluginInfo in pluginManager.LoadedPlugins)
{
options.FileProviders.Add(new PluginFileProvider(pluginInfo, "Views", "Views"));
}
return options;
}
public HiveHostGame(
string gameName,
RoomCacheBase roomCache,
IGameStateFactory gameStateFactory = null,
int maxEmptyRoomTTL = 0,
IPluginManager pluginManager = null,
string pluginName = "",
Dictionary<string, object> environment = null,
int lastTouchLimitMilliseconds = 0,
int lastTouchCheckIntervalMilliseconds = 0,
HttpRequestQueueOptions httpRequestQueueOptions = null,
ExtendedPoolFiber executionFiber = null
)
: base(gameName, roomCache, gameStateFactory, maxEmptyRoomTTL, lastTouchLimitMilliseconds, lastTouchCheckIntervalMilliseconds, executionFiber)
{
this.pluginManager = pluginManager;
if (httpRequestQueueOptions == null)
{
httpRequestQueueOptions = new HttpRequestQueueOptions();
}
this.httpRequestQueue.MaxErrorRequests = httpRequestQueueOptions.HttpQueueMaxTimeouts;
this.httpRequestQueue.MaxTimedOutRequests = httpRequestQueueOptions.HttpQueueMaxErrors;
this.httpRequestQueue.ReconnectInterval = TimeSpan.FromMilliseconds(httpRequestQueueOptions.HttpQueueReconnectInterval);
this.httpRequestQueue.QueueTimeout = TimeSpan.FromMilliseconds(httpRequestQueueOptions.HttpQueueQueueTimeout);
this.httpRequestQueue.MaxQueuedRequests = httpRequestQueueOptions.HttpQueueMaxQueuedRequests;
this.httpRequestQueue.MaxBackoffInMilliseconds = httpRequestQueueOptions.HttpQueueMaxBackoffTime;
this.httpRequestQueue.MaxConcurrentRequests = httpRequestQueueOptions.HttpQueueMaxConcurrentRequests;
this.httpQueueRequestTimeout = httpRequestQueueOptions.HttpQueueRequestTimeout;
this.httpRequestQueue.SetCounters(this);
this.Environment = environment ?? new Dictionary<string, object>
{
{"AppId", GetHwId()},
{"AppVersion", ""},
{"Region", ""},
{"Cloud", ""},
};
this.InitPlugin(pluginName);
if (this.Plugin == null)
{
throw new Exception(string.Format("Failed to craete plugin '{0}'", pluginName));
}
var errorPlugin = this.Plugin as ErrorPlugin;
if (errorPlugin != null)
{
Log.ErrorFormat("Game {0} is created with ErrorPlugin. message:{1}", this.Name, errorPlugin.Message);
}
this.customTypeCache.TypeMapper = this;
this.callEnv = new CallEnv(this.Plugin, this.Name);
}
/// <summary>
/// A simple constructor that initializes the factory with the required dependencies.
/// </summary>
/// <param name="p_gmdGameMode">The game mode for which the created installer will be installing mods.</param>
/// <param name="p_eifEnvironmentInfo">The application's envrionment info.</param>
/// <param name="p_futFileUtility">The file utility class.</param>
/// <param name="p_scxUIContext">The <see cref="SynchronizationContext"/> to use to marshall UI interactions to the UI thread.</param>
/// <param name="p_ilgInstallLog">The install log that tracks mod install info
/// for the current game mode.</param>
/// <param name="p_pmgPluginManager">The plugin manager to use to work with plugins.</param>
public ModInstallerFactory(IGameMode p_gmdGameMode, IEnvironmentInfo p_eifEnvironmentInfo, FileUtil p_futFileUtility, SynchronizationContext p_scxUIContext, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, ModManager p_mmModManager)
{
m_gmdGameMode = p_gmdGameMode;
m_eifEnvironmentInfo = p_eifEnvironmentInfo;
m_futFileUtility = p_futFileUtility;
m_scxUIContext = p_scxUIContext;
m_ilgInstallLog = p_ilgInstallLog;
m_pmgPluginManager = p_pmgPluginManager;
m_mmModManager = p_mmModManager;
}
/// <summary>
/// Constructor to initialize all stuff
/// </summary>
/// <param name="aConfiguration">Reference to the the Configuration object</param>
public Settings(Configuration aConfiguration, IPluginManager aPluginManager)
{
_myConfiguration = aConfiguration;
_myConfiguration.AddObserver(this);
_pluginManager = aPluginManager;
_converter = new System.Windows.Forms.KeysConverter();
_cultConvert = new CultureInfoConverter();
InitializeComponent();
WriteThanks();
}
/// <summary>
/// A simple constructor that initializes the object with its dependencies.
/// </summary>
/// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param>
/// <param name="p_modMod">The mod being installed.</param>
/// <param name="p_ilgInstallLog">The install log to use to log file installations.</param>
/// <param name="p_pmgPluginManager">The plugin manager.</param>
/// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param>
/// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param>
/// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param>
/// <param name="p_UsesPlugins">Whether the file is a mod or a plugin.</param>
public ModFileInstaller(IGameModeEnvironmentInfo p_gmiGameModeInfo, IMod p_modMod, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, IDataFileUtil p_dfuDataFileUtility, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate, bool p_UsesPlugins)
{
GameModeInfo = p_gmiGameModeInfo;
Mod = p_modMod;
InstallLog = p_ilgInstallLog;
PluginManager = p_pmgPluginManager;
DataFileUtility = p_dfuDataFileUtility;
TransactionalFileManager = p_tfmFileManager;
m_dlgOverwriteConfirmationDelegate = p_dlgOverwriteConfirmationDelegate ?? ((s, b, m) => OverwriteResult.No);
IsPlugin = p_UsesPlugins;
}
public Bot(IClient client, IStorageManager storage, ICommandManager command, IPluginManager plugin,
IAuthenticationManager authentication, IPermissionManager permission)
{
_client = client;
_storage = storage;
_command = command;
_plugin = plugin;
_authentication = authentication;
_permission = permission;
_data = storage.Global().GetOrCreate<BotData>(_storageIdentifier);
_replyHandler = new ReplyHandler(this, _data);
_messsageHandler = new MessageHandler(this, _replyHandler, _data);
}
/////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a new AddSnippet Form and precompiles this form with the selected text
/// </summary>
/// <param name="pluginManager"></param>
public static IManageSnippetForm PrepareAddNewSnippetForm(IPluginManager pluginManager)
{
if (pluginManager == null)
return null;
// Manage editor selection
string selText = pluginManager.RetrieveSelectedText();
// Open "Add Snippet" Window
pluginManager.ClosePublishSnippetWindow();
IManageSnippetForm addSnipForm = pluginManager.CreateAddSnippetForm();
if (addSnipForm != null)
addSnipForm.PrepareAddNewSnippet(selText);
return addSnipForm;
}
public SystemsManager( IPluginManager pluginManager, ILogManager logManager, INGinCore core, IMainLoopManager mainLoopManager )
{
this.LogManager = logManager;
foreach ( SystemAttribute plugin in pluginManager.GetPluginsForType( typeof( SystemAttribute ) ) )
{
// create and store system
//ConstructorInfo constructor = plugin.SystemType.GetConstructor( plugin.ConstructorParameterTypes );
//ISystem system = plugin.SystemType.InvokeMember( plugin.SystemType.Name, global::System.Reflection.BindingFlags.CreateInstance, null, null, new object[] { this.LogManager } ) as ISystem;
ISystem system = core.GetService( plugin.SystemType ) as ISystem;
lock ( this.registeredSystemsLock )
{
this.registeredSystems.Add( system.Name, system );
}
}
}
public SettingsViewModel(
ISettingsProvider settingsService,
IWindowManager windowManager,
IEventAggregator eventAggregator,
Func<BlogSettingsViewModel> blogSettingsCreator,
IPluginManager pluginManager,
Func<IPlugin, PluginViewModel> pluginViewModelCreator,
ISpellingService spellingService)
{
this.settingsService = settingsService;
this.windowManager = windowManager;
this.eventAggregator = eventAggregator;
this.blogSettingsCreator = blogSettingsCreator;
this.pluginManager = pluginManager;
this.pluginViewModelCreator = pluginViewModelCreator;
this.spellingService = spellingService;
this.pluginManager.Container.ComposeParts(this);
}
public AlbumDownloadEvent(IPluginManager pluginManager, IConfigurationManager configMgr)
{
_pluginManager = pluginManager;
_configMgr = configMgr;
}
public IPluginState CreatePluginState(IPluginManager pluginManager)
{
return(new NcchState());
}
public ConfigController(IHostApplicationLifetime hostApplicationLifetime, IAuthManager authManager, IPluginManager pluginManager, ISiteRepository siteRepository, IChannelRepository channelRepository)
{
_hostApplicationLifetime = hostApplicationLifetime;
_authManager = authManager;
_pluginManager = pluginManager;
_siteRepository = siteRepository;
_channelRepository = channelRepository;
}
public AddLayerUploadController(IHostApplicationLifetime hostApplicationLifetime, ISettingsManager settingsManager, IAuthManager authManager, IPathManager pathManager, IPluginManager pluginManager)
{
_hostApplicationLifetime = hostApplicationLifetime;
_settingsManager = settingsManager;
_authManager = authManager;
_pathManager = pathManager;
_pluginManager = pluginManager;
}
public IPluginState CreatePluginState(IPluginManager pluginManager)
{
return(new AAPackState());
}
/// <summary>
/// Plugin constructor.
/// </summary>
/// <param name="pluginManager">PluginManager object</param>
protected Plugin(IPluginManager pluginManager)
{
PluginManager = pluginManager;
}
/// <summary>
/// A simple constructor that initializes the object with its dependencies.
/// </summary>
/// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param>
/// <param name="p_modMod">The mod being installed.</param>
/// <param name="p_ilgInstallLog">The install log to use to log file installations.</param>
/// <param name="p_pmgPluginManager">The plugin manager.</param>
/// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param>
/// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param>
/// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param>
/// <param name="p_UsesPlugins">Whether the file is a mod or a plugin.</param>
public ModFileInstaller(IGameModeEnvironmentInfo p_gmiGameModeInfo, IMod p_modMod, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, IDataFileUtil p_dfuDataFileUtility, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate, bool p_UsesPlugins, ModManager p_mmModManager)
{
GameModeInfo = p_gmiGameModeInfo;
Mod = p_modMod;
InstallLog = p_ilgInstallLog;
PluginManager = p_pmgPluginManager;
DataFileUtility = p_dfuDataFileUtility;
TransactionalFileManager = p_tfmFileManager;
m_dlgOverwriteConfirmationDelegate = p_dlgOverwriteConfirmationDelegate ?? ((s, b, m) => OverwriteResult.No);
IsPlugin = p_UsesPlugins;
m_mmModManager = p_mmModManager;
}
public void Initialize(IPluginManager loader, IPlugin[] plugins)
{
this.config = loader.GetPluginSetting <UserDefinedFilterConfig>(this.Name);
Reload();
}
private Action CreateInvoker(IPluginManager pluginManager, int browserId, long frameId, int contextId,
string methodName, IJavaScriptParameters parameters, IJavaScriptPluginCallback callback)
{
ThrowIfDisposed();
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
MethodInfo method;
if (!_methods.TryGetValue(methodName, out method))
{
if (callback != null)
{
var msg = string.Format("Error executing {0} on plugin {1} - method not found", methodName, _pluginId);
InvokeReturnCallback(callback, null, 0, msg);
}
}
var nativeObject = NativeObject;
if (nativeObject == null)
{
if (callback != null)
{
var msg = string.Format("Error executing {0} on plugin {1} - plugin object has been disposed", methodName, _pluginId);
InvokeReturnCallback(callback, null, 0, msg);
}
}
object[] arguments;
var hasCallbackParameter = HasCallbackParameter(method);
var methodParams = method.GetParameters();
var parameterDefinitions = hasCallbackParameter
? methodParams.Take(methodParams.Length - 1).ToArray()
: methodParams;
try
{
arguments = parameters.GetConvertedParameters(parameterDefinitions, pluginManager);
if (hasCallbackParameter)
{
// Create a new args array with length + 1 so we can add the callback param to it.
var args = new object[arguments.Length + 1];
Array.Copy(arguments, args, arguments.Length);
// Extract the callback and wrap it.
JavaScriptPluginCallback callbackParam = null;
if (callback != null)
{
var parameterCallback = callback.GetParameterCallback();
if (parameterCallback != null)
{
callbackParam = parameterCallback.Invoke;
}
}
// Add the wrapped callback to the args list.
args[args.Length - 1] = callbackParam;
arguments = args;
}
}
catch (Exception ex)
{
Logger.Error("Error converting plugin invocation parameters: " + ex);
if (callback != null)
{
InvokeReturnCallback(callback, null, -1, ex.Message);
}
return(null);
}
var invoke = new Action(
() =>
{
using (PluginExecutionContext.Create(browserId, contextId, frameId))
{
object result = null;
var errorCode = 0;
var error = string.Empty;
try
{
result = method.Invoke(nativeObject, arguments);
}
catch (Exception e)
{
while (e is TargetInvocationException)
{
e = e.InnerException;
}
errorCode = -1;
error = e.Message;
Logger.Error("Error executing plugin method: " + e);
}
if (callback != null)
{
InvokeReturnCallback(callback, result, errorCode, error);
}
}
});
return(invoke);
}
public Main(IPluginManager pluginManager)
: base(pluginManager)
{
entities = new List <IEntity>();
}
public MonitoringLogic(IConfigurationRepository configDb, IPluginManager pluginManager)
{
_configDb = configDb;
_pluginManager = pluginManager;
_logger = Serilog.Log.Logger;
}
public PluginActionDescriptorCollectionProvider(IServiceProvider serviceProvider, IPluginManager pluginManager)
{
_serviceProvider = serviceProvider;
_pluginManager = pluginManager;
_activePluginHash = -1;
}
public PluginManagerViewModel(IPluginManager pluginManager)
{
pluginManager.PluginsLoaded += PluginManager_PluginsLoaded;
}
protected PluginEvent(IPluginManager pluginManager, IPlugin plugin, bool global = true) : base(global)
{
PluginManager = pluginManager;
Plugin = plugin;
}
protected PluginEvent(IPluginManager pluginManager, IPlugin plugin) : this(pluginManager, plugin, true)
{
}
public IPluginState CreatePluginState(IPluginManager pluginManager)
{
return(new HpiHpbState());
}
/// <summary>
/// The main entry point for the MP 2 client application.
/// </summary>
private static void Main(params string[] args)
{
Thread.CurrentThread.Name = "Main";
#if !DEBUG
SplashScreen splashScreen = CreateSplashScreen();
splashScreen.ShowSplashScreen();
#endif
// Parse Command Line options
CommandLineOptions mpArgs = new CommandLineOptions();
ICommandLineParser parser = new CommandLineParser(new CommandLineParserSettings(Console.Error));
if (!parser.ParseArguments(args, mpArgs, Console.Out))
{
Environment.Exit(1);
}
#if !DEBUG
string logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), @"Team MediaPortal\MP2-Client\Log");
#endif
SystemStateService systemStateService = new SystemStateService();
ServiceRegistration.Set <ISystemStateService>(systemStateService);
systemStateService.SwitchSystemState(SystemState.Initializing, false);
try
{
ILogger logger = null;
try
{
// Check if user wants to override the default Application Data location.
ApplicationCore.RegisterCoreServices(mpArgs.DataDirectory);
logger = ServiceRegistration.Get <ILogger>();
#if !DEBUG
IPathManager pathManager = ServiceRegistration.Get <IPathManager>();
logPath = pathManager.GetPath("<LOG>");
#endif
UiExtension.RegisterUiServices();
}
catch (Exception e)
{
if (logger != null)
{
logger.Critical("Error starting application", e);
}
systemStateService.SwitchSystemState(SystemState.ShuttingDown, true);
ServiceRegistration.IsShuttingDown = true;
UiExtension.DisposeUiServices();
ApplicationCore.DisposeCoreServices();
throw;
}
// Start the core
logger.Debug("ApplicationLauncher: Starting application");
try
{
IPluginManager pluginManager = ServiceRegistration.Get <IPluginManager>();
pluginManager.Initialize();
pluginManager.Startup(false);
ApplicationCore.StartCoreServices();
ISkinEngine skinEngine = ServiceRegistration.Get <ISkinEngine>();
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
IMediaAccessor mediaAccessor = ServiceRegistration.Get <IMediaAccessor>();
ILocalSharesManagement localSharesManagement = ServiceRegistration.Get <ILocalSharesManagement>();
// We have to handle some dependencies here in the start order:
// 1) After all plugins are loaded, the SkinEngine can initialize (=load all skin resources)
// 2) After the skin resources are loaded, the workflow manager can initialize (=load its states and actions)
// 3) Before the main window is shown, the splash screen should be hidden
// 4) After the workflow states and actions are loaded, the main window can be shown
// 5) After the skinengine triggers the first workflow state/startup screen, the default shortcuts can be registered
mediaAccessor.Initialize(); // Independent from other services
localSharesManagement.Initialize(); // After media accessor was initialized
skinEngine.Initialize(); // 1)
workflowManager.Initialize(); // 2)
#if !DEBUG
splashScreen.CloseSplashScreen(); // 3)
#endif
skinEngine.Startup(); // 4)
UiExtension.Startup(); // 5)
ApplicationCore.RegisterDefaultMediaItemAspectTypes(); // To be done after UI services are running
systemStateService.SwitchSystemState(SystemState.Running, true);
Application.Run();
systemStateService.SwitchSystemState(SystemState.ShuttingDown, true);
ServiceRegistration.IsShuttingDown = true; // Block ServiceRegistration from trying to load new services in shutdown phase
// 1) Stop UI extensions (Releases all active players, must be done before shutting down SE)
// 2) Shutdown SkinEngine (Closes all screens, uninstalls background manager, stops render thread)
// 3) Shutdown WorkflowManager (Disposes all models)
// 4) Shutdown PluginManager (Shuts down all plugins)
// 5) Remove all services
UiExtension.StopUiServices();
skinEngine.Shutdown();
workflowManager.Shutdown();
pluginManager.Shutdown();
mediaAccessor.Shutdown();
localSharesManagement.Shutdown();
ApplicationCore.StopCoreServices();
}
catch (Exception e)
{
logger.Critical("Error executing application", e);
systemStateService.SwitchSystemState(SystemState.ShuttingDown, true);
ServiceRegistration.IsShuttingDown = true;
}
finally
{
UiExtension.DisposeUiServices();
ApplicationCore.DisposeCoreServices();
systemStateService.SwitchSystemState(SystemState.Ending, false);
}
}
catch (Exception ex)
{
#if DEBUG
ConsoleLogger log = new ConsoleLogger(LogLevel.All, false);
log.Error(ex);
#else
UiCrashLogger crash = new UiCrashLogger(logPath);
crash.CreateLog(ex);
#endif
systemStateService.SwitchSystemState(SystemState.Ending, false);
Application.Exit();
}
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ISettingsManager settingsManager, IPluginManager pluginManager, IErrorLogRepository errorLogRepository, IOptions <SenparcSetting> senparcSetting)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseExceptionHandler(a => a.Run(async context =>
{
var exceptionHandlerPathFeature = context.Features.Get <IExceptionHandlerPathFeature>();
var exception = exceptionHandlerPathFeature.Error;
string result;
if (env.IsDevelopment())
{
result = TranslateUtils.JsonSerialize(new
{
exception.Message,
exception.StackTrace,
AddDate = DateTime.Now
});
}
else
{
result = TranslateUtils.JsonSerialize(new
{
exception.Message,
AddDate = DateTime.Now
});
}
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(result);
}));
app.UseCors(CorsPolicy);
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
//app.UseHttpsRedirection();
var options = new DefaultFilesOptions();
options.DefaultFileNames.Clear();
options.DefaultFileNames.Add("index.html");
app.UseDefaultFiles(options);
if (settingsManager.Containerized)
{
app.Map($"/{DirectoryUtils.SiteFiles.DirectoryName}/assets", assets =>
{
assets.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(PathUtils.Combine(settingsManager.ContentRootPath, "assets"))
});
});
}
app.UseStaticFiles();
var supportedCultures = new[]
{
new CultureInfo("en-US"),
new CultureInfo("zh-CN")
};
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("zh-CN"),
// Formatting numbers, dates, etc.
SupportedCultures = supportedCultures,
// UI strings that we have localized.
SupportedUICultures = supportedCultures
});
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UsePluginsAsync(settingsManager, pluginManager, errorLogRepository).GetAwaiter().GetResult();
app.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/healthz");
endpoints.MapControllers();
endpoints.MapRazorPages();
});
//api.UseEndpoints(endpoints => { endpoints.MapControllerRoute("default", "{controller}/{action}/{id?}"); });
app.UseRequestLocalization();
RegisterService.Start(senparcSetting.Value)
//自动扫描自定义扩展缓存（二选一）
.UseSenparcGlobal(true)
//指定自定义扩展缓存（二选一）
//.UseSenparcGlobal(false, () => GetExCacheStrategies(senparcSetting.Value))
;
app.UseOpenApi();
app.UseSwaggerUi3();
app.UseReDoc(settings =>
{
settings.Path = "/api/docs";
settings.DocumentPath = "/swagger/v1/swagger.json";
});
}
/// <summary>
/// Initializes a new <see cref="WorkflowScheduler"/>
/// </summary>
/// <param name="serviceProvider">The current <see cref="IServiceProvider"/></param>
/// <param name="logger">The service used to perform logging</param>
/// <param name="pluginManager">The service used to manage <see cref="IPlugin"/>s</param>
public WorkflowScheduler(IServiceProvider serviceProvider, ILogger <WorkflowScheduler> logger, IPluginManager pluginManager)
{
this.ServiceProvider = serviceProvider;
this.Logger = logger;
this.PluginManager = pluginManager;
}
public PluginApplicationModelProvider(IPluginManager pluginManager)
{
_pluginManager = pluginManager ?? throw new ArgumentNullException(nameof(pluginManager));
}
public void Initialize(IPluginManager loader, IPlugin[] plugins)
{
this.config = loader.GetPluginSetting <AddNameFilterConfig>(this.Name);
}
public TerminalSettingsSerializer(IPluginManager pm)
{
_serializeService = (ISerializeService)pm.FindPlugin("org.poderosa.core.serializing", typeof(ISerializeService));
}
/// <summary>
/// Loads a <see cref="HomeEditorRegistration"/> for the specified <paramref name="itemMetadata"/>.
/// </summary>
/// <param name="itemMetadata"></param>
/// <param name="pluginManager"></param>
/// <returns></returns>
protected HomeEditorRegistration GetSkinRegistration(PluginItemMetadata itemMetadata, IPluginManager pluginManager)
{
try
{
HomeEditorRegistration providerRegistration = pluginManager.RequestPluginItem <HomeEditorRegistration>(
HomeEditorRegistrationBuilder.HOME_EDITOR_PROVIDER_PATH, itemMetadata.Id, _pluginItemStateTracker);
if (providerRegistration != null)
{
ServiceRegistration.Get <ILogger>().Info("Successfully added Home Editor skin registration for skin '{0}' (Id '{1}')",
itemMetadata.Attributes["SkinName"], itemMetadata.Id);
return(providerRegistration);
}
ServiceRegistration.Get <ILogger>().Warn("Could not instantiate Home Editor skin registration with id '{0}'", itemMetadata.Id);
}
catch (PluginInvalidStateException e)
{
ServiceRegistration.Get <ILogger>().Warn("Cannot add Home Editor skin registration with id '{0}'", e, itemMetadata.Id);
}
return(null);
}
/// <inheritdoc />
public TestTask(IProjectService projectService, IExternalServiceService externalServiceService, IExternalServiceTypeService externalServiceTypeService, IProviderService providerService, IPluginManager pluginManager, ILogger <TestTask> logger)
: base(projectService, externalServiceService, externalServiceTypeService, providerService, pluginManager, logger)
{
}
internal static void DefineExtensionPoint(IPluginManager pm)
{
IExtensionPoint pt = pm.CreateExtensionPoint("org.poderosa.window.aboutbox", typeof(IPoderosaAboutBoxFactory), WindowManagerPlugin.Instance);
pt.RegisterExtension(new DefaultAboutBoxFactory());
}
internal PluginsCommand(IPluginManager pluginManager)
{
_pluginManager = pluginManager;
}
public SystemController(ISystemManager systemManager, IPluginManager pluginManager, IDbConnectionFactory dbConnectionFactory)
{
_systemManager = systemManager;
_pluginManager = pluginManager;
_dbConnectionFactory = dbConnectionFactory;
}
public LogsErrorController(IAuthManager authManager, IPluginManager pluginManager, IErrorLogRepository errorLogRepository)
{
_authManager = authManager;
_pluginManager = pluginManager;
_errorLogRepository = errorLogRepository;
}
public IPluginState CreatePluginState(IPluginManager pluginManager)
{
return(new NonaryMainState());
}
public override void Initialize(IPluginManager loader, IPlugin[] plugins)
{
}
