void Awake()
    {
        this.pack = PackageManager.Instance;
//        this.objectGroup = GetComponentsInChildren<ObjectGroup>();

        this.pack.onLoaded += pack_onLoaded;
    }

        public void InstallPackageAddsAllFilesToFileSystem()
        {
            // Arrange
            var projectSystem = new MockProjectSystem();
            var sourceRepository = new MockPackageRepository();
            var pathResolver = new DefaultPackagePathResolver(projectSystem);
            var packageManager = new PackageManager(sourceRepository, pathResolver, projectSystem, 
                new SharedPackageRepository(pathResolver, projectSystem, projectSystem));

            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                             new[] { "contentFile", @"sub\contentFile" },
                                                             new[] { @"lib\reference.dll" },
                                                             new[] { @"readme.txt" });

            sourceRepository.AddPackage(packageA);

            // Act
            Install("A", new NullProjectManager(packageManager));

            // Assert
            Assert.Equal(0, projectSystem.References.Count);
            Assert.Equal(5, projectSystem.Paths.Count);
            Assert.True(projectSystem.FileExists(@"A.1.0\content\contentFile"));
            Assert.True(projectSystem.FileExists(@"A.1.0\content\sub\contentFile"));
            Assert.True(projectSystem.FileExists(@"A.1.0\lib\reference.dll"));
            Assert.True(projectSystem.FileExists(@"A.1.0\tools\readme.txt"));
            Assert.True(projectSystem.FileExists(@"A.1.0\A.1.0.nupkg"));
        }

        /// <summary>
        /// Uninstall package
        /// </summary>
        /// <param name="pkgId"></param>
        /// <returns></returns>
        public static JsonResponse UninstallPackage(string pkgId)
        {
            try
            {
                var packageManager = new PackageManager(
                    _repository,
                    new DefaultPackagePathResolver(BlogSettings.Instance.GalleryFeedUrl),
                    new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages"))
                );

                var package = _repository.FindPackage(pkgId);

                if (package == null)
                    return new JsonResponse { Success = false, Message = "Package " + pkgId + " not found" };

                packageManager.UninstallPackage(package, true);

                FileSystem.UninstallPackage(package.Id);

                BlogService.DeletePackage(pkgId);

                // reset cache
                Blog.CurrentInstance.Cache.Remove(Constants.CacheKey);

                Utils.Log(string.Format("Uninstalled package {0} by {1}", pkgId, Security.CurrentUser.Identity.Name));
            }
            catch (Exception ex)
            {
                Utils.Log("BlogEngine.Core.Packaging.Installer.UninstallPackage(" + pkgId + ")", ex);
                return new JsonResponse { Success = false, Message = "Error uninstalling package, see logs for details" };
            }

            return new JsonResponse { Success = true, Message = "Package successfully uninstalled" };
        }

        public override void ExecuteCommand()
        {
            var feedUrl = DefaultFeedUrl;
            if (!String.IsNullOrEmpty(Source)) {
                feedUrl = Source;
            }

            IPackageRepository packageRepository = RepositoryFactory.CreateRepository(new PackageSource(feedUrl));

            // Use the passed in install path if any, and default to the current dir
            string installPath = OutputDirectory ?? Directory.GetCurrentDirectory();

            var packageManager = new PackageManager(packageRepository,
                new DefaultPackagePathResolver(installPath, useSideBySidePaths: !ExcludeVersion),
                new PhysicalFileSystem(installPath));

            packageManager.Logger = Console;

            // If the first argument is a packages.config file, install everything it lists
            // Otherwise, treat the first argument as a package Id
            if (Path.GetFileName(Arguments[0]).Equals(PackageReferenceRepository.PackageReferenceFile, StringComparison.OrdinalIgnoreCase)) {
                InstallPackagesFromConfigFile(packageManager, installPath);
            }
            else {
                string packageId = Arguments[0];
                Version version = Version != null ? new Version(Version) : null;
                packageManager.InstallPackage(packageId, version);
            }
        }

 public static InstallationDefinition InstallationDefinition(PackageManager packageManager, string visualStudioVersion)
 {
     var isVisualStudioInstalled = VisualStudioDetecter.InstalledVersions.Contains(visualStudioVersion);
     var packageName = string.Format("ServiceMatrix.{0}.install", visualStudioVersion);
     var isChocolateyPackageInstalled = packageManager.IsInstalled(packageName);
     return GetInstallationDefinition(visualStudioVersion, isVisualStudioInstalled, isChocolateyPackageInstalled, packageName);
 }

        private IEnumerable<ITaskItem> ResolvePackage(ITaskItem package)
        {
            string id = package.ItemSpec;
            string version = package.GetMetadata("Version");

            Log.LogMessage(MessageImportance.Normal, "Resolving Package Reference {0} {1}...", id, version);

            // Initial version just searches a machine-level repository

            var localFs = new PhysicalFileSystem(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Lib"));
            var defaultResolver = new DefaultPackagePathResolver(localFs);
            var machineRepo = new LocalPackageRepository(defaultResolver, localFs);
            var buildRepo = new BuildPackageRepository();
            var remoteRepo = new DataServicePackageRepository(new Uri("https://nuget.org/api/v2"));
            var project = new BuildProjectSystem(ProjectDirectory, new FrameworkName(TargetFramework), CurrentReferences);
            var manager = new PackageManager(remoteRepo, defaultResolver, localFs, machineRepo);
            var projectManager = new ProjectManager(remoteRepo, defaultResolver, project, buildRepo);

            // Install the package
            var ver = new SemanticVersion(version);
            manager.PackageInstalling += manager_PackageInstalling;
            manager.InstallPackage(id, ver);
            projectManager.AddPackageReference(id, ver);

            return project.OutputReferences.Select(item =>
            {
                var name = AssemblyName.GetAssemblyName(item);
                return new TaskItem(name.FullName, new Dictionary<string, string>() {
                    {"HintPath", item },
                    {"Private", "true"}
                });
            });
        }

        public void ExistsTest( )
        {
            Device device = GetFirstDevice ( );

            PackageManager pm = new PackageManager ( device );
            Assert.True ( pm.Exists ( "com.android.contacts" ) );
            Assert.False ( pm.Exists ( "foo.bar.package" ) );
        }

 public static bool IsKitKatWithStepCounter(PackageManager pm)
 {
     // Require at least Android KitKat
         int currentApiVersion = (int)Build.VERSION.SdkInt;
         // Check that the device supports the step counter and detector sensors
         return currentApiVersion >= 19
         && pm.HasSystemFeature (Android.Content.PM.PackageManager.FeatureSensorStepCounter);
 }

 public void TestFixtureSetUp()
 {
     _mockFileSystem = new MockFileSystem();
     _packageManager = new PackageManager(
         AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(Utilities.GetFactory(),
                                                                        Utilities.GetSourceProvider(),
                                                                        new List<string>() { "Dev" }),
         new DefaultPackagePathResolver(_mockFileSystem), _mockFileSystem);
 }

        public void RefreshPackagesTest( )
        {
            Device device = GetFirstDevice ( );

            PackageManager pm = new PackageManager ( device );
            pm.RefreshPackages ( );

            Assert.IsTrue ( pm.Packages.ContainsKey ( "com.android.contacts" ) );
            Assert.IsTrue ( pm.Packages.ContainsKey ( "android" ) ); // the framework
        }

 public InstallingViewModel(PackageDefinitionService packageDefinitionDiscovery, ChocolateyInstaller chocolateyInstaller, IEventAggregator eventAggregator, PackageManager packageManager, IWindowManager windowManager, PowerShellRunner powerShellRunner, List<string> itemsToInstall)
 {
     PackageDefinitionService = packageDefinitionDiscovery;
     this.chocolateyInstaller = chocolateyInstaller;
     this.eventAggregator = eventAggregator;
     this.packageManager = packageManager;
     this.windowManager = windowManager;
     this.powerShellRunner = powerShellRunner;
     this.itemsToInstall = itemsToInstall;
 }

    public static InstallationDefinition InstallationDefinition(PackageManager packageManager)
    {
        var versionsToInstall = VisualStudioDetecter.InstalledVersions.Where(version => supportedVersions.Contains(version));

        var installationDefinition = new InstallationDefinition
        {
            SortOrder = 20,
            Name = "ServiceMatrix",
            Image = "/Images/SM.png",
            Disabled = true,
            ToolTip = "ServiceMatrix requires Visual Studio 2012 to be installed,",
            PackageDefinitions = new List<PackageDefinition>(),
            SelectedByDefault = false
        };

        foreach (var version in versionsToInstall)
        {
            var packageName = "ServiceMatrix." + version + ".install";

            if (packageManager.IsInstalled(packageName))
            {
                continue;
            }

            installationDefinition.PackageDefinitions.Add(new PackageDefinition
                 {
                     Name =packageName,
                     DisplayName = "ServiceMatrix for " + version
                 });
        }

        if (installationDefinition.PackageDefinitions.Any())
        {
            installationDefinition.Status = "Install";
            installationDefinition.SelectedByDefault = true;
            installationDefinition.Disabled = false;
            installationDefinition.ToolTip = "Install ServiceMatrix";
        }
        else
        {
            if (versionsToInstall.Any())
            {
                installationDefinition.Status = "Already installed";
                installationDefinition.ToolTip = "ServiceMatrix for Visual Studio 2012";
            }
            else
            {
                installationDefinition.Status = "VS 2012 required";
                installationDefinition.ToolTip = "ServiceMatrix requires Visual Studio 2012";
            }
        }

        return installationDefinition;
    }

        public void RefreshPackagesTest( )
        {
            Device device = GetFirstDevice ( );

            PackageManager pm = new PackageManager ( device );
            Assert.DoesNotThrow ( new Assert.ThrowsDelegate ( delegate ( ) {
                pm.RefreshPackages ( );
            } ) );

            Assert.True ( pm.Packages.ContainsKey ( "com.android.contacts" ) );
            Assert.True ( pm.Packages.ContainsKey ( "android" ) ); // the framework
        }

        public void Execute(IPackage package, string packagePath)
        {
            var dialog = new OpenFileDialog();
            var result = dialog.ShowDialog();

            if (result == DialogResult.OK)
            {
                var provider = new EnvironmentProvider();

                var packageManager = new PackageManager(provider);
                packageManager.ConfigurePackage(packagePath, dialog.FileNames[0], @"c:\temp\packageexplorer");
            }
        }

        internal bool AppToTakePicturesExists(PackageManager pkgManager)
        {
            // Check if there is an application that can take pictures
            var intent = new Intent (MediaStore.ActionImageCapture);
            IList<ResolveInfo> availableActivities =  pkgManager.QueryIntentActivities (intent, PackageInfoFlags.MatchDefaultOnly);

            foreach (var item in availableActivities) {

                Log.Info ("AVAILABLE CAMERA APPS", item.ToString());
            }

            return availableActivities != null && availableActivities.Count > 0;
        }

    public NuGetDownloader(string nugetName, IEnumerable<string> repositories)
    {
        package = nugetName;

        var nugetCacheDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Cache");

        var reposToUse = new List<IPackageRepository>
        {
            PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory)
        };

        reposToUse.AddRange(repositories.ToList().Select(r => PackageRepositoryFactory.Default.CreateRepository(r)));
        var repo = new AggregateRepository(reposToUse);

        packageManager = new PackageManager(repo, "packages");
    }

        public void UninstallingPackageWithNoDependents()
        {
            // Arrange
            var localRepository = new MockPackageRepository();
            var sourceRepository = new MockPackageRepository();
            var projectSystem = new MockProjectSystem();
            var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
            var package = PackageUtility.CreatePackage("foo", "1.2.33");
            localRepository.AddPackage(package);

            // Act
            packageManager.UninstallPackage("foo");

            // Assert
            Assert.False(packageManager.LocalRepository.Exists(package));
        }

        public IPackageInstaller CreatePackageInstaller(string installationPath, string configurationPath)
        {
            var packagePath = this.configurationManager.PackagePath;
            var sourceRepository = this.source.CreatePackageRepository();
            var logger = new PackageLogger();
            var packagePathResolver = new DefaultPackagePathResolver(packagePath);
            var fileSystem = new PhysicalFileSystem(installationPath ?? this.directorySystem.CurrentDirectory) { Logger = logger };
            var destinationRepository = new LocalPackageRepository(packagePath);
            var manager = new PackageManager(
                sourceRepository, packagePathResolver, fileSystem, destinationRepository) { Logger = logger };
            var powerShellPackageFile = new PowerShellPackageFile(
                new BackgroundProcess(),
                manager,
                new PhysicalFileSystem(this.directorySystem.TemporaryPath),
                configurationPath);

            return new DefaultPackageInstaller(manager, powerShellPackageFile, logger);
        }

        /// <summary>
        /// Install package
        /// </summary>
        /// <param name="pkgId"></param>
        public static JsonResponse InstallPackage(string pkgId)
        {
            try
            {
                if(BlogService.InstalledFromGalleryPackages() != null && 
                    BlogService.InstalledFromGalleryPackages().Find(p => p.PackageId == pkgId) != null)
                    UninstallPackage(pkgId);

                var packageManager = new PackageManager(
                    _repository,
                    new DefaultPackagePathResolver(BlogSettings.Instance.GalleryFeedUrl),
                    new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages"))
                );

                var package = _repository.FindPackage(pkgId);

                packageManager.InstallPackage(package, false, true);

                var iPkg = new InstalledPackage { PackageId = package.Id, Version = package.Version.ToString() };
                BlogService.InsertPackage(iPkg);

                var packageFiles = FileSystem.InstallPackage(package.Id, package.Version.ToString());
                BlogService.InsertPackageFiles(packageFiles);

                Blog.CurrentInstance.Cache.Remove(Constants.CacheKey);

                Utils.Log(string.Format("Installed package {0} by {1}", pkgId, Security.CurrentUser.Identity.Name));
            }
            catch (Exception ex)
            {
                Utils.Log("BlogEngine.Core.Packaging.Installer.InstallPackage(" + pkgId + ")", ex);
                try
                {
                    UninstallPackage(pkgId);
                }
                catch (Exception)
                {
                    // just trying to clean up if package did not installed properly
                }
                return new JsonResponse { Success = false, Message = "Error installing package, see logs for details" };
            }

            return new JsonResponse { Success = true, Message = "Package successfully installed" };
        }

    public static int Main(string[] args)
    {
        Console.WriteLine("Copyright (c) Microsoft Corporation. All rights reserved.");
        Console.WriteLine("FindPackagesWithPackageTypes sample");
        Console.WriteLine();

        PackageManager packageManager = new PackageManager();

        try
        {
            PackageTypes type = PackageTypes.Main;
            IEnumerable<Package> packages = (IEnumerable<Package>) packageManager.FindPackagesWithPackageTypes(type);

            int packageCount = 0;
            foreach (var package in packages)
            {
                DisplayPackageInfo(package);

                Console.WriteLine();
                packageCount += 1;
            }

            if (packageCount < 1)
            {
                Console.WriteLine("No packages were found.");
            }

        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("packageManager.FindPackagesWithPackageTypes() failed because access was denied. This program must be run from an elevated command prompt.");
            
            return 1;
        }
        catch (Exception ex)
        {
            Console.WriteLine("packageManager.FindPackagesWithPackageTypes() failed, error message: {0}", ex.Message);
            Console.WriteLine("Full Stacktrace: {0}", ex.ToString());

            return 1;
        }

        return 0;
    }