public WindowsUserInformationProvider(IRegistryTools regTools, IInternalSettings internalSettings, IEnvironmentTools envTools, ILegacyApi legacyApi, Guid?userId)
: base(internalSettings, envTools, legacyApi, userId)
{
CodeContract.RequiresArgumentNotNull <IRegistryTools>(regTools, "regTools");
registryTools = regTools;
userType = new Lazy <UserType>(() => CalculateUserType(), LazyThreadSafetyMode.ExecutionAndPublication);
}
/// <summary>
/// Main constructor that requests all required classes.
/// </summary>
/// <param name="diagnosticTelemetry"></param>
/// <param name="registryTools"></param>
public InternalSettingsBase(IDiagnosticTelemetry diagnosticTelemetry, IRegistryTools registryTools)
{
CodeContract.RequiresArgumentNotNull <IDiagnosticTelemetry>(diagnosticTelemetry, "diagnosticTelemetry");
CodeContract.RequiresArgumentNotNull <IRegistryTools>(registryTools, "registryTools");
this.registryTools = registryTools;
this.diagnosticTelemetry = diagnosticTelemetry;
}
private static IUserInformationProvider GetUserInformationProvider(IRegistryTools registryTools, IInternalSettings internalSettings, IEnvironmentTools environmentTools, ILegacyApi legacyApi, TelemetrySessionSettings telemetrySessionSettings)
{
if (Platform.IsWindows)
{
return(new WindowsUserInformationProvider(registryTools, internalSettings, environmentTools, legacyApi, telemetrySessionSettings?.UserId));
}
return(new MonoUserInformationProvider(internalSettings, environmentTools, legacyApi, telemetrySessionSettings?.UserId));
}
public DefaultExperimentationOptinStatusReader(TelemetrySession telemetrySession, IRegistryTools registryTools)
{
CodeContract.RequiresArgumentNotNull <TelemetrySession>(telemetrySession, "telemetrySession");
CodeContract.RequiresArgumentNotNull <IRegistryTools>(registryTools, "registryTools");
this.telemetrySession = telemetrySession;
this.registryTools = registryTools;
isOptedIn = new Lazy <bool>(() => GetIsOptedIn());
}
private static ILegacyApi GetLegacyApi(IRegistryTools registryTools)
{
if (Platform.IsWindows)
{
return(new LegacyApi(registryTools));
}
return(new MonoLegacyApi(registryTools));
}
public WindowsInternalSettings(IDiagnosticTelemetry diagnosticTelemetry, IRegistryTools registryTools)
: base(diagnosticTelemetry, registryTools)
{
string userEventTag = GetUserEventTag();
if (!string.IsNullOrEmpty(userEventTag))
{
diagnosticTelemetry.LogRegistrySettings("EventTag", userEventTag);
}
}
/// <summary>
/// Only for testing. Testing "fake" IE Cache or "fake" server response
/// </summary>
/// <param name="requestor"></param>
/// <param name="theRegistryTools"></param>
/// <param name="hostId"></param>
/// <param name="baseUrl"></param>
/// <param name="relativePath"></param>
/// <param name="pollingIntervalMins"></param>
/// <param name="httpRequestTimeoutSeconds"></param>
/// <param name="maxRandomDownloadDelaySeconds"></param>
internal RemoteControlClient(IRemoteControlHTTPRequestor requestor, IRegistryTools theRegistryTools, string hostId, string baseUrl, string relativePath, int pollingIntervalMins = 1380, int httpRequestTimeoutSeconds = 60, int maxRandomDownloadDelaySeconds = 0)
: this(theRegistryTools, hostId, baseUrl, relativePath, pollingIntervalMins)
{
this.maxRandomDownloadDelaySeconds = maxRandomDownloadDelaySeconds;
this.requestor = requestor;
cacheUpdateTimer = new Timer(delegate(object o)
{
CacheUpdateTimerCallback(o, cancellationToken.Token).SwallowException();
}, null, -1, -1);
}
public LegacyApi(IRegistryTools registryTools)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
if (registryTools == null)
{
registryTools = (IRegistryTools)(object)new RegistryTools();
}
this.registryTools = registryTools;
}
public WindowsMachinePropertyProvider(IMachineInformationProvider machineInformationProvider, IRegistryTools regTools, IMACInformationProvider macInformationProvider)
{
CodeContract.RequiresArgumentNotNull <IMachineInformationProvider>(machineInformationProvider, "machineInformationProvider");
CodeContract.RequiresArgumentNotNull <IRegistryTools>(regTools, "regTools");
CodeContract.RequiresArgumentNotNull <IMACInformationProvider>(macInformationProvider, "macInformationProvider");
this.machineInformationProvider = machineInformationProvider;
registryTools = regTools;
this.macInformationProvider = macInformationProvider;
memoryInformation = new Lazy <NativeMethods.MemoryStatus>(() => InitializeOSMemoryInformation(), false);
systemInformation = new Lazy <NativeMethods.SystemInfo>(() => InitializeSystemInformation(), false);
processorDescription = new Lazy <string>(() => InitializeProcessorDescription(), false);
processorFrequency = new Lazy <int?>(() => registryTools.GetRegistryIntValueFromLocalMachineRoot("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", "~MHz", (int?)null), false);
azureVMImageName = new Lazy <string>(() => InitializeAzureVMImageName(), false);
}
private RemoteControlClient(IRegistryTools registryTools, string hostId, string baseUrl, string relativePath, int pollingIntervalMins)
{
Uri = RemoteControlUri.Create(registryTools, hostId, baseUrl, relativePath);
PollingIntervalMins = Math.Max(5, pollingIntervalMins);
int num = 0;
try
{
num = Convert.ToInt32(registryTools.GetRegistryValueFromCurrentUserRoot("Software\\Coding4Fun\\VisualStudio\\RemoteControl", "TurnOffSwitch", 0));
}
catch
{
}
isDisabled = (num == 1);
}
public WindowsOSPropertyProvider(IEnvironmentTools envTools, IRegistryTools regTools)
{
CodeContract.RequiresArgumentNotNull <IEnvironmentTools>(envTools, "envTools");
CodeContract.RequiresArgumentNotNull <IRegistryTools>(regTools, "regTools");
environmentTools = envTools;
registryTools = regTools;
buildLabInfo = new Lazy <string>(() => InitializeBuildLabInfo(), false);
displayInfo = new Lazy <DisplayInformation>(() => InitializeDisplayInfo(), false);
operatingSystemVersionInfo = new Lazy <OSVersionInfo>(() => InitializeOSVersionInfo(), false);
productNameInfo = new Lazy <string>(() => InitializeProductNameInfo(), false);
rootDriveInfo = new Lazy <RootDriveInfo>(() => InitializeRootDriveInfo(), false);
totalVolumesSize = new Lazy <long?>(() => InitializeTotalVolumeSize(), false);
clrInstalledVersion = new Lazy <int>(() => InitializeClrInstalledVersion(), false);
clrRunningVersion = new Lazy <string>(() => InitializeClrRunningVersion(), false);
}
private static IEnumerable <IPropertyProvider> GetPropertyProviders(IRegistryTools registryTools, IEnvironmentTools environmentTools, IHostInformationProvider host, IMachineInformationProvider machine, IMACInformationProvider macAddress, IUserInformationProvider user, IPersistentPropertyBag sharedProperties, IIdentityInformationProvider identity)
{
yield return(new IdentityPropertyProvider());
if (Platform.IsMac)
{
yield return(new MacHostPropertyProvider(host, new NsBundleInformationProvider()));
yield return(new AssemblyPropertyProvider());
yield return(new MacLocalePropertyProvider());
yield return(new MacMachinePropertyProvider(machine, registryTools, macAddress));
yield return(new MacOSPropertyProvider(environmentTools));
yield return(new MacUserPropertyProvider(user));
yield return(new PersistentSharedPropertyProvider(sharedProperties));
}
else if (Platform.IsLinux)
{
yield return(new LinuxHostPropertyProvider(host));
yield return(new AssemblyPropertyProvider());
yield return(new LinuxLocalePropertyProvider());
yield return(new PersistentSharedPropertyProvider(sharedProperties));
}
else
{
yield return(new WindowsHostPropertyProvider(host));
yield return(new AssemblyPropertyProvider());
yield return(new WindowsLocalePropertyProvider(registryTools));
yield return(new WindowsMachinePropertyProvider(machine, registryTools, macAddress));
yield return(new WindowsOSPropertyProvider(environmentTools, registryTools));
yield return(new WindowsUserPropertyProvider(user));
yield return(new PersistentSharedPropertyProvider(sharedProperties));
}
}
/// <summary>
/// Creates a new URI with optional redirect.
/// </summary>
/// <param name="registryTools"></param>
/// <param name="hostId"></param>
/// <param name="baseUrl"></param>
/// <param name="relativePath"></param>
/// <returns></returns>
public static RemoteControlUri Create(IRegistryTools registryTools, string hostId, string baseUrl, string relativePath)
{
registryTools.RequiresArgumentNotNull("registryTools");
hostId.RequiresArgumentNotNullAndNotEmpty("hostId");
baseUrl.RequiresArgumentNotNullAndNotEmpty("baseUrl");
relativePath.RequiresArgumentNotNullAndNotEmpty("relativePath");
Uri uri = new Uri(baseUrl).AddSegment(hostId).AddSegment(relativePath);
Tuple <Uri, string> tuple = uri.SplitLastSegment();
string absoluteUri = tuple.Item1.AbsoluteUri;
object registryValueFromCurrentUserRoot = registryTools.GetRegistryValueFromCurrentUserRoot("Software\\Coding4Fun\\VisualStudio\\RemoteControl\\TestUrlMapping", absoluteUri);
if (registryValueFromCurrentUserRoot != null)
{
uri = new Uri(registryValueFromCurrentUserRoot.ToString()).AddSegment(tuple.Item2);
}
return(new RemoteControlUri(uri, hostId));
}
public OSInformationProvider(IRegistryTools registryTools)
{
CodeContract.RequiresArgumentNotNull <IRegistryTools>(registryTools, "registryTools");
this.registryTools = registryTools;
}
/// <summary>
/// Only for testing. Testing local functionality
/// </summary>
/// <param name="theRegistryTools"></param>
/// <param name="theFileReader"></param>
/// <param name="hostId"></param>
/// <param name="baseUrl"></param>
/// <param name="relativePath"></param>
internal RemoteControlClient(IRegistryTools theRegistryTools, IFileReader theFileReader, string hostId, string baseUrl, string relativePath)
: this(theRegistryTools, hostId, baseUrl, relativePath, 1380)
{
fileReader = theFileReader;
}
protected virtual bool SaveMachineIdToRegistry(IRegistryTools registry, string regPath, string regKey, string machineId)
{
return(registry.SetRegistryFromLocalMachineRoot(regPath, regKey, (object)machineId, true));
}
public WindowsLocalePropertyProvider(IRegistryTools regTools)
{
CodeContract.RequiresArgumentNotNull <IRegistryTools>(regTools, "regTools");
registryTools = regTools;
systemInfo = new Lazy <CultureInfo>(() => InitializeSystemInformation(), false);
}
public MonoInternalSettings(IDiagnosticTelemetry diagnosticTelemetry, IRegistryTools registryTools)
: base(diagnosticTelemetry, registryTools)
{
LoadChannelSettings();
}
protected override string ReadMachineIdFromRegistry(IRegistryTools registry, string regPath, string regKey)
{
return((string)registry.GetRegistryValueFromCurrentUserRoot(regPath, regKey, (object)null));
}
public MacMachinePropertyProvider(IMachineInformationProvider machineInformationProvider, IRegistryTools regTools, IMACInformationProvider macInformationProvider)
{
CodeContract.RequiresArgumentNotNull <IMachineInformationProvider>(machineInformationProvider, "machineInformationProvider");
CodeContract.RequiresArgumentNotNull <IRegistryTools>(regTools, "regTools");
CodeContract.RequiresArgumentNotNull <IMACInformationProvider>(macInformationProvider, "macInformationProvider");
this.machineInformationProvider = machineInformationProvider;
this.macInformationProvider = macInformationProvider;
memoryInformation = new Lazy <PerformanceCounter>(() => InitializeOSMemoryInformation(), false);
systemInformation = new Lazy <SystemInfo>(() => InitializeSystemInformation(), false);
}
protected override bool SaveMachineIdToRegistry(IRegistryTools registry, string regPath, string regKey, string machineId)
{
return(registry.SetRegistryFromCurrentUserRoot(regPath, regKey, (object)machineId));
}
protected virtual string ReadMachineIdFromRegistry(IRegistryTools registry, string regPath, string regKey)
{
return((string)registry.GetRegistryValueFromLocalMachineRoot(regPath, regKey, true, (object)null));
}
private static IInternalSettings GetInternalSettings(IDiagnosticTelemetry diagnosticTelemetry, IRegistryTools registryTools)
{
if (Platform.IsWindows)
{
return(new WindowsInternalSettings(diagnosticTelemetry, registryTools));
}
return(new MonoInternalSettings(diagnosticTelemetry, registryTools));
}
public MonoLegacyApi(IRegistryTools registryTools)
: base(registryTools)
{
}