public CopyrightLabel(IVersionTracking versionTracking)
{
this.BindTapGesture(nameof(SettingsViewModel.CopyrightLabelTappedCommand));
AutomationId = SettingsPageAutomationIds.CopyrightLabel;
LineBreakMode = LineBreakMode.WordWrap;
VerticalOptions = LayoutOptions.EndAndExpand;
HorizontalOptions = LayoutOptions.CenterAndExpand;
VerticalTextAlignment = TextAlignment.End;
HorizontalTextAlignment = TextAlignment.Center;
FontSize = 12;
FontFamily = FontFamilyConstants.RobotoMedium;
LineHeight = 1.82;
Opacity = 0.85;
#if DEBUG
var versionNumberText = $"Version {versionTracking.CurrentVersion} (Debug)";
#elif RELEASE
var versionNumberText = $"Version {versionTracking.CurrentVersion} (Release)";
#else
var versionNumberText = $"Version {versionTracking.CurrentVersion}";
#endif
Text = $"{versionNumberText}\nCreated by Code Traveler LLC";
SetDynamicResource(TextColorProperty, nameof(BaseTheme.PrimaryTextColor));
}
public ReferringSitesViewModel(IMainThread mainThread,
ReviewService reviewService,
FavIconService favIconService,
IVersionTracking versionTracking,
IAnalyticsService analyticsService,
GitHubUserService gitHubUserService,
GitHubApiV3Service gitHubApiV3Service,
DeepLinkingService deepLinkingService,
ReferringSitesDatabase referringSitesDatabase,
GitHubAuthenticationService gitHubAuthenticationService) : base(analyticsService, mainThread)
{
ReviewService.ReviewRequested += HandleReviewRequested;
ReviewService.ReviewCompleted += HandleReviewCompleted;
_reviewService = reviewService;
_favIconService = favIconService;
_versionTracking = versionTracking;
_gitHubUserService = gitHubUserService;
_gitHubApiV3Service = gitHubApiV3Service;
_deepLinkingService = deepLinkingService;
_referringSitesDatabase = referringSitesDatabase;
_gitHubAuthenticationService = gitHubAuthenticationService;
RefreshState = RefreshState.Uninitialized;
RefreshCommand = new AsyncCommand <(string Owner, string Repository, string RepositoryUrl, CancellationToken Token)>(tuple => ExecuteRefreshCommand(tuple.Owner, tuple.Repository, tuple.RepositoryUrl, tuple.Token));
NoButtonCommand = new Command(() => HandleReviewRequestButtonTapped(ReviewAction.NoButtonTapped));
YesButtonCommand = new Command(() => HandleReviewRequestButtonTapped(ReviewAction.YesButtonTapped));
UpdateStoreRatingRequestView();
}
public LoginProvider(IAppSettings appSettings, ISecureStorage secureStorage, ILoggingService loggingService,
IDeviceInfo deviceInfo, IVersionTracking versionTracking)
{
_appSettings = appSettings;
_secureStorage = secureStorage;
_loggingService = loggingService;
_deviceInfo = deviceInfo;
_versionTracking = versionTracking;
}
public static IDependencyManager RegisterRequiredServices(this IDependencyManager dependencyManager)
{
if (dependencyManager == null)
{
throw new ArgumentNullException(nameof(dependencyManager));
}
dependencyManager.RegisterXamarinEssentials();
dependencyManager.Register <IDateTimeProvider, DefaultDateTimeProvider>(lifeCycle: DependencyLifeCycle.SingleInstance, overwriteExisting: false);
dependencyManager.RegisterInstance(DefaultJsonContentFormatter.Current, overwriteExisting: false);
dependencyManager.RegisterUsing(resolver => new INavServiceFactory((prismNavService, popupNav) => DefaultNavService.INavServiceFactory <DefaultNavService>(prismNavService, popupNav)), overwriteExisting: false, lifeCycle: DependencyLifeCycle.Transient);
dependencyManager.RegisterInstance <IExceptionHandler>(BitExceptionHandler.Current);
((IAutofacDependencyManager)dependencyManager).GetContainerBuidler().RegisterBuildCallback(container =>
{
if (BitExceptionHandler.Current is BitExceptionHandler exceptionHandler)
{
exceptionHandler.ServiceProvider = container.Resolve <IServiceProvider>();
}
});
dependencyManager.RegisterInstance <ITelemetryService>(ApplicationInsightsTelemetryService.Current);
dependencyManager.RegisterInstance <ITelemetryService>(AppCenterTelemetryService.Current);
dependencyManager.RegisterInstance <ITelemetryService>(FirebaseTelemetryService.Current);
dependencyManager.RegisterInstance <ITelemetryService>(DebugTelemetryService.Current);
dependencyManager.RegisterInstance <ITelemetryService>(ConsoleTelemetryService.Current);
dependencyManager.RegisterInstance(LocalTelemetryService.Current, servicesType: new[] { typeof(LocalTelemetryService).GetTypeInfo(), typeof(ITelemetryService).GetTypeInfo() });
IContainerRegistry containerRegistry = dependencyManager.GetContainerRegistry();
containerRegistry.RegisterForNav <BitConsoleView, BitConsoleViewModel>("BitConsole");
dependencyManager.GetContainerBuilder().RegisterBuildCallback(container =>
{
IMessageReceiver?messageReceiver = container.ResolveOptional <IMessageReceiver>();
IConnectivity connectivity = container.Resolve <IConnectivity>();
IVersionTracking versionTracking = container.Resolve <IVersionTracking>();
foreach (TelemetryServiceBase telemetryService in container.Resolve <IEnumerable <ITelemetryService> >().OfType <TelemetryServiceBase>())
{
if (messageReceiver != null)
{
telemetryService.MessageReceiver = messageReceiver;
}
telemetryService.Connectivity = connectivity;
telemetryService.VersionTracking = versionTracking;
}
});
return(dependencyManager);
}
public SettingsViewModel(IVersionTracking versionTracking, IPermissions permissions, IUserDialogs userDialogs,
IPreferences preferences, IMvxMessenger messenger, ISecureStorage secureStorage, ILoginProvider loginProvider,
IFirebaseService firebaseService)
{
_versionTracking = versionTracking;
_permissions = permissions;
_userDialogs = userDialogs;
_preferences = preferences;
_messenger = messenger;
_secureStorage = secureStorage;
_loginProvider = loginProvider;
_firebaseService = firebaseService;
}
protected sealed override async void OnInitialized()
{
try
{
IEnumerable <ITelemetryService> allTelemetryServices = Container.Resolve <IEnumerable <ITelemetryService> >();
ISecurityServiceBase securityService = Container.Resolve <ISecurityServiceBase>();
IMessageReceiver?messageReceiver = Container.Resolve <ILifetimeScope>().ResolveOptional <IMessageReceiver>();
IConnectivity connectivity = Container.Resolve <IConnectivity>();
IVersionTracking versionTracking = Container.Resolve <IVersionTracking>();
IDeviceService deviceService = Container.Resolve <IDeviceService>();
bool isLoggedIn = await securityService.IsLoggedInAsync().ConfigureAwait(false);
string?userId = !isLoggedIn ? null : await securityService.GetUserIdAsync(default).ConfigureAwait(false);
public MenuViewModel(IMvxNavigationService navigationService, IAuthentificationService authentificationService,
IPreferences preferences, IVersionTracking versionTracking, IUserSettingsService userSettingsService,
IUserDialogs userDialogs, IMvxMessenger messenger, OperationsDatabase operationsDatabase, IDialogNavigationService dialogNavigationService)
{
_navigationService = navigationService;
_authentificationService = authentificationService;
_preferences = preferences;
_versionTracking = versionTracking;
_userSettingsService = userSettingsService;
_userDialogs = userDialogs;
_messenger = messenger;
_operationsDatabase = operationsDatabase;
_dialogNavigationService = dialogNavigationService;
BuildMenu();
}
public static IDependencyManager RegisterRequiredServices(this IDependencyManager dependencyManager)
{
if (dependencyManager == null)
{
throw new ArgumentNullException(nameof(dependencyManager));
}
dependencyManager.RegisterXamarinEssentials();
dependencyManager.Register <IEventAggregator, EventAggregator>(lifeCycle: DependencyLifeCycle.SingleInstance, overwriteExisting: false);
dependencyManager.Register <IDateTimeProvider, DefaultDateTimeProvider>(lifeCycle: DependencyLifeCycle.SingleInstance, overwriteExisting: false);
dependencyManager.RegisterInstance(DefaultJsonContentFormatter.Current, overwriteExisting: false);
dependencyManager.RegisterInstance <IExceptionHandler>(BitExceptionHandler.Current);
((IAutofacDependencyManager)dependencyManager).GetContainerBuidler().RegisterBuildCallback(container =>
{
if (BitExceptionHandler.Current is BitExceptionHandler exceptionHandler)
{
exceptionHandler.ServiceProvider = container.Resolve <IServiceProvider>();
}
});
dependencyManager.RegisterInstance <ITelemetryService>(DebugTelemetryService.Current);
dependencyManager.RegisterInstance <ITelemetryService>(ConsoleTelemetryService.Current);
dependencyManager.GetContainerBuilder().RegisterBuildCallback(container =>
{
IMessageReceiver?messageReceiver = container.ResolveOptional <IMessageReceiver>();
IConnectivity connectivity = container.Resolve <IConnectivity>();
IVersionTracking versionTracking = container.Resolve <IVersionTracking>();
foreach (TelemetryServiceBase telemetryService in container.Resolve <IEnumerable <ITelemetryService> >().OfType <TelemetryServiceBase>())
{
if (messageReceiver != null)
{
telemetryService.MessageReceiver = messageReceiver;
}
telemetryService.Connectivity = connectivity;
telemetryService.VersionTracking = versionTracking;
}
});
return(dependencyManager);
}
public SettingsViewModel(IMainThread mainThread,
ThemeService themeService,
LanguageService languageService,
IVersionTracking versionTracking,
IAnalyticsService analyticsService,
GitHubUserService gitHubUserService,
DeepLinkingService deepLinkingService,
NotificationService notificationService,
TrendsChartSettingsService trendsChartSettingsService,
GitHubAuthenticationService gitHubAuthenticationService)
: base(mainThread, analyticsService, gitHubUserService, deepLinkingService, gitHubAuthenticationService)
{
_themeService = themeService;
_versionTracking = versionTracking;
_languageService = languageService;
_deepLinkingService = deepLinkingService;
_notificationService = notificationService;
_trendsChartSettingsService = trendsChartSettingsService;
CopyrightLabelTappedCommand = new AsyncCommand(ExecuteCopyrightLabelTappedCommand);
GitHubUserViewTappedCommand = new AsyncCommand(ExecuteGitHubUserViewTappedCommand, _ => IsNotAuthenticating);
App.Resumed += HandleResumed;
GitHubUserService.NameChanged += HandleNameChanged;
GitHubUserService.AliasChanged += HandleAliasChanged;
GitHubUserService.AvatarUrlChanged += HandleAvatarUrlChanged;
ThemeService.PreferenceChanged += HandlePreferenceChanged;
LanguageService.PreferredLanguageChanged += HandlePreferredLanguageChanged;
GitHubAuthenticationService.AuthorizeSessionCompleted += HandleAuthorizeSessionCompleted;
ThemePickerSelectedIndex = (int)themeService.Preference;
PreferredChartsSelectedIndex = (int)trendsChartSettingsService.CurrentTrendsChartOption;
LanguagePickerSelectedIndex = CultureConstants.CulturePickerOptions.Keys.ToList().IndexOf(languageService.PreferredLanguage ?? string.Empty);
initializeIsRegisterForNotificationsSwitch().SafeFireAndForget();
InitializeText();
async Task initializeIsRegisterForNotificationsSwitch() => IsRegisterForNotificationsSwitchToggled = notificationService.ShouldSendNotifications && await notificationService.AreNotificationsEnabled().ConfigureAwait(false);
}
public SettingsViewModel(
IBrowser browser,
ILauncher launcher,
IDeviceInfo deviceInfo,
IAppInfo appInfo,
IVersionTracking versionTracking,
IEmail email,
IStoreReview storeReview,
IMuGetPackageService muGetPackageService,
IBvmConstructor bvmConstructor) : base(bvmConstructor)
{
Title = Resources.Settings;
_browser = browser;
_launcher = launcher;
_deviceInfo = deviceInfo;
_appInfo = appInfo;
_versionTracking = versionTracking;
_email = email;
_storeReview = storeReview;
_muGetPackageService = muGetPackageService;
MuGetPackages = new ObservableRangeCollection <MuGetPackage>(_muGetPackageService.GetPackages());
SettingsItemTappedCommand = new AsyncCommand <SettingItem>(SettingsItemTappedAsync);
PackageTappedCommand = new AsyncCommand <MuGetPackage>(async(p) =>
{
if (!string.IsNullOrEmpty(p?.PackageId))
{
await _launcher.TryOpenAsync(string.Format(Resources.PackageUrlFormat, p.PackageId));
}
});
ResetNotificationsCommand = new Command(ResetNotifications);
RunJobsCommand = new AsyncCommand(RunJobsAsync);
}
public NuGetService(
ICacheService cacheProvider,
IHttpHandlerService httpHandlerService,
IPreferences preferences,
IVersionTracking versionTracking,
IConnectivity connectivity,
IFileSystem fileSystem,
ILogger logger)
{
_cache = cacheProvider ?? throw new ArgumentNullException(nameof(cacheProvider));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_preferences = preferences;
_versionTracking = versionTracking;
_connectivity = connectivity;
_httpClient = new HttpClient(httpHandlerService.GetNativeHandler());
var dbPath = Path.Combine(fileSystem.AppDataDirectory, "nugets.db");
_db = new LiteDatabase($"Filename={dbPath};Upgrade=true;");
_db.Pragma("UTC_DATE", true);
_packageSourceRepo = new EntityRepository <PackageSource>(_db, TimeSpan.FromDays(7), _connectivity);
_favouriteRepo = new EntityRepository <FavouritePackage>(_db, TimeSpan.MaxValue, _connectivity);
_recentRepo = new EntityRepository <RecentPackage>(_db, TimeSpan.MaxValue, _connectivity);
_retryPolicy =
Policy.Handle <WebException>()
.Or <HttpRequestException>()
.WaitAndRetryAsync
(
retryCount: 2,
sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
);
}
public SplashScreenViewModel(IConnectivity connectivity, IPreferences preferences, IVersionTracking versionTracking,
IAuthentificationService authentificationService, IMvxNavigationService navigationService, IMvxMessenger messenger,
ISecureStorage secureStorage, IAppSettings appSettings, IUserSettingsService userSettingsService, IUserDialogs userDialogs,
WasabeeApiV1Service wasabeeApiV1Service, UsersDatabase usersDatabase, OperationsDatabase operationsDatabase, LinksDatabase linksDatabase,
MarkersDatabase markersDatabase, TeamsDatabase teamsDatabase, TeamAgentsDatabase teamAgentsDatabase)
{
_connectivity = connectivity;
_preferences = preferences;
_versionTracking = versionTracking;
_authentificationService = authentificationService;
_navigationService = navigationService;
_messenger = messenger;
_secureStorage = secureStorage;
_appSettings = appSettings;
_userSettingsService = userSettingsService;
_userDialogs = userDialogs;
_wasabeeApiV1Service = wasabeeApiV1Service;
_usersDatabase = usersDatabase;
_operationsDatabase = operationsDatabase;
_linksDatabase = linksDatabase;
_markersDatabase = markersDatabase;
_teamsDatabase = teamsDatabase;
_teamAgentsDatabase = teamAgentsDatabase;
}
public AboutVM(IVersionTracking versionTracker)
{
version = versionTracker.CurrentVersion;
}
public SettingsPage(SettingsViewModel settingsViewModel,
TrendsChartSettingsService trendsChartSettingsService,
IAnalyticsService analyticsService,
IMainThread mainThread,
IVersionTracking versionTracking) : base(settingsViewModel, analyticsService, mainThread, PageTitles.SettingsPage, true)
{
const int separatorRowHeight = 1;
const int settingsRowHeight = 38;
var loginRowTapGesture = new TapGestureRecognizer();
loginRowTapGesture.Tapped += HandleLoginRowTapped;
Content = new ScrollView
{
Content = _contentGrid = new Grid
{
RowSpacing = 8,
ColumnSpacing = 16.5,
Margin = new Thickness(30, 0, 30, 5),
RowDefinitions = Rows.Define(
(Row.GitHubUser, AbsoluteGridLength(GitHubUserView.TotalHeight)),
(Row.GitHubUserSeparator, AbsoluteGridLength(separatorRowHeight)),
(Row.Login, AbsoluteGridLength(settingsRowHeight)),
(Row.LoginSeparator, AbsoluteGridLength(separatorRowHeight)),
(Row.Notifications, AbsoluteGridLength(settingsRowHeight)),
(Row.NotificationsSeparator, AbsoluteGridLength(separatorRowHeight)),
(Row.Theme, AbsoluteGridLength(settingsRowHeight)),
(Row.ThemeSeparator, AbsoluteGridLength(separatorRowHeight)),
(Row.PreferredCharts, AbsoluteGridLength(80)),
(Row.Copyright, Star)),
ColumnDefinitions = Columns.Define(
(Column.Icon, AbsoluteGridLength(24)),
(Column.Title, StarGridLength(3)),
(Column.Button, StarGridLength(1))),
Children =
{
new GitHubUserView().Row(Row.GitHubUser).ColumnSpan(All <Column>()),
new Separator().Row(Row.GitHubUserSeparator).ColumnSpan(All <Column>()),
new LoginRowTappableView(loginRowTapGesture).Row(Row.Login).ColumnSpan(All <Column>()),
new LoginRowSvg("logout.svg", getSVGIconColor).Row(Row.Login).Column(Column.Icon),
new LoginLabel().Row(Row.Login).Column(Column.Title),
new LoginRowSvg("right_arrow.svg", getSVGIconColor).End().Row(Row.Login).Column(Column.Button),
new Separator().Row(Row.LoginSeparator).ColumnSpan(All <Column>()),
new SvgImage("bell.svg", getSVGIconColor).Row(Row.Notifications).Column(Column.Icon),
new RegisterForNotificationsLabel().Row(Row.Notifications).Column(Column.Title),
new EnableNotificationsSwitch().Row(Row.Notifications).Column(Column.Button),
new Separator().Row(Row.NotificationsSeparator).ColumnSpan(All <Column>()),
new SvgImage("theme.svg", getSVGIconColor).Row(Row.Theme).Column(Column.Icon),
new ThemeLabel().Row(Row.Theme).Column(Column.Title),
new ThemePicker().Row(Row.Theme).Column(Column.Button),
new Separator().Row(Row.ThemeSeparator).ColumnSpan(All <Column>()),
new PreferredChartsView(settingsViewModel).Row(Row.PreferredCharts).ColumnSpan(All <Column>()),
new CopyrightLabel(versionTracking).Row(Row.Copyright).ColumnSpan(All <Column>())
}
}
};
public AboutViewModel(IVersionTracking versionTracker)
{
Version = versionTracker.CurrentVersion;
}
public VersionTrackingService(IVersionTracking versionTracking)
{
_versionTracking = versionTracking;
}
