Merge remote-tracking branch 'upstream/master' into video_player_avplay_upgrade

xiaowei-guan · xiaowei-guan · commit 63fa911257e2 · 2025-10-23T21:12:02.000+08:00
diff --git a/packages/tizen_package_manager/CHANGELOG.md b/packages/tizen_package_manager/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.4.0
+
+* Add retrieve package size information using `PackageManager.getPackageSizeInfo`.
+
 ## 0.3.0
 
 * Update minimum Flutter and Dart version to 3.13 and 3.1.
diff --git a/packages/tizen_package_manager/README.md b/packages/tizen_package_manager/README.md
@@ -10,7 +10,7 @@ To use this package, add `tizen_package_manager` as a dependency in your `pubspe
 
 ```yaml
 dependencies:
-  tizen_package_manager: ^0.3.0
+  tizen_package_manager: ^0.4.0
 ```
 
 ### Retrieving specific package info
@@ -22,6 +22,15 @@ String packageId = 'org.tizen.settings';
 PackageInfo package = await PackageManager.getPackageInfo(packageId);
 ```
 
+### Retrieving specific package size info
+
+To retrieve size information of a specific package, use `PackageManager.getPackageSizeInfo` which returns an instance of `PackageSizeInfo`.
+
+```dart
+String packageId = 'org.tizen.settings';
+PackageSizeInfo sizeInfo = await PackageManager.getPackageSizeInfo(packageId);
+```
+
 ### Retrieving all packages' info
 
 To retrieve information of all packages installed on a Tizen device, use `PackageManager.getPackagesInfo`.
diff --git a/packages/tizen_package_manager/example/integration_test/tizen_package_manager_test.dart b/packages/tizen_package_manager/example/integration_test/tizen_package_manager_test.dart
@@ -24,6 +24,13 @@ void main() {
     expect(info.isRemovable, true);
   });
 
