fix: 6976 - isolates for all multi product search (#6981)

* fix: 6976 - isolates for all multi product search

* code refactoring

* Better perfs for language refresh

* Update packages/smooth_app/lib/database/dao_product.dart

Author: monsieurtanuki

packages/smooth_app/lib/database/dao_product.dart

@@ -21,12 +21,14 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
       'encoded_gzipped_json';
   static const String _TABLE_PRODUCT_COLUMN_LAST_UPDATE = 'last_update';
   static const String _TABLE_PRODUCT_COLUMN_LANGUAGE = 'lc';
+  static const String _TABLE_PRODUCT_COLUMN_PRODUCT_TYPE = 'product_type';
 
   static const List<String> _columns = <String>[
     _TABLE_PRODUCT_COLUMN_BARCODE,
     _TABLE_PRODUCT_COLUMN_GZIPPED_JSON,
     _TABLE_PRODUCT_COLUMN_LAST_UPDATE,
     _TABLE_PRODUCT_COLUMN_LANGUAGE,
+    _TABLE_PRODUCT_COLUMN_PRODUCT_TYPE,
   ];
 
   static FutureOr<void> onUpgrade(
@@ -50,6 +52,12 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
         '$_TABLE_PRODUCT_COLUMN_LANGUAGE TEXT',
       );
     }
+    if (oldVersion < 8) {
+      await db.execute(
+        'alter table $_TABLE_PRODUCT add column '
+        '$_TABLE_PRODUCT_COLUMN_PRODUCT_TYPE TEXT',
+      );
+    }
   }
 
   /// Returns the [Product] that matches the [barcode], or null.
@@ -177,7 +185,7 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
     }
     await localDatabase.database.transaction(
       (final Transaction transaction) async =>
-          _bulkReplaceLoop(transaction, products, language),
+          _bulkReplaceLoop(transaction, products, language, productType),
     );
   }
 
@@ -208,6 +216,7 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
     final DatabaseExecutor databaseExecutor,
     final Iterable<Product> products,
     final OpenFoodFactsLanguage language,
+    final ProductType productType,
   ) async {
     final int lastUpdate = LocalDatabase.nowInMillis();
     final BulkManager bulkManager = BulkManager();
@@ -221,6 +230,7 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
       );
       insertParameters.add(lastUpdate);
       insertParameters.add(language.offTag);
