void RegisterParts(IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.RegisterConstant(this, typeof(IScreen));
dependencyResolver.Register(() => new Editor(), typeof(IViewFor<EditorViewModel>));
dependencyResolver.Register(() => new MetroiLinksViewModel(), typeof(IMetroiLinksViewModel));
}
public void Register(IMutableDependencyResolver resolver)
{
// NB: We want the most recently registered fs, since there really
// only should be one
var fs = Locator.Current.GetService<IFilesystemProvider>();
if (fs == null)
{
throw new Exception("Failed to initialize Akavache properly. Do you have a reference to Akavache.dll?");
}
var localCache = new Lazy<IBlobCache>(() =>{
fs.CreateRecursive(fs.GetDefaultLocalMachineCacheDirectory()).SubscribeOn(BlobCache.TaskpoolScheduler).Wait();
return new SQLitePersistentBlobCache(Path.Combine(fs.GetDefaultLocalMachineCacheDirectory(), "blobs.db"), BlobCache.TaskpoolScheduler);
});
resolver.Register(() => localCache.Value, typeof(IBlobCache), "LocalMachine");
var userAccount = new Lazy<IBlobCache>(() =>{
fs.CreateRecursive(fs.GetDefaultRoamingCacheDirectory()).SubscribeOn(BlobCache.TaskpoolScheduler).Wait();
return new SQLitePersistentBlobCache(Path.Combine(fs.GetDefaultRoamingCacheDirectory(), "userblobs.db"), BlobCache.TaskpoolScheduler);
});
resolver.Register(() => userAccount.Value, typeof(IBlobCache), "UserAccount");
var secure = new Lazy<ISecureBlobCache>(() => {
fs.CreateRecursive(fs.GetDefaultSecretCacheDirectory()).SubscribeOn(BlobCache.TaskpoolScheduler).Wait();
return new SQLiteEncryptedBlobCache(Path.Combine(fs.GetDefaultSecretCacheDirectory(), "secret.db"), Locator.Current.GetService<IEncryptionProvider>(), BlobCache.TaskpoolScheduler);
});
resolver.Register(() => secure.Value, typeof(ISecureBlobCache), null);
}
public void Register(IMutableDependencyResolver splatLocator, CompositionRoot compositionRoot)
{
splatLocator.AssertNotNull(nameof(splatLocator));
this.RegisterViews(splatLocator);
this.RegisterScreen(splatLocator, compositionRoot);
this.RegisterCommandBinders(splatLocator, compositionRoot);
this.RegisterPlatformComponents(splatLocator, compositionRoot);
}
public Bootstrapper(IMutableDependencyResolver deps = null, RoutingState testRouter = null)
{
Router = testRouter ?? new RoutingState();
deps = deps ?? Locator.CurrentMutable;
var options = ((App) System.Windows.Application.Current).CommandLineOptions;
// Bind
RegisterParts(deps);
// This is a good place to set up any other app
// startup tasks, like setting the logging level
LogHost.Default.Level = LogLevel.Debug;
var settingsManager = deps.GetService<ISettingsManager>();
var gameManager = deps.GetService<IGameManager>();
deps.GetService<NLog.ILogger>().Info("Waiting for settings...");
settingsManager.ApiAuthenticated.Subscribe(user => {
if (user != null) {
((App)System.Windows.Application.Current).CrashManager.SetUser(user);
}
});
// Navigate to the opening page of the application
settingsManager.SettingsAvailable.Subscribe(settings => {
if (settings == null) {
return;
}
System.Windows.Application.Current.Dispatcher.Invoke(delegate {
deps.GetService<NLog.ILogger>().Info("Got settings!");
if (settings.IsFirstRun || string.IsNullOrEmpty(settings.ApiKey)) {
System.Windows.Application.Current.MainWindow = new MainWindow(this);
System.Windows.Application.Current.MainWindow.Show();
Router.Navigate.Execute(new SettingsViewModel(this,
deps.GetService<ISettingsManager>(),
deps.GetService<IVersionManager>(),
deps.GetService<IGameManager>())
);
} else if (!options.Minimized) {
// start the initialization
gameManager.Initialize();
System.Windows.Application.Current.MainWindow = new MainWindow(this);
System.Windows.Application.Current.MainWindow.Show();
Router.Navigate.Execute(new MainViewModel(this, deps.GetService<ISettingsManager>(), deps.GetService<IVersionManager>()));
} else {
// start the initialization
gameManager.Initialize();
}
});
});
}
public AppViewModel(IMutableDependencyResolver dependencyResolver = null, IRoutingState routingState = null)
{
Router = routingState ?? new RoutingState();
dependencyResolver = dependencyResolver ?? RxApp.MutableResolver;
RegisterDependencies(dependencyResolver);
LogHost.Default.Level = LogLevel.Debug;
Router.Navigate.Execute(new CustomerViewModel(dependencyResolver.GetService<IScreen>()));
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver = null, IRoutingState testRouter = null)
{
Router = testRouter ?? new RoutingState();
dependencyResolver = dependencyResolver ?? RxApp.MutableResolver;
//bind our shit up
RegisterParts(dependencyResolver);
//navigate to first screen
Router.Navigate.Execute(new EditorViewModel(this));
}
static bool processRegistrationForNamespace(string ns, AssemblyName assmName, IMutableDependencyResolver resolver)
{
var targetType = ns + ".Registrations";
string fullName = targetType + ", " + assmName.FullName.Replace(assmName.Name, ns);
var registerTypeClass = Reflection.ReallyFindType(fullName, false);
if (registerTypeClass == null) return false;
var registerer = (IWantsToRegisterStuff)Activator.CreateInstance(registerTypeClass);
registerer.Register((f, t) => resolver.RegisterConstant(f(), t));
return true;
}
private void RegisterParts(IMutableDependencyResolver resolver)
{
resolver.RegisterConstant(this, typeof(IScreen));
resolver.RegisterConstant(this.Router, typeof(IRoutingState));
resolver.RegisterLazySingleton(() => new MainWindowViewModel(this), typeof(IMainWindowViewModel));
resolver.RegisterLazySingleton(() => new NotificationView(), typeof(INotificationView));
resolver.Register(() => new Service(), typeof(IService));
resolver.Register(() => new SettingsViewModel(), typeof(ISettingsViewModel));
resolver.Register(() => new TreeViewModel(), typeof(ITreeViewModel));
resolver.Register(() => new NotificationViewModel(this), typeof(INotificationViewModel));
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver = null, IRoutingState testRouter = null)
{
// Initialize the defaults from the constructor
// (i think they are there for unit test purposes), even though they aren't used now.
Router = testRouter ?? new RoutingState();
dependencyResolver = dependencyResolver ?? RxApp.MutableResolver;
// Declare the application name for Akavache
BlobCache.ApplicationName = "StarHub";
// Bind
RegisterParts(dependencyResolver);
// TODO: This is a good place to set up any other app
// startup tasks, like setting the logging level
LogHost.Default.Level = LogLevel.Debug;
// Connect to GitHub
LoadCredentials().Subscribe(creds =>
{
Connection conn = new Connection(new ProductHeaderValue("StarHub"));
if (creds != null)
{
conn.Credentials = creds;
}
else
{
// For now, look for a token in the environment while i figure out how to get logins working
var authToken = Environment.GetEnvironmentVariable("OCTOKIT_GITHUBPASSWORD");
conn.Credentials = new Credentials(authToken);
}
GHClient = new GitHubClient(conn);
// Instantiate my view models
HomeVM = new HomeViewModel(this, GHClient);
Router.Navigate.Execute(HomeVM);
});
//LogInVM = new LogInViewModel(this, GHClient);
//BlobCache.UserAccount.GetObjectAsync<string>("UserName").Subscribe(user =>
// {
// });
// Make sure routing is set up
//SetRoutingHome();
//SetRoutingLogIn();
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver = null, RoutingState testRouter = null)
{
Router = testRouter ?? new RoutingState();
dependencyResolver = dependencyResolver ?? Locator.CurrentMutable;
// Bind
RegisterParts(dependencyResolver);
// TODO: This is a good place to set up any other app
// startup tasks, like setting the logging level
LogHost.Default.Level = LogLevel.Debug;
// Navigate to the opening page of the application
Router.Navigate.Execute(new WelcomeViewModel(this));
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver = null, RoutingState testRouter = null)
{
Router = testRouter ?? new RoutingState();
dependencyResolver = dependencyResolver ?? Locator.CurrentMutable;
// Bind
RegisterParts(dependencyResolver);
// TODO: This is a good place to set up any other app
// startup tasks, like setting the logging level
#if DEBUG
LogHost.Default.Level = LogLevel.Debug;
#else
LogHost.Default.Level = LogLevel.Info;
#endif
}
private void RegisterParts(IMutableDependencyResolver dependencyResolver)
{
#if DEBUG
dependencyResolver.RegisterConstant(new ConsoleLogger(), typeof(ILogger));
#endif
dependencyResolver.RegisterConstant(this, typeof(IAppBootstrapper));
dependencyResolver.RegisterConstant(new MessageBus(), typeof(IMessageBus));
dependencyResolver.Register(() => new MainView(), typeof(IViewFor<MainViewModel>));
#if WINDOWS_PHONE_APP
dependencyResolver.Register(() => new RouteView(), typeof(IViewFor<RouteViewModel>));
#endif
dependencyResolver.Register(() => new SettingsView(), typeof(IViewFor<SettingsViewModel>));
dependencyResolver.Register(() => new IAPView(), typeof(IViewFor<IAPViewModel>));
IMessageBus messageBus = Locator.Current.GetService<IMessageBus>();
messageBus.Listen<BasicGeoposition>(Constants.MSGBUS_TOKEN_MY_GEOPOSITION).Subscribe(x => MyPosition = x);
}
public void Register(IMutableDependencyResolver resolver)
{
#if SILVERLIGHT || XAMARIN_MOBILE
var fs = new IsolatedStorageProvider();
#elif WINRT
var fs = new WinRTFilesystemProvider();
#else
var fs = new SimpleFilesystemProvider();
#endif
resolver.Register(() => fs, typeof(IFilesystemProvider), null);
#if WP8
var enc = new WP8EncryptionProvider();
#elif WINRT
var enc = new WinRTEncryptionProvider();
#else
var enc = new EncryptionProvider();
#endif
resolver.Register(() => enc, typeof(IEncryptionProvider), null);
var localCache = new Lazy<IBlobCache>(() => new InMemoryBlobCache());
var userAccount = new Lazy<IBlobCache>(() => new InMemoryBlobCache());
var secure = new Lazy<ISecureBlobCache>(() => new InMemoryBlobCache());
resolver.Register(() => localCache.Value, typeof(IBlobCache), "LocalMachine");
resolver.Register(() => userAccount.Value, typeof(IBlobCache), "UserAccount");
resolver.Register(() => secure.Value, typeof(ISecureBlobCache), null);
resolver.Register(() => new AkavacheHttpMixin(), typeof(IAkavacheHttpMixin), null);
#if APPKIT || UIKIT
BlobCache.ApplicationName = NSBundle.MainBundle.BundleIdentifier;
resolver.Register(() => new MacFilesystemProvider(), typeof(IFilesystemProvider), null);
#endif
#if ANDROID
var ai = Application.Context.PackageManager.GetApplicationInfo(Application.Context.PackageName, 0);
BlobCache.ApplicationName = ai.LoadLabel(Application.Context.PackageManager);
resolver.Register(() => new AndroidFilesystemProvider(), typeof(IFilesystemProvider), null);
#endif
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver = null, RoutingState testRouter = null)
{
Router = testRouter ?? new RoutingState();
dependencyResolver = dependencyResolver ?? Locator.CurrentMutable;
// Bind
RegisterParts(dependencyResolver);
// TODO: This is a good place to set up any other app
// startup tasks, like setting the logging level
LogHost.Default.Level = LogLevel.Debug;
// Navigate to the opening page of the application
Router.Navigate.Execute(new DetailsViewModel(this));
//Router.Navigate.Execute(new WelcomeViewModel(this));
CloseFlyoutCommand.Subscribe(o => IsFlyoutOpen = false);
MessageBus.Current.Listen<ShortcutViewModel>()
.Subscribe(ShowFlyout);
}
public AppBootstrapper(IMutableDependencyResolver d = null, RoutingState testRouter = null)
{
Router = testRouter ?? new RoutingState();
d = d ?? Locator.CurrentMutable;
Locator.CurrentMutable.RegisterConstant(this, typeof(IScreen));
var r = new RoutingState();
Locator.CurrentMutable.RegisterConstant(r, typeof(RoutingState));
Locator.CurrentMutable.Register(() => new MainCalculatorView(), typeof(IViewFor<MainCalculatorViewModel>));
//Locator.CurrentMutable.Register(() => new TodayDashboardView(), typeof(IViewFor<TodayDashboardViewModel>));
//Locator.CurrentMutable.Register(() => new DailyItemView(), typeof(IViewFor<DailyItemViewModel>));
//db Context
//Locator.CurrentMutable.RegisterConstant(new DataBaseInstance().DbInstance, typeof(DbInstance));
_router = new RoutingState();
_router.Navigate.Execute(new MainCalculatorViewModel());
}
public void Register(IMutableDependencyResolver resolver)
{
resolver.Register(() => new JsonSerializerSettings()
{
ObjectCreationHandling = ObjectCreationHandling.Replace,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.All,
}, typeof(JsonSerializerSettings), null);
var akavacheDriver = new AkavacheDriver();
resolver.Register(() => akavacheDriver, typeof(ISuspensionDriver), null);
// NB: These correspond to the hacks in Akavache.Http's registrations
resolver.Register(() => resolver.GetService<ISuspensionHost>().ShouldPersistState,
typeof(IObservable<IDisposable>), "ShouldPersistState");
resolver.Register(() => resolver.GetService<ISuspensionHost>().IsUnpausing,
typeof(IObservable<Unit>), "IsUnpausing");
resolver.Register(() => RxApp.TaskpoolScheduler, typeof(IScheduler), "Taskpool");
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver = null, IRoutingState routingState = null)
{
#region Handle Optional Parameters
Router = routingState ?? new RoutingState();
var kernel = new StandardKernel();
RxApp.DependencyResolver = dependencyResolver ?? new FuncDependencyResolver((type, contract) => kernel.GetAll(type, contract));
if (dependencyResolver == null)
RxApp.InitializeCustomResolver((obj, type) => kernel.Bind(type).ToConstant(obj));
#endregion
#region Ninject Setup
// Singletons
kernel.Bind<IScreen>().ToConstant<AppBootstrapper>(this);
kernel.Bind<ILogPeopleIn>().To<LoginManager>().InSingletonScope();
// View resolution
kernel.Bind<IViewFor<LoginWidgetViewModel>>().To<LoginWidgetView>();
kernel.Bind<IViewFor<MainViewModel>>().To<MainView>();
kernel.Bind<IViewFor<CreateTicketsViewModel>>().To<CreateTicketsView>();
kernel.Bind<IViewFor<DispatchViewModel>>().To<DispatchView>();
kernel.Bind<IViewFor<AssignedTicketsViewModel>>().To<AssignedTicketsView>();
// Persistence
kernel.Bind<ISession>().To<TicketingSession>().InParentScope();
#endregion
LogHost.Default.Level = LogLevel.Debug;
LoginWidgetViewModel = kernel.Get<LoginWidgetViewModel>();
Router.Navigate.Execute(kernel.Get<MainViewModel>());
}
/// <summary>
/// Registers a constant value which will always return the specified object instance.
/// </summary>
/// <param name="resolver">The resolver to register the service type with.</param>
/// <param name="value">The specified instance to always return.</param>
/// <param name="serviceType">The type of service to register.</param>
/// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
public static void RegisterConstant(this IMutableDependencyResolver resolver, object value, Type serviceType, string contract = null)
{
resolver.Register(() => value, serviceType, contract);
}
private void RegisterTypesInContainer(IMutableDependencyResolver dependencyResolver)
{
Locator.CurrentMutable.InitializeSplat();
Locator.CurrentMutable.InitializeReactiveUI();
dependencyResolver.RegisterConstant(this, typeof(IScreen));
Locator.CurrentMutable.RegisterLazySingleton(() => new AppViewLocator(), typeof(IViewLocator));
}
/// <summary>
/// Registers a lazy singleton value which will always return the specified object instance once created.
/// The value is only generated once someone requests the service from the resolver.
/// </summary>
/// <typeparam name="T">The service type to register for.</typeparam>
/// <param name="resolver">The resolver to register the service type with.</param>
/// <param name="valueFactory">A factory method for generating a object of the specified type.</param>
/// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
public static void RegisterLazySingleton <T>(this IMutableDependencyResolver resolver, Func <T> valueFactory, string contract = null)
{
RegisterLazySingleton(resolver, () => valueFactory(), typeof(T), contract);
}
/// <summary>
/// Registers a new callback that occurs when a new service with the specified type is registered.
/// </summary>
/// <param name="resolver">The resolver we want to register the callback with.</param>
/// <param name="serviceType">The service type we are wanting to observe.</param>
/// <param name="callback">The callback which should be called.</param>
/// <returns>A disposable which will stop notifications to the callback.</returns>
public static IDisposable ServiceRegistrationCallback(this IMutableDependencyResolver resolver, Type serviceType, Action <IDisposable> callback)
{
return(resolver.ServiceRegistrationCallback(serviceType, null, callback));
}
// This is where we configure the composition of our components.
private void RegisterDependencies(IMutableDependencyResolver dr)
{
dr.RegisterConstant(this, typeof(IScreen));
dr.Register(() => new CustomerView(), typeof(IViewFor<CustomerViewModel>));
dr.Register(() => new SuccessView(), typeof(IViewFor<SuccessViewModel>));
}
/// <summary>
/// Registers a constant value which will always return the specified object instance.
/// </summary>
/// <typeparam name="T">The service type to register for.</typeparam>
/// <param name="resolver">The resolver to register the service type with.</param>
/// <param name="value">The specified instance to always return.</param>
/// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
public static void RegisterConstant <T>(this IMutableDependencyResolver resolver, T value, string contract = null)
{
RegisterConstant(resolver, value, typeof(T), contract);
}
private static void RegisterLinuxServices(IMutableDependencyResolver services, IReadonlyDependencyResolver resolver)
{
services.RegisterLazySingleton <ILinuxRemovedFileMetadataBuilderFactory>(() => new LinuxRemovedFileMetadataBuilderFactory());
services.RegisterLazySingleton <IUnmountedDriveService>(() => new LinuxUnmountedDriveService(
resolver.GetRequiredService <IProcessService>(),
resolver.GetRequiredService <IEnvironmentService>(),
resolver.GetRequiredService <LinuxUnmountedDrivesConfiguration>()
));
services.RegisterLazySingleton <ITrashCanService>(() => new LinuxTrashCanService(
resolver.GetRequiredService <IMountedDriveService>(),
resolver.GetRequiredService <IOperationsService>(),
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IEnvironmentService>(),
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IDateTimeProvider>(),
resolver.GetRequiredService <ILinuxRemovedFileMetadataBuilderFactory>(),
resolver.GetRequiredService <IHomeDirectoryProvider>()
));
services.RegisterLazySingleton <IHomeDirectoryProvider>(() => new UnixHomeDirectoryProvider(
resolver.GetRequiredService <IEnvironmentService>()
));
services.RegisterLazySingleton <IDriveNameService>(() => new DriveNameService(
resolver.GetRequiredService <IProcessService>(),
resolver.GetRequiredService <IEnvironmentService>()
));
services.RegisterLazySingleton <IDesktopEnvironmentService>(() => new DesktopEnvironmentService(
resolver.GetRequiredService <IEnvironmentService>()
));
services.RegisterLazySingleton <IShellCommandWrappingService>(() => new ShellCommandWrappingService());
services.RegisterLazySingleton <IResourceOpeningService>(() => new ResourceOpeningServiceOpenWith(
new LinuxResourceOpeningService(
resolver.GetRequiredService <IProcessService>(),
resolver.GetRequiredService <IShellCommandWrappingService>(),
resolver.GetRequiredService <IDesktopEnvironmentService>()),
resolver.GetRequiredService <IOpenWithApplicationService>(),
resolver.GetRequiredService <IPathService>()
));
services.RegisterLazySingleton <ITerminalService>(() => new LinuxTerminalService(
resolver.GetRequiredService <IProcessService>(),
resolver.GetRequiredService <IUnitOfWorkFactory>(),
resolver.GetRequiredService <IDesktopEnvironmentService>(),
resolver.GetRequiredService <IShellCommandWrappingService>()
));
services.RegisterLazySingleton <IMimeTypesReader>(() => new MimeTypesReader());
services.RegisterLazySingleton <IIniReader>(() => new IniReader());
services.RegisterLazySingleton <IApplicationService>(() => new LinuxApplicationService(
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IHomeDirectoryProvider>(),
resolver.GetRequiredService <IIniReader>(),
resolver.GetRequiredService <IRegexService>(),
resolver.GetRequiredService <IMimeTypesReader>(),
resolver.GetRequiredService <IPathService>()
));
services.RegisterLazySingleton <IMountedDriveService>(() => new LinuxMountedDriveService(
resolver.GetRequiredService <IEnvironmentDriveService>(),
resolver.GetRequiredService <IProcessService>(),
resolver.GetRequiredService <IDriveNameService>(),
resolver.GetRequiredService <ILogger>()
));
}
void RegisterTypesInContainer(IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.RegisterConstant(this, typeof(IScreen));
dependencyResolver.Register(() => new CreateUserView(), typeof(IViewFor<CreateUserViewModel>));
}
private void RegisterParts(IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.RegisterConstant(this, typeof(IScreen));
dependencyResolver.Register(() => new WelcomeView(), typeof(IViewFor <WelcomeViewModel>));
}
public static void InitializeSplat(this IMutableDependencyResolver This)
{
This.Register(() => new DefaultLogManager(), typeof(ILogManager));
This.Register(() => new DebugLogger(), typeof(ILogger));
}
private void RegisterServices(IMutableDependencyResolver registrar)
{
registrar.Register(() => new MockConnectivityEssential(RxApp.MainThreadScheduler, 5), typeof(IConnectivity));
registrar.Register(() => new MockCompassEssential(RxApp.MainThreadScheduler), typeof(ICompass));
}
public static void RegisterSuspensionDriver(this IMutableDependencyResolver resolver)
=> resolver.RegisterLazySingleton(
() => new AkavacheSuspensionDriver <AppState>(), typeof(ISuspensionDriver));
/// <summary>
/// Registers the navigation controller.
/// </summary>
/// <param name="dependencyResolver">The dependency resolver.</param>
/// <returns>The mutable dependency resolver.</returns>
public static IMutableDependencyResolver RegisterNavigationController(
this IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.RegisterLazySingleton(() => new NavigationViewController());
return(dependencyResolver);
}
private void RegisterViews(IMutableDependencyResolver splatLocator)
{
splatLocator.Register(() => new ExerciseProgramsView(), typeof(IViewFor<ExerciseProgramsViewModel>));
splatLocator.Register(() => new ExerciseProgramView(), typeof(IViewFor<ExerciseProgramViewModel>));
}
public static void RegisterServices(IMutableDependencyResolver services, IReadonlyDependencyResolver resolver)
{
RegisterCommonServices(services, resolver);
RegisterPlatformSpecificServices(services, resolver);
}
private void RegisterCommandBinders(IMutableDependencyResolver splatLocator, CompositionRoot compositionRoot) =>
splatLocator.RegisterConstant(new ControlButtonCommandBinder(), typeof(ICreatesCommandBinding));
private static void RegisterCommonServices(IMutableDependencyResolver services, IReadonlyDependencyResolver resolver)
{
services.RegisterLazySingleton <IArchiveProcessorFactory>(() => new ArchiveProcessorFactory(
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IFileNameGenerationService>(),
resolver.GetRequiredService <IPathService>()
));
services.Register <ICreateArchiveStateService>(() => new CreateArchiveStateService(
resolver.GetRequiredService <IUnitOfWorkFactory>()
));
services.RegisterLazySingleton <IArchiveTypeMapper>(() => new ArchiveTypeMapper(
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <ArchiveTypeMapperConfiguration>()
));
services.RegisterLazySingleton <IArchiveService>(() => new ArchiveService(
resolver.GetRequiredService <IArchiveTypeMapper>(),
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IOperationsService>(),
resolver.GetRequiredService <IFileNameGenerationService>()
));
services.RegisterLazySingleton <IFileService>(() => new FileService(
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IEnvironmentFileService>(),
resolver.GetRequiredService <ILogger>()
));
services.RegisterLazySingleton <ISuggestionsService>(() => new SuggestionsService(
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IFavouriteDirectoriesService>(),
resolver.GetRequiredService <SuggestionsConfiguration>()
));
services.RegisterLazySingleton <IDateTimeProvider>(() => new DateTimeProvider());
services.RegisterLazySingleton <IFavouriteDirectoriesService>(() => new FavouriteDirectoriesService(
resolver.GetRequiredService <IUnitOfWorkFactory>(),
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IHomeDirectoryProvider>()
));
services.RegisterLazySingleton <IDrivesUpdateService>(() => new DrivesUpdateService(
resolver.GetRequiredService <IMountedDriveService>(),
resolver.GetRequiredService <IUnmountedDriveService>(),
resolver.GetRequiredService <ILogger>(),
resolver.GetRequiredService <DriveServiceConfiguration>()
));
services.RegisterLazySingleton <IOperationsFactory>(() => new OperationsFactory(
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IFileNameGenerationService>(),
resolver.GetRequiredService <ILogger>(),
resolver.GetRequiredService <IArchiveProcessorFactory>()
));
services.RegisterLazySingleton <INodesSelectionService>(() => new NodesSelectionService());
services.RegisterLazySingleton <IOperationsService>(() => new OperationsService(
resolver.GetRequiredService <IOperationsFactory>(),
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IResourceOpeningService>(),
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IOperationsStateService>()
));
services.RegisterLazySingleton <IDirectoryService>(() => new DirectoryService(
resolver.GetRequiredService <IPathService>(),
resolver.GetRequiredService <IEnvironmentDirectoryService>(),
resolver.GetRequiredService <IEnvironmentFileService>(),
resolver.GetRequiredService <ILogger>()
));
services.Register <IFileSystemWatchingService>(() => new FileSystemWatchingService(
resolver.GetRequiredService <IFileSystemWatcherFactory>()
));
services.RegisterLazySingleton(() => new FileOpeningBehavior(
resolver.GetRequiredService <IResourceOpeningService>()
));
services.RegisterLazySingleton(() => new DirectoryOpeningBehavior(
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IResourceOpeningService>()
));
services.RegisterLazySingleton <ILocalizationService>(() => new LocalizationService(
resolver.GetRequiredService <IUnitOfWorkFactory>()
));
services.RegisterLazySingleton <IThemeService>(() => new ThemeService(
resolver.GetRequiredService <IUnitOfWorkFactory>(),
resolver.GetRequiredService <DefaultThemeConfiguration>()
));
services.RegisterLazySingleton <IFileSizeFormatter>(() => new FileSizeFormatter());
services.RegisterLazySingleton <IPathService>(() => new PathService(
resolver.GetRequiredService <IEnvironmentPathService>()
));
services.RegisterLazySingleton <IDialogService>(() => new DialogService(
resolver.GetRequiredService <IMainWindowProvider>()
));
services.RegisterLazySingleton <ISystemDialogService>(() => new SystemDialogService(
resolver.GetRequiredService <IMainWindowProvider>()
));
services.RegisterLazySingleton <IResourceProvider>(() => new ResourceProvider());
services.RegisterLazySingleton <ILanguageManager>(() => new LanguageManager(
resolver.GetRequiredService <LanguagesConfiguration>()
));
services.RegisterLazySingleton <IClipboardOperationsService>(() => new ClipboardOperationsService(
resolver.GetRequiredService <IClipboardService>(),
resolver.GetRequiredService <IOperationsService>(),
resolver.GetRequiredService <IEnvironmentService>()
));
services.RegisterLazySingleton <IOperationsStateService>(() => new OperationsStateService());
services.RegisterLazySingleton <IFileNameGenerationService>(() => new FileNameGenerationService(
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IPathService>()
));
services.RegisterLazySingleton <IOpenWithApplicationService>(() => new OpenWithApplicationService(
resolver.GetRequiredService <IUnitOfWorkFactory>()
));
services.RegisterLazySingleton <IRecursiveSearchResultFactory>(() => new RecursiveSearchResultFactory());
services.RegisterLazySingleton <IRecursiveSearchService>(() => new RecursiveSearchService(
resolver.GetRequiredService <IDirectoryService>(),
resolver.GetRequiredService <IFileService>(),
resolver.GetRequiredService <IRecursiveSearchResultFactory>(),
resolver.GetRequiredService <ILogger>()
));
}
private void RegisterParts(IMutableDependencyResolver deps)
{
deps.RegisterConstant(this, typeof(IScreen));
// services
deps.RegisterLazySingleton(NLog.LogManager.GetCurrentClassLogger, typeof(NLog.ILogger));
deps.RegisterLazySingleton(() => ((App)System.Windows.Application.Current).CrashManager, typeof(CrashManager));
deps.RegisterLazySingleton(() => new ThreadManager(), typeof(IThreadManager));
deps.RegisterLazySingleton(() => new Directory(), typeof(IDirectory));
deps.RegisterLazySingleton(() => new File(), typeof(IFile));
deps.RegisterLazySingleton(() => new SettingsManager(
deps.GetService<NLog.ILogger>()
), typeof(ISettingsManager));
deps.RegisterLazySingleton(() => new MarshallManager(
deps.GetService<NLog.ILogger>(),
deps.GetService<CrashManager>()
), typeof(IMarshallManager));
deps.RegisterLazySingleton(() => new FileSystemWatcher(
deps.GetService<NLog.ILogger>()
), typeof(IFileSystemWatcher));
deps.RegisterLazySingleton(() => new VersionManager(
deps.GetService<CrashManager>(),
deps.GetService<NLog.ILogger>()
), typeof(IVersionManager));
deps.RegisterLazySingleton(() => new VisualPinballManager(
deps.GetService<CrashManager>(),
deps.GetService<NLog.ILogger>()
), typeof(IVisualPinballManager));
deps.RegisterLazySingleton(() => new DatabaseManager(
deps.GetService<ISettingsManager>(),
deps.GetService<CrashManager>(),
deps.GetService<NLog.ILogger>()
), typeof(IDatabaseManager));
deps.RegisterLazySingleton(() => new MessageManager(
deps.GetService<IDatabaseManager>(),
deps.GetService<CrashManager>()
), typeof(IMessageManager));
deps.RegisterLazySingleton(() => new MenuManager(
deps.GetService<IFileSystemWatcher>(),
deps.GetService<ISettingsManager>(),
deps.GetService<IMarshallManager>(),
deps.GetService<IThreadManager>(),
deps.GetService<IFile>(),
deps.GetService<IDirectory>(),
deps.GetService<NLog.ILogger>()
), typeof(IMenuManager));
deps.RegisterLazySingleton(() => new PlatformManager(
deps.GetService<IMenuManager>(),
deps.GetService<IThreadManager>(),
deps.GetService<NLog.ILogger>(),
deps
), typeof(IPlatformManager));
deps.RegisterLazySingleton(() => new VpdbClient(
deps.GetService<ISettingsManager>(),
deps.GetService<IVersionManager>(),
deps.GetService<IMessageManager>(),
this,
deps.GetService<NLog.ILogger>(),
deps.GetService<CrashManager>()
), typeof(IVpdbClient));
deps.RegisterLazySingleton(() => new RealtimeManager(
deps.GetService<IVpdbClient>(),
deps.GetService<NLog.ILogger>()
), typeof(IRealtimeManager));
deps.RegisterLazySingleton(() => new JobManager(
deps.GetService<IDatabaseManager>(),
deps.GetService<IMessageManager>(),
deps.GetService<NLog.ILogger>(),
deps.GetService<CrashManager>()
), typeof(IJobManager));
deps.RegisterLazySingleton(() => new DownloadManager(
deps.GetService<IPlatformManager>(),
deps.GetService<IJobManager>(),
deps.GetService<IVpdbClient>(),
deps.GetService<ISettingsManager>(),
deps.GetService<IMessageManager>(),
deps.GetService<IDatabaseManager>(),
deps.GetService<NLog.ILogger>(),
deps.GetService<CrashManager>()
), typeof(IDownloadManager));
deps.RegisterLazySingleton(() => new GameManager(
deps.GetService<IMenuManager>(),
deps.GetService<IVpdbClient>(),
deps.GetService<ISettingsManager>(),
deps.GetService<IDownloadManager>(),
deps.GetService<IDatabaseManager>(),
deps.GetService<IVersionManager>(),
deps.GetService<IPlatformManager>(),
deps.GetService<IMessageManager>(),
deps.GetService<IRealtimeManager>(),
deps.GetService<IVisualPinballManager>(),
deps.GetService<IThreadManager>(),
deps.GetService<NLog.ILogger>()
), typeof(IGameManager));
// converters
deps.RegisterConstant(new ImageToUrlTypeConverter(), typeof(IBindingTypeConverter));
deps.RegisterConstant(new NullToCollapsedConverter(), typeof(IBindingTypeConverter));
deps.RegisterConstant(new NullToFalseConverter(), typeof(IBindingTypeConverter));
deps.RegisterConstant(new DictionaryToStringConverter(), typeof(IBindingTypeConverter));
deps.RegisterConstant(new DictionaryToBooleanConverter(), typeof(IBindingTypeConverter));
deps.RegisterConstant(new DictionaryToVisibilityConverter(), typeof(IBindingTypeConverter));
deps.RegisterConstant(new BooleanToVisibilityConverter(), typeof(IBindingTypeConverter));
// view models
deps.RegisterLazySingleton(() => new MainView(), typeof(IViewFor<MainViewModel>));
deps.RegisterLazySingleton(() => new GamesView(), typeof(IViewFor<GamesViewModel>));
deps.RegisterLazySingleton(() => new DownloadsView(), typeof(IViewFor<DownloadsViewModel>));
deps.RegisterLazySingleton(() => new MessagesView(), typeof(IViewFor<MessagesViewModel>));
deps.Register(() => new GameItemView(), typeof(IViewFor<GameItemViewModel>));
deps.Register(() => new GameResultItemView(), typeof(IViewFor<GameResultItemViewModel>));
deps.Register(() => new DownloadItemView(), typeof(IViewFor<DownloadItemViewModel>));
deps.Register(() => new MessageItemView(), typeof(IViewFor<MessageItemViewModel>));
deps.RegisterLazySingleton(() => new SettingsView(), typeof(IViewFor<SettingsViewModel>));
}
private void RegisterParts(IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.RegisterConstant(this, typeof(IScreen));
dependencyResolver.Register(() => new HomeView(), typeof(IViewFor<HomeViewModel>));
dependencyResolver.Register(() => new StarRowView(), typeof(IViewFor<StarRowViewModel>));
//dependencyResolver.Register(() => new LogInView(), typeof(IViewFor<LogInViewModel>));
}
private static void RegisterUnmountedDrivesConfiguration(IMutableDependencyResolver services,
IConfiguration configuration)
{
RegisterLinuxUnmountedDrivesConfiguration(services, configuration);
RegisterMacUnmountedDrivesConfiguration(services, configuration);
}
/// <summary>
/// Simple helper to initialize Serilog within Splat with the Wrapping Full Logger.
/// </summary>
/// <remarks>
/// You should configure Serilog prior to calling this method.
/// </remarks>
/// <param name="instance">An instance of Mutable Dependency Resolver.</param>
/// <param name="actualLogger">The serilog logger to register.</param>
/// <example>
/// <code>
/// Locator.CurrentMutable.UseSerilogWithWrappingFullLogger();
/// </code>
/// </example>
public static void UseSerilogWithWrappingFullLogger(this IMutableDependencyResolver instance, global::Serilog.ILogger actualLogger)
{
var miniLoggingWrapper = new SerilogLogger(actualLogger);
instance.RegisterConstant(new WrappingFullLogger(miniLoggingWrapper), typeof(ILogManager));
}
/// <summary>
/// Registers a lazy singleton value which will always return the specified object instance once created.
/// The value is only generated once someone requests the service from the resolver.
/// </summary>
/// <param name="resolver">The resolver to register the service type with.</param>
/// <param name="valueFactory">A factory method for generating a object of the specified type.</param>
/// <param name="serviceType">The type of service to register.</param>
/// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
public static void RegisterLazySingleton(this IMutableDependencyResolver resolver, Func <object> valueFactory, Type serviceType, string contract = null)
{
var val = new Lazy <object>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
resolver.Register(() => val.Value, serviceType, contract);
}
public static void Register(IMutableDependencyResolver services, IReadonlyDependencyResolver resolver)
{
RegisterServices(services, resolver);
RegisterViewModels(services, resolver);
}
/// <summary>
/// Unregisters the all the values for the specified type and the optional contract.
/// </summary>
/// <typeparam name="T">The type of items to unregister.</typeparam>
/// <param name="resolver">The resolver to unregister the services with.</param>
/// <param name="contract">A optional contract which indicates to only removed those items registered with this contract.</param>
public static void UnregisterAll <T>(this IMutableDependencyResolver resolver, string contract = null)
{
resolver.UnregisterAll(typeof(T), contract);
}
protected abstract void RegisterPlatformComponents(IMutableDependencyResolver splatLocator, CompositionRoot compositionRoot);
/// <summary>
/// Registers a factory for the the given <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The service type to register for.</typeparam>
/// <param name="resolver">The resolver to register the service type with.</param>
/// <param name="factory">A factory method for generating a object of the specified type.</param>
/// <param name="contract">A optional contract value which will indicates to only generate the value if this contract is specified.</param>
public static void Register <T>(this IMutableDependencyResolver resolver, Func <T> factory, string contract = null)
{
resolver.Register(() => factory(), typeof(T), contract);
}
private void RegisterScreen(IMutableDependencyResolver dependencyResolver, CompositionRoot compositionRoot)
{
dependencyResolver.RegisterLazySingleton(compositionRoot.ResolveNavigationView, typeof(IView));
}
public static void AddUtils(this IMutableDependencyResolver services)
{
services.RegisterLazySingleton <IPlatform>(Platform.GetPlatform);
services.RegisterLazySingleton <IStringFormatter>(() => new StringFormatter());
}
private void RegisterServices(IMutableDependencyResolver dependencyResolver, CompositionRoot compositionRoot)
{
}
public static void AddHttp(this IMutableDependencyResolver services)
{
services.Register(() => new HttpClient());
}
private void RegisterViews(IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.Register(CreateView <LoginPage>, typeof(IViewFor <LoginViewModel>));
}
private void RegisterScreen(IMutableDependencyResolver splatLocator, CompositionRoot compositionRoot) =>
splatLocator.RegisterConstant(compositionRoot.ResolveMainViewModel(), typeof(IScreen));
/// <summary>
/// Registers all the default registrations that are needed by the Splat module.
/// </summary>
/// <param name="resolver">The resolver to register the needed service types against.</param>
public static void InitializeSplat(this IMutableDependencyResolver resolver)
{
resolver.Register(() => new DefaultLogManager(), typeof(ILogManager));
resolver.RegisterConstant(new DebugLogger(), typeof(ILogger));
}
protected abstract void RegisterPlatformComponents(IMutableDependencyResolver splatLocator, CompositionRoot compositionRoot);
/// <summary>
/// Simple helper to initialize Log4Net within Splat with the Wrapping Full Logger.
/// </summary>
/// <remarks>
/// You should configure Log4Net prior to calling this method.
/// </remarks>
/// <param name="instance">
/// An instance of Mutable Dependency Resolver.
/// </param>
/// <example>
/// <code>
/// Locator.CurrentMutable.UseLog4NetWithWrappingFullLogger();
/// </code>
/// </example>
public static void UseLog4NetWithWrappingFullLogger(this IMutableDependencyResolver instance)
{
var funcLogManager = new FuncLogManager(type => new WrappingFullLogger(new Log4NetLogger(LogResolver.Resolve(type))));
instance.RegisterConstant(funcLogManager, typeof(ILogManager));
}
public AppBootstrapper(IMutableDependencyResolver dependencyResolver)
{
InitializeLogging();
RegisterExceptionHandlers();
RegisterTypesInContainer(dependencyResolver);
}
private static void ProcessRegistrationForNamespace(string ns, AssemblyName assemblyName, IMutableDependencyResolver resolver)
{
var targetType = ns + ".Registrations";
var fullName = targetType + ", " + assemblyName.FullName.Replace(assemblyName.Name, ns);
var registerTypeClass = Reflection.ReallyFindType(fullName, false);
if (registerTypeClass != null)
{
var registerer = (IWantsToRegisterStuff)Activator.CreateInstance(registerTypeClass);
registerer.Register((f, t) => resolver.RegisterConstant(f(), t));
}
}
private void RegisterParts(IMutableDependencyResolver dependencyResolver)
{
dependencyResolver.RegisterConstant(this, typeof(IScreen));
dependencyResolver.Register(() => new DetailsView(), typeof(IViewFor<DetailsViewModel>));
}
public static void RegisterAvaloniaServices(IMutableDependencyResolver services)
{
services.RegisterLazySingleton <IApplicationCloser>(() => new ApplicationCloser());
services.RegisterLazySingleton <IApplicationDispatcher>(() => new AvaloniaDispatcher());
services.RegisterLazySingleton <IApplicationVersionProvider>(() => new ApplicationVersionProvider());
}
/// <summary>
/// Registeres a <see cref="ModuleRegistration"/> to the <see cref="IMutableDependencyResolver"/>.
/// </summary>
/// <param name="self">Object to be extended.</param>
/// <param name="registration">Registration which should be applied.</param>
public static void RegisterModule(this IMutableDependencyResolver self, ModuleRegistration registration)
{
Guard.Against.ArgumentNull(registration, nameof(registration));
registration.Register(self);
}
/// <summary>
/// Simple helper to initialize Serilog within Splat with the Wrapping Full Logger.
/// </summary>
/// <remarks>
/// You should configure Serilog prior to calling this method.
/// </remarks>
/// <param name="instance">An instance of Mutable Dependency Resolver.</param>
/// <param name="actualLogger">The serilog logger to register.</param>
/// <example>
/// <code>
/// Locator.CurrentMutable.UseSerilogWithWrappingFullLogger();
/// </code>
/// </example>
public static void UseSerilogFullLogger(this IMutableDependencyResolver instance, global::Serilog.ILogger actualLogger)
{
var funcLogManager = new FuncLogManager(type => new SerilogFullLogger(actualLogger.ForContext(type)));
instance.RegisterConstant(funcLogManager, typeof(ILogManager));
}