+  testWidgets('Can get current package size info', (WidgetTester tester) async {
+    final PackageSizeInfo info = await PackageManager.getPackageSizeInfo(
+      currentPackageId,
+    );
+    expect(info.appSize, greaterThan(0)); // package size -> 160935936
+  });
+
   testWidgets('Can get all installed packages info', (
     WidgetTester tester,
   ) async {
diff --git a/packages/tizen_package_manager/example/lib/main.dart b/packages/tizen_package_manager/example/lib/main.dart
@@ -79,11 +79,15 @@ class _CurrentPackageScreenState extends State<_CurrentPackageScreen> {
 
   @override
   Widget build(BuildContext context) {
-    return FutureBuilder<PackageInfo>(
-      future: PackageManager.getPackageInfo(currentPackageId),
-      builder: (BuildContext context, AsyncSnapshot<PackageInfo> snapshot) {
+    return FutureBuilder<List<dynamic>>(
+      future: Future.wait(<Future<dynamic>>[
+        PackageManager.getPackageInfo(currentPackageId),
+        PackageManager.getPackageSizeInfo(currentPackageId),
+      ]),
+      builder: (BuildContext context, AsyncSnapshot<List<dynamic>> snapshot) {
         if (snapshot.hasData) {
-          final PackageInfo packageInfo = snapshot.data!;
+          final PackageInfo packageInfo = snapshot.data![0] as PackageInfo;
+          final PackageSizeInfo sizeInfo = snapshot.data![1] as PackageSizeInfo;
           return ListView(
             children: <Widget>[
               _infoTile('Package ID', packageInfo.packageId),
@@ -94,6 +98,20 @@ class _CurrentPackageScreenState extends State<_CurrentPackageScreen> {
               _infoTile('System app', packageInfo.isSystem.toString()),
               _infoTile('Preloaded app', packageInfo.isPreloaded.toString()),
               _infoTile('Removable', packageInfo.isRemovable.toString()),
+              const Divider(),
+              const ListTile(
+                title: Text('Package Size Information',
+                    style: TextStyle(fontWeight: FontWeight.bold)),
+              ),
+              _infoTile('Data Size', '${sizeInfo.dataSize} bytes'),
+              _infoTile('Cache Size', '${sizeInfo.cacheSize} bytes'),
+              _infoTile('App Size', '${sizeInfo.appSize} bytes'),
+              _infoTile(
+                  'External Data Size', '${sizeInfo.externalDataSize} bytes'),
+              _infoTile(
+                  'External Cache Size', '${sizeInfo.externalCacheSize} bytes'),
+              _infoTile(
+                  'External App Size', '${sizeInfo.externalAppSize} bytes'),
             ],
           );
         } else if (snapshot.hasError) {
@@ -118,6 +136,25 @@ class _PackageListScreenState extends State<_PackageListScreen>
   @override
   bool get wantKeepAlive => true;
 
+  Future<Map<String, PackageSizeInfo>> _getAllPackagesSizeInfo(
+      List<PackageInfo> packages) async {
+    final Map<String, PackageSizeInfo> sizeInfoMap =
+        <String, PackageSizeInfo>{};
+
+    for (final PackageInfo package in packages) {
+      try {
+        final PackageSizeInfo sizeInfo =
+            await PackageManager.getPackageSizeInfo(package.packageId);
+        sizeInfoMap[package.packageId] = sizeInfo;
+      } catch (e) {
+        debugPrint(
+            'Failed to get size info for package ${package.packageId}: $e');
+      }
+    }
+
+    return sizeInfoMap;
+  }
+
   @override
   Widget build(BuildContext context) {
     super.build(context);
@@ -130,23 +167,43 @@ class _PackageListScreenState extends State<_PackageListScreen>
       ) {
         if (snapshot.hasData) {
           final List<PackageInfo> packages = snapshot.data!;
-          return ListView.builder(
-            itemCount: packages.length,
-            itemBuilder: (BuildContext context, int index) {
-              final PackageInfo package = packages[index];
-              return ListTile(
-                title: Text(package.label),
-                subtitle: Padding(
-                  padding: const EdgeInsets.symmetric(vertical: 5),
-                  child: Text(
-                    'Package ID: ${package.packageId}\n'
-                    'Version: ${package.version}\n'
-                    'Type: ${package.packageType.name}\n'
-                    'System: ${package.isSystem}',
-                  ),
-                ),
-                isThreeLine: true,
-              );
+          return FutureBuilder<Map<String, PackageSizeInfo>>(
+            future: _getAllPackagesSizeInfo(packages),
+            builder: (
+              BuildContext context,
+              AsyncSnapshot<Map<String, PackageSizeInfo>> sizeSnapshot,
+            ) {
+              if (sizeSnapshot.hasData) {
+                final Map<String, PackageSizeInfo> sizeInfoMap =
+                    sizeSnapshot.data!;
+                return ListView.builder(
+                  itemCount: packages.length,
+                  itemBuilder: (BuildContext context, int index) {
+                    final PackageInfo package = packages[index];
+                    final PackageSizeInfo? sizeInfo =
+                        sizeInfoMap[package.packageId];
+
+                    return ListTile(
+                      title: Text(package.label),
+                      subtitle: Padding(
+                        padding: const EdgeInsets.symmetric(vertical: 5),
+                        child: Text(
+                          'Package ID: ${package.packageId}\n'
+                          'Version: ${package.version}\n'
+                          'Type: ${package.packageType.name}\n'
+                          'System: ${package.isSystem}'
+                          '${sizeInfo != null ? '\nApp Size: ${sizeInfo.appSize} bytes' : ''}',
+                        ),
+                      ),
+                      isThreeLine: sizeInfo != null,
+                    );
+                  },
+                );
+              } else if (sizeSnapshot.hasError) {
+                return Center(child: Text(sizeSnapshot.error.toString()));
+              } else {
+                return const Center(child: CircularProgressIndicator());
+              }
             },
           );
         } else if (snapshot.hasError) {
diff --git a/packages/tizen_package_manager/lib/tizen_package_manager.dart b/packages/tizen_package_manager/lib/tizen_package_manager.dart
@@ -115,6 +115,20 @@ class PackageManager {
     return list;
   }
 
+  /// Gets the package size information for the given package ID.
+  static Future<PackageSizeInfo> getPackageSizeInfo(String packageId) async {
+    if (packageId.isEmpty) {
+      throw ArgumentError('Must not be empty', 'packageId');
+    }
+
+    final Map<String, dynamic>? sizeInfo =
+        await _channel.invokeMapMethod<String, dynamic>(
+      'getPackageSizeInfo',
+      <String, String>{'packageId': packageId},
+    );
+    return PackageSizeInfo.fromMap(sizeInfo!);
+  }
+
   /// Installs the package located at the given path.
   ///
   /// The `http://tizen.org/privilege/packagemanager.admin` platform privilege
@@ -229,6 +243,49 @@ class PackageInfo {
   }
 }
 
+/// Represents size information of specific package.
+class PackageSizeInfo {
+  /// Creates an instance of [PackageInfo] with the given parameters.
+  PackageSizeInfo({
+    required this.dataSize,
+    required this.cacheSize,
+    required this.appSize,
+    required this.externalDataSize,
+    required this.externalCacheSize,
+    required this.externalAppSize,
+  });
+
+  /// The size of data.
+  final int dataSize;
+
+  /// The size of cache.
+  final int cacheSize;
+
+  /// The size of app.
+  final int appSize;
+
+  /// The size of external data.
+  final int externalDataSize;
+
+  /// The size of external cache.
+  final int externalCacheSize;
+
+  /// The size of external app.
+  final int externalAppSize;
+
+  /// Creates an instance of [PackageSizeInfo] from the [map].
+  static PackageSizeInfo fromMap(Map<String, dynamic> map) {
+    return PackageSizeInfo(
+      dataSize: map['dataSize'] as int,
+      cacheSize: map['cacheSize'] as int,
+      appSize: map['appSize'] as int,
+      externalDataSize: map['externalDataSize'] as int,
+      externalCacheSize: map['externalCacheSize'] as int,
+      externalAppSize: map['externalAppSize'] as int,
+    );
+  }
+}
+
 /// Represents the event arguments of [PackageManager] events.
 class PackageEvent {
   /// Creates an instance of [PackageEvent] with the given parameters.
diff --git a/packages/tizen_package_manager/pubspec.yaml b/packages/tizen_package_manager/pubspec.yaml
@@ -2,7 +2,7 @@ name: tizen_package_manager
 description: Tizen package manager APIs. Used to get information about packages installed on a Tizen device.
 homepage: https://github.com/flutter-tizen/plugins
 repository: https://github.com/flutter-tizen/plugins/tree/master/packages/tizen_package_manager
-version: 0.3.0
+version: 0.4.0
 
 environment:
   sdk: ">=3.1.0 <4.0.0"
diff --git a/packages/tizen_package_manager/tizen/src/tizen_package_manager.cc b/packages/tizen_package_manager/tizen/src/tizen_package_manager.cc
@@ -70,6 +70,7 @@ TizenPackageManager::TizenPackageManager() {
 
 TizenPackageManager::~TizenPackageManager() {
   if (package_manager_) {
+    package_size_callbacks_.clear();
     package_manager_unset_event_cb(package_manager_);
     package_manager_destroy(package_manager_);
   }
@@ -215,6 +216,58 @@ TizenPackageManager::GetAllPackagesInfo() {
   return packages_;
 }
 
+void TizenPackageManager::GetPackageSizeInfo(
+    const std::string &package_id, OnPackageSizeEvent on_package_size_result) {
+  package_size_callbacks_[package_id] =
+      std::make_unique<OnPackageSizeEvent>(on_package_size_result);
+
+  int ret = package_manager_get_package_size_info(
+      package_id.c_str(),
+      [](const char *package_id, const package_size_info_h size_info,
+         void *user_data) {
+        auto *self = static_cast<TizenPackageManager *>(user_data);
+        PackageSizeInfo package_size_info;
+
+        if (size_info) {
+          long long data_size = 0;
+          long long cache_size = 0;
+          long long app_size = 0;
+          long long external_data_size = 0;
+          long long external_cache_size = 0;
+          long long external_app_size = 0;
+
+          package_size_info_get_data_size(size_info, &data_size);
+          package_size_info_get_cache_size(size_info, &cache_size);
+          package_size_info_get_app_size(size_info, &app_size);
+          package_size_info_get_external_data_size(size_info,
+                                                   &external_data_size);
+          package_size_info_get_external_cache_size(size_info,
+                                                    &external_cache_size);
+          package_size_info_get_external_app_size(size_info,
+                                                  &external_app_size);
+
+          package_size_info.data_size = data_size;
+          package_size_info.cache_size = cache_size;
+          package_size_info.app_size = app_size;
+          package_size_info.external_data_size = external_data_size;
+          package_size_info.external_cache_size = external_cache_size;
+          package_size_info.external_app_size = external_app_size;
+
+          (*self->package_size_callbacks_[package_id])(package_size_info);
+        }
+      },
+      this);
+
+  if (ret != PACKAGE_MANAGER_ERROR_NONE) {
+    LOG_ERROR("package_manager_get_package_size_info failed: %s",
+              get_error_message(ret));
+    last_error_ = ret;
+    PackageSizeInfo package_size_info;
+    package_size_info.app_size = 0;
+    (*package_size_callbacks_[package_id])(package_size_info);
+  }
+}
+
 bool TizenPackageManager::Install(const std::string &package_path) {
   package_manager_request_h request = nullptr;
   int ret = package_manager_request_create(&request);
diff --git a/packages/tizen_package_manager/tizen/src/tizen_package_manager.h b/packages/tizen_package_manager/tizen/src/tizen_package_manager.h
@@ -10,6 +10,7 @@
 
 #include <cstdint>
 #include <functional>
+#include <map>
 #include <memory>
 #include <optional>
 #include <string>
@@ -27,12 +28,23 @@ struct PackageInfo {
   bool is_removable = false;
 };
 
+struct PackageSizeInfo {
+  long long data_size = 0;
+  long long cache_size = 0;
+  long long app_size = 0;
+  long long external_data_size = 0;
+  long long external_cache_size = 0;
+  long long external_app_size = 0;
+};
+
 enum class PacakgeEventState { kStarted, kProcessing, kFailed, kCompleted };
 
 using OnPackageEvent =
     std::function<void(std::string package_id, std::string package_type,
                        PacakgeEventState state, int32_t progress)>;
 
+using OnPackageSizeEvent = std::function<void(PackageSizeInfo size_info)>;
+
 class TizenPackageManager {
  public:
   ~TizenPackageManager();
@@ -49,6 +61,9 @@ class TizenPackageManager {
 
   std::optional<PackageInfo> GetPackageInfo(const std::string& package_id);
 
+  void GetPackageSizeInfo(const std::string& package_id,
+                          OnPackageSizeEvent on_package_size_result);
+
   std::optional<std::vector<PackageInfo>> GetAllPackagesInfo();
 
   bool Install(const std::string& package_path);
@@ -80,6 +95,8 @@ class TizenPackageManager {
   OnPackageEvent install_callback_;
   OnPackageEvent uninstall_callback_;
   OnPackageEvent update_callback_;
+  std::map<std::string, std::unique_ptr<OnPackageSizeEvent>>
+      package_size_callbacks_;
   std::vector<PackageInfo> packages_;
 
   int last_error_ = PACKAGE_MANAGER_ERROR_NONE;
diff --git a/packages/tizen_package_manager/tizen/src/tizen_package_manager_plugin.cc b/packages/tizen_package_manager/tizen/src/tizen_package_manager_plugin.cc