+      insertParameters.add(product.productType?.offTag ?? productType.offTag);
     }
     await bulkManager.insert(
       bulkInsertable: this,
@@ -344,24 +354,38 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
 
     const String tableJoin =
         'p.$_TABLE_PRODUCT_COLUMN_BARCODE = a.${DaoProductLastAccess.COLUMN_BARCODE}';
+    const String columns =
+        'p.$_TABLE_PRODUCT_COLUMN_GZIPPED_JSON'
+        ',p.$_TABLE_PRODUCT_COLUMN_BARCODE'
+        ',p.$_TABLE_PRODUCT_COLUMN_PRODUCT_TYPE';
+    // we want rows with a different language - or a null language
     final String languageCondition =
         ' ('
         'p.$_TABLE_PRODUCT_COLUMN_LANGUAGE is null '
         "or p.$_TABLE_PRODUCT_COLUMN_LANGUAGE != '${language.offTag}'"
         ') ';
+    // we want rows with that type - or a null type
+    final String productTypeCondition =
+        ' ('
+        'p.$_TABLE_PRODUCT_COLUMN_PRODUCT_TYPE is null '
+        "or p.$_TABLE_PRODUCT_COLUMN_PRODUCT_TYPE = '${productType.offTag}'"
+        ') ';
 
+    // Listing the rows with a last access, ordered by last access (desc).
     final String queryWithLastAccess =
-        'select p.$_TABLE_PRODUCT_COLUMN_GZIPPED_JSON '
+        'select $columns '
         'from'
         ' $_TABLE_PRODUCT p '
         ' inner join ${DaoProductLastAccess.TABLE} a'
         '  on $tableJoin '
         'where'
         ' $languageCondition '
+        ' and $productTypeCondition '
         'order by a.${DaoProductLastAccess.COLUMN_LAST_ACCESS} desc';
 
+    // Listing the rows without a last access.
     final String queryWithoutLastAccess =
-        'select p.$_TABLE_PRODUCT_COLUMN_GZIPPED_JSON '
+        'select $columns '
         'from'
         ' $_TABLE_PRODUCT p '
         'where'
@@ -370,8 +394,27 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
         '  from ${DaoProductLastAccess.TABLE} a '
         '  where $tableJoin '
         ' ) '
+        ' and $productTypeCondition '
         ' and $languageCondition';
 
+    final Map<String, String> updates = <String, String>{};
+
+    /// Updates products that didn't have a product_type *in the table column*.
+    ///
+    /// This way, we lazily populate the database.
+    /// After one "language refresh", all products will have a populated
+    /// product_type column, so this method will do nothing afterwards.
+    Future<void> updateUnknownProductTypes() async {
+      for (final MapEntry<String, String> entry in updates.entries) {
+        await localDatabase.database.update(
+          _TABLE_PRODUCT,
+          <String, String>{_TABLE_PRODUCT_COLUMN_PRODUCT_TYPE: entry.value},
+          where: '$_TABLE_PRODUCT_COLUMN_BARCODE = ?',
+          whereArgs: <String>[entry.key],
+        );
+      }
+    }
+
     // optimization: using 2 more simple queries than a "left join" that proved
     // more expensive (less than .1s for each simple query, .5s for "left join")
     final List<String> queries = <String>[
@@ -384,21 +427,36 @@ class DaoProduct extends AbstractSqlDao implements BulkDeletable {
       final QueryCursor queryCursor = await localDatabase.database
           .rawQueryCursor(query, null);
       while (await queryCursor.moveNext()) {
-        final Product product = _getProductFromQueryResult(queryCursor.current);
-        final String barcode = product.barcode!;
+        final String barcode =
+            queryCursor.current[_TABLE_PRODUCT_COLUMN_BARCODE]! as String;
         if (excludeBarcodes.contains(barcode)) {
           continue;
         }
-        if ((product.productType ?? ProductType.food) != productType) {
+        String? foundProductType =
+            queryCursor.current[_TABLE_PRODUCT_COLUMN_PRODUCT_TYPE] as String?;
+        if (foundProductType == null) {
+          final Product product = _getProductFromQueryResult(
+            queryCursor.current,
+          );
+          foundProductType = product.productType?.offTag;
+          if (foundProductType != null) {
+            updates[barcode] = foundProductType;
+          }
+        }
+        if ((foundProductType ?? ProductType.food.offTag) !=
+            productType.offTag) {
           continue;
         }
         result.add(barcode);
         if (result.length == limit) {
+          await queryCursor.close();
+          await updateUnknownProductTypes();
           return result;
         }
       }
     }
 
+    await updateUnknownProductTypes();
     return result;
   }
 

packages/smooth_app/lib/database/local_database.dart

@@ -36,6 +36,7 @@ class LocalDatabase extends ChangeNotifier {
   Database get database => _database;
 
   UpToDateProductProvider get upToDate => _upToDateProductProvider;
+
   UpToDateProductListProvider get upToDateProductList =>
       _upToDateProductListProvider;
 
@@ -75,7 +76,7 @@ class LocalDatabase extends ChangeNotifier {
     final String databasePath = join(databasesRootPath, 'smoothie.db');
     final Database database = await openDatabase(
       databasePath,
-      version: 7,
+      version: 8,
       singleInstance: true,
       onUpgrade: _onUpgrade,
     );

packages/smooth_app/lib/query/search_products_manager.dart

@@ -1,3 +1,5 @@
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart';
 import 'package:openfoodfacts/openfoodfacts.dart';
 
 /// Type of "search products" action.
@@ -51,10 +53,43 @@ class SearchProductsManager {
     required final SearchProductsType type,
   }) async {
     await type.waitIfNeeded();
-    return OpenFoodAPIClient.searchProducts(
-      user,
-      configuration,
-      uriHelper: uriHelper,
-    );
+
+    // It's better to do the HTTP actions outside of "compute", because
+    // there are init phases for HTTP (like user agent and SSL certificates)
+    // that would need to be somehow replicated for a new "compute thread".
+    // Besides, putting HTTP in "compute" wouldn't improve the performances.
+    final Response response = await configuration.getResponse(user, uriHelper);
+    TooManyRequestsException.check(response);
+
+    final SearchResult result = await compute(_decodeProducts, response.body);
+    _removeImages(result, configuration);
+    return result;
+  }
+
+  static Future<SearchResult> _decodeProducts(
+    final String responseBody,
+  ) async => SearchResult.fromJson(
+    HttpHelper().jsonDecode(_replaceQuotes(responseBody)),
+  );
+
+  // TODO(monsieurtanuki): somehow move to/make public in off-dart
+  static String _replaceQuotes(String str) {
+    const String needle = '&quot;';
+    if (!str.contains(needle)) {
+      return str;
+    }
+    return str.replaceAll(needle, r'\"');
+  }
+
+  // TODO(monsieurtanuki): somehow move to/make public in off-dart
+  static void _removeImages(
+    final SearchResult searchResult,
+    final AbstractQueryConfiguration configuration,
+  ) {
+    if (searchResult.products != null) {
+      searchResult.products!.asMap().forEach((int index, Product product) {
+        ProductHelper.removeImages(product, configuration.language);
+      });
+    }
   }
 }