/// <summary>
        /// Resolve dependencies.
        /// </summary>
        /// <param name="resolutionComplete">Delegate called when resolution is complete.</param>
        /// <param name="forceResolution">Whether resolution should be executed when no dependencies
        /// have changed.  This is useful if a dependency specifies a wildcard in the version
        /// expression.</param>
        public static void Resolve(System.Action resolutionComplete = null,
                                   bool forceResolution             = false)
        {
            if (!buildConfigChanged)
            {
                DeleteFiles(Resolver.OnBuildSettings());
            }

            if (forceResolution)
            {
                DeleteLabeledAssets();
            }
            else
            {
                // Only resolve if user specified dependencies changed or the output files
                // differ to what is present in the project.
                var currentState  = DependencyState.GetState();
                var previousState = DependencyState.ReadFromFile();
                if (previousState != null)
                {
                    if (currentState.Equals(previousState))
                    {
                        if (resolutionComplete != null)
                        {
                            resolutionComplete();
                        }
                        return;
                    }
                    // Delete all labeled assets to make sure we don't leave any stale transitive
                    // dependencies in the project.
                    DeleteLabeledAssets();
                }
            }

            System.IO.Directory.CreateDirectory(GooglePlayServices.SettingsDialog.PackageDir);
            Resolver.DoResolution(svcSupport, GooglePlayServices.SettingsDialog.PackageDir,
                                  (oldDependency, newDependency) => {
                return(Resolver.ShouldReplaceDependency(oldDependency,
                                                        newDependency));
            },
                                  () => {
                System.Action complete = () => {
                    AssetDatabase.Refresh();
                    DependencyState.GetState().WriteToFile();
                    if (resolutionComplete != null)
                    {
                        resolutionComplete();
                    }
                };
                updateQueue.Enqueue(complete);
            });
        }
        /// <summary>
        /// Resolve dependencies.
        /// </summary>
        /// <param name="resolutionComplete">Delegate called when resolution is complete
        /// with a parameter that indicates whether it succeeded or failed.</param>
        /// <param name="forceResolution">Whether resolution should be executed when no dependencies
        /// have changed.  This is useful if a dependency specifies a wildcard in the version
        /// expression.</param>
        private static void ResolveUnsafe(Action <bool> resolutionComplete = null,
                                          bool forceResolution             = false)
        {
            JavaUtilities.CheckJdkForApiLevel();

            if (!buildConfigChanged)
            {
                DeleteFiles(Resolver.OnBuildSettings());
            }

            xmlDependencies.ReadAll(logger);

            if (forceResolution)
            {
                DeleteLabeledAssets();
            }
            else
            {
                // Only resolve if user specified dependencies changed or the output files
                // differ to what is present in the project.
                var currentState  = DependencyState.GetState();
                var previousState = DependencyState.ReadFromFile();
                if (previousState != null)
                {
                    if (currentState.Equals(previousState))
                    {
                        if (resolutionComplete != null)
                        {
                            resolutionComplete(true);
                        }
                        return;
                    }
                    // Delete all labeled assets to make sure we don't leave any stale transitive
                    // dependencies in the project.
                    DeleteLabeledAssets();
                }
            }

            System.IO.Directory.CreateDirectory(GooglePlayServices.SettingsDialog.PackageDir);
            PlayServicesSupport.Log("Resolving...", verbose: true);

            lastError = "";
            Resolver.DoResolution(svcSupport, GooglePlayServices.SettingsDialog.PackageDir,
                                  (oldDependency, newDependency) => {
                return(Resolver.ShouldReplaceDependency(oldDependency,
                                                        newDependency));
            },
                                  () => {
                System.Action complete = () => {
                    bool succeeded = String.IsNullOrEmpty(lastError);
                    AssetDatabase.Refresh();
                    DependencyState.GetState().WriteToFile();
                    PlayServicesSupport.Log(String.Format(
                                                "Resolution {0}.\n\n{1}",
                                                succeeded ? "Succeeded" : "Failed",
                                                lastError), verbose: true);
                    if (resolutionComplete != null)
                    {
                        resolutionComplete(succeeded);
                    }
                };
                updateQueue.Enqueue(complete);
            });
        }