[uwptool] Add uninstall command (#26122)

Adds an uninstall command that uninstalls the specified application by
its package family name.

This currently attempts to remove for all users, but in future, we may
want to restrict install and uninstall to the current user only.

Also renames ApplicationStore::GetInstalledApplications() to
ApplicationStore::GetApps()

Author: cbracken

shell/platform/windows/uwptool_main.cc

@@ -20,34 +20,54 @@ namespace {
 // Prints a list of installed UWP apps to stdout.
 void PrintInstalledApps() {
   flutter::ApplicationStore app_store;
-  for (const flutter::Application& app : app_store.GetInstalledApplications()) {
+  for (const flutter::Application& app : app_store.GetApps()) {
     std::wcout << app.GetPackageFamily() << std::endl;
   }
 }
 
-// Launches the app installed on the system whose Application User Model ID is
-// prefixed with app_id, with the specified arguments list.
+// Launches the app installed on the system with the specified package.
 //
 // Returns -1 if no matching app, or multiple matching apps are found, or if
 // the app fails to launch. Otherwise, the process ID of the launched app is
 // returned.
 int LaunchApp(const std::wstring_view package_family,
               const std::wstring_view args) {
   flutter::ApplicationStore app_store;
-  std::optional<flutter::Application> app =
-      app_store.GetInstalledApplication(package_family);
-  if (!app) {
-    return -1;
+  for (flutter::Application& app : app_store.GetApps(package_family)) {
+    int process_id = app.Launch(args);
+    if (process_id != -1) {
+      return process_id;
+    }
   }
-  return app->Launch(args);
+  return -1;
+}
+
+// Uninstalls the app with the specified package.
+//
+// Returns true on success.
+bool UninstallApp(const std::wstring_view package_family) {
+  bool success = true;
+  flutter::ApplicationStore app_store;
+  for (flutter::Application& app : app_store.GetApps(package_family)) {
+    if (app.Uninstall()) {
+      std::wcerr << L"Uninstalled application " << app.GetPackageFullName()
+                 << std::endl;
+    } else {
+      std::wcerr << L"error: Failed to uninstall application "
+                 << app.GetPackageFullName() << std::endl;
+      success = false;
+    }
+  }
+  return success;
 }
 
 // Prints the command usage to stderr.
 void PrintUsage() {
-  std::cerr << "usage: uwptool COMMAND [APP_ID]" << std::endl;
+  std::cerr << "usage: uwptool COMMAND [ARGUMENTS]" << std::endl;
   std::cerr << "commands:" << std::endl;
-  std::cerr << "  listapps        list installed applications" << std::endl;
-  std::cerr << "  launch          launch an application" << std::endl;
+  std::cerr << "  listapps                  list installed apps" << std::endl;
+  std::cerr << "  launch PACKAGE_FAMILY     launch an app" << std::endl;
+  std::cerr << "  uninstall PACKAGE_FAMILY  uninstall an app" << std::endl;
 }
 
 }  // namespace
@@ -67,12 +87,12 @@ int main(int argc, char** argv) {
     PrintInstalledApps();
     return 0;
   } else if (command == "launch") {
-    if (command_line.positional_args().size() < 1) {
+    if (args.size() < 2) {
       PrintUsage();
       return 1;
     }
 
-    // Get the package family.
+    // Get the package family name.
     std::string package_family = args[1];
 
     // Concatenate the remaining args, comma-separated.
@@ -97,6 +117,13 @@ int main(int argc, char** argv) {
     // Write the PID to stdout. The flutter tool reads this value in.
     std::cout << process_id << std::endl;
     return 0;
+  } else if (command == "uninstall") {
+    if (args.size() < 2) {
+      PrintUsage();
+      return 1;
+    }
+    std::string package_family = args[1];
+    return UninstallApp(flutter::Utf16FromUtf8(package_family)) ? 0 : 1;
   }
 
   std::cerr << "Unknown command: " << command << std::endl;

shell/platform/windows/uwptool_utils.cc

@@ -12,16 +12,20 @@
 #include <winrt/Windows.Management.Deployment.h>
 #include <winrt/base.h>
 
+#include <iostream>
 #include <optional>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 namespace flutter {
 
-Application::Application(const std::wstring_view package_family,
+Application::Application(const std::wstring_view package_name,
+                         const std::wstring_view package_family,
                          const std::wstring_view package_full_name)
-    : package_family_(package_family), package_full_name_(package_full_name) {}
+    : package_name_(package_name),
+      package_family_(package_family),
+      package_full_name_(package_full_name) {}
 
 int Application::Launch(const std::wstring_view args) {
   // Create the ApplicationActivationManager.
@@ -45,34 +49,67 @@ int Application::Launch(const std::wstring_view args) {
   return process_id;
 }
 
-std::vector<Application> ApplicationStore::GetInstalledApplications() const {
+bool Application::Uninstall() {
+  using winrt::Windows::Foundation::AsyncStatus;
+  using winrt::Windows::Management::Deployment::PackageManager;
+  using winrt::Windows::Management::Deployment::RemovalOptions;
+
+  PackageManager package_manager;
+  auto operation = package_manager.RemovePackageAsync(
+      package_full_name_, RemovalOptions::RemoveForAllUsers);
+  operation.get();
+
+  if (operation.Status() == AsyncStatus::Completed) {
+    return true;
+  } else if (operation.Status() == AsyncStatus::Canceled) {
+    return false;
+  } else if (operation.Status() == AsyncStatus::Error) {
+    auto result = operation.GetResults();
+    std::wcerr << L"error: uninstall failed for package " << package_full_name_
+               << L" with error: " << result.ErrorText().c_str() << std::endl;
+    return false;
+  }
+  return false;
+}
+
+std::vector<Application> ApplicationStore::GetApps() const {
   using winrt::Windows::ApplicationModel::Package;
   using winrt::Windows::Management::Deployment::PackageManager;
 
   // Find packages for the current user (default for empty string).
-  PackageManager package_manager;
   std::vector<Application> apps;
-  for (const Package& package : package_manager.FindPackagesForUser(L"")) {
-    apps.emplace_back(package.Id().FamilyName().c_str(),
-                      package.Id().FullName().c_str());
+  try {
+    PackageManager package_manager;
+    for (const Package& package : package_manager.FindPackagesForUser(L"")) {
+      apps.emplace_back(package.Id().Name().c_str(),
+                        package.Id().FamilyName().c_str(),
+                        package.Id().FullName().c_str());
+    }
+  } catch (winrt::hresult_error error) {
+    return {};
   }
   return apps;
 }
 
-std::optional<Application> ApplicationStore::GetInstalledApplication(
+std::vector<Application> ApplicationStore::GetApps(
     const std::wstring_view package_family) const {
   using winrt::Windows::ApplicationModel::Package;
   using winrt::Windows::Management::Deployment::PackageManager;
 
   // Find packages for the current user (default for empty string).
-  PackageManager package_manager;
   std::vector<Application> apps;
-  for (const Package& package :
-       package_manager.FindPackagesForUser(L"", package_family)) {
-    return std::optional(Application(package.Id().FamilyName().c_str(),
-                                     package.Id().FullName().c_str()));
+  try {
+    PackageManager package_manager;
+    for (const Package& package :
+         package_manager.FindPackagesForUser(L"", package_family)) {
+      apps.emplace_back(package.Id().Name().c_str(),
+                        package.Id().FamilyName().c_str(),
+                        package.Id().FullName().c_str());
+    }
+  } catch (winrt::hresult_error error) {
+    return {};
   }
-  return std::nullopt;
+  return apps;
 }
 
 }  // namespace flutter

shell/platform/windows/uwptool_utils.h

@@ -14,23 +14,43 @@ namespace flutter {
 // A UWP application.
 class Application {
  public:
-  explicit Application(const std::wstring_view package_family,
+  explicit Application(const std::wstring_view package_name,
+                       const std::wstring_view package_family,
                        const std::wstring_view package_full_name);
   Application(const Application& other) = default;
   Application& operator=(const Application& other) = default;
 
+  // Returns the package name.
+  //
+  // The package name is a globally unique name that represents the 'friendly'
+  // name of a package.
+  std::wstring GetPackageName() const { return package_name_; }
+
   // Returns the package family.
+  //
+  // The package family is a serialized form of the package identifiers that
+  // includes the package name and publisher.
   std::wstring GetPackageFamily() const { return package_family_; }
 
   // Returns the package full name.
+  //
+  // The package full name is a serialized form of the package identifiers that
+  // includes a particular version of the package on the computer. It encodes
+  // package name, publisher, architecture and version information.
   std::wstring GetPackageFullName() const { return package_full_name_; }
 
   // Launches the application with the specified list of launch arguments.
   //
   // Returns the process ID on success, or -1 on failure.
   int Launch(const std::wstring_view args);
 
+  // Uninstalls the application.
+  //
+  // Returns true on success.
+  bool Uninstall();
+
  private:
+  std::wstring package_name_;
   std::wstring package_family_;
   std::wstring package_full_name_;
 };
@@ -44,11 +64,11 @@ class ApplicationStore {
   ApplicationStore(const ApplicationStore& other) = delete;
   ApplicationStore& operator=(const ApplicationStore& other) = delete;
 
-  // Returns a list of all installed application user model IDs.
-  std::vector<Application> GetInstalledApplications() const;
+  // Returns all installed applications.
+  std::vector<Application> GetApps() const;
 
-  // Returns a list of all installed application user model IDs.
-  std::optional<Application> GetInstalledApplication(
+  // Returns all installed applications with the specified family name.
+  std::vector<Application> GetApps(
       const std::wstring_view package_family) const;
 };
 

shell/platform/windows/uwptool_utils_unittests.cc

@@ -20,9 +20,9 @@ namespace testing {
 
 // Verify that at least one Microsoft app (e.g. Microsoft.WindowsCalculator) is
 // installed and can be found.
-TEST(ApplicationStore, GetInstalledApplications) {
-  ApplicationStore app_store;
-  std::vector<Application> apps = app_store.GetInstalledApplications();
+TEST(ApplicationStore, GetApps) {
+  ApplicationStore store;
+  std::vector<Application> apps = store.GetApps();
   EXPECT_FALSE(apps.empty());
 
   auto ms_pos = std::find_if(apps.begin(), apps.end(), [](const auto& app) {
@@ -32,16 +32,18 @@ TEST(ApplicationStore, GetInstalledApplications) {
 }
 
 // Verify that we can look up an app by family name.
-TEST(ApplicationStore, GetInstalledApplication) {
-  ApplicationStore app_store;
-  std::vector<Application> apps = app_store.GetInstalledApplications();
-  EXPECT_FALSE(apps.empty());
-
-  std::optional<Application> found_app =
-      app_store.GetInstalledApplication(apps[0].GetPackageFamily());
-  ASSERT_TRUE(found_app != std::nullopt);
-  EXPECT_EQ(found_app->GetPackageFamily(), apps[0].GetPackageFamily());
-  EXPECT_EQ(found_app->GetPackageFullName(), apps[0].GetPackageFullName());
+TEST(ApplicationStore, GetAppsByPackageFamily) {
+  ApplicationStore store;
+  std::vector<Application> all_apps = store.GetApps();
+  EXPECT_FALSE(all_apps.empty());
+
+  Application app = all_apps[0];
+  std::vector<Application> found_apps = store.GetApps(app.GetPackageFamily());
+  ASSERT_FALSE(found_apps.empty());
+  for (const Application& found_app : found_apps) {
+    EXPECT_EQ(found_app.GetPackageName(), app.GetPackageName());
+    EXPECT_EQ(found_app.GetPackageFamily(), app.GetPackageFamily());
+  }
 }
 
 }  // namespace testing