[FL-2733] multitarget support for fbt (#2209)

* First part of multitarget porting
* Delete firmware/targets/f7/Inc directory
* Delete firmware/targets/f7/Src directory
* gpio: cli fixes; about: using version from HAL
* sdk: path fixes
* gui: include fixes
* applications: more include fixes
* gpio: ported to new apis
* hal: introduced furi_hal_target_hw.h; libs: added one_wire
* hal: f18 target
* github: also build f18 by default
* typo fix
* fbt: removed extra checks on app list
* api: explicitly bundling select mlib headers with sdk
* hal: f18: changed INPUT_DEBOUNCE_TICKS to match f7
* cleaned up commented out code
* docs: added info on hw targets
* docs: targets: formatting fixes
* f18: fixed link error
* f18: fixed API version to match f7
* docs: hardware: minor wording fixes
* faploader: added fw target check
* docs: typo fixes
* github: not building komi target by default
* fbt: support for `targets` field for built-in apps
* github: reworked build flow to exclude app_set; fbt: removed komi-specific appset; added additional target buildset check
* github: fixed build; nfc: fixed pvs warnings
* attempt to fix target id
* f7, f18: removed certain HAL function from public API
* apps: debug: enabled bt_debug_app for f18
* Targets: backport input pins configuration routine from F7 to F18

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

scripts/fbt/appmanifest.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Callable
 from enum import Enum
 import os
 
@@ -71,6 +71,9 @@ class FlipperApplication:
     _appdir: Optional[object] = None
     _apppath: Optional[str] = None
 
+    def supports_hardware_target(self, target: str):
+        return target in self.targets or "all" in self.targets
+
 
 class AppManager:
     def __init__(self):
@@ -158,15 +161,26 @@ class AppBuildset:
         FlipperAppType.STARTUP,
     )
 
-    def __init__(self, appmgr: AppManager, appnames: List[str], hw_target: str):
+    @staticmethod
+    def print_writer(message):
+        print(message)
+
+    def __init__(
+        self,
+        appmgr: AppManager,
+        appnames: List[str],
+        hw_target: str,
+        message_writer: Callable = None,
+    ):
         self.appmgr = appmgr
         self.appnames = set(appnames)
-        self.hw_target = hw_target
         self._orig_appnames = appnames
+        self.hw_target = hw_target
+        self._writer = message_writer if message_writer else self.print_writer
         self._process_deps()
-        self._filter_by_target()
         self._check_conflicts()
         self._check_unsatisfied()  # unneeded?
+        self._check_target_match()
         self.apps = sorted(
             list(map(self.appmgr.get, self.appnames)),
             key=lambda app: app.appid,
@@ -175,28 +189,32 @@ class AppBuildset:
     def _is_missing_dep(self, dep_name: str):
         return dep_name not in self.appnames
 
-    def _filter_by_target(self):
-        for appname in self.appnames.copy():
-            app = self.appmgr.get(appname)
-            # if app.apptype not in self.BUILTIN_APP_TYPES:
-            if not any(map(lambda t: t in app.targets, ["all", self.hw_target])):
-                print(
-                    f"Removing {appname} due to target mismatch (building for {self.hw_target}, app supports {app.targets}"
-                )
-                self.appnames.remove(appname)
+    def _check_if_app_target_supported(self, app_name: str):
+        return self.appmgr.get(app_name).supports_hardware_target(self.hw_target)
+
+    def _get_app_depends(self, app_name: str) -> List[str]:
+        # Skip app if its target is not supported by the target we are building for
+        if not self._check_if_app_target_supported(app_name):
+            self._writer(
+                f"Skipping {app_name} due to target mismatch (building for {self.hw_target}, app supports {app_def.targets}"
+            )
+            return []
+
+        app_def = self.appmgr.get(app_name)
+        return list(
+            filter(
+                self._check_if_app_target_supported,
+                filter(self._is_missing_dep, app_def.provides + app_def.requires),
+            )
+        )
 
     def _process_deps(self):
         while True:
             provided = []
-            for app in self.appnames:
-                # print(app)
-                provided.extend(
-                    filter(
-                        self._is_missing_dep,
-                        self.appmgr.get(app).provides + self.appmgr.get(app).requires,
-                    )
-                )
-            # print("provides round", provided)
+            for app_name in self.appnames:
+                provided.extend(self._get_app_depends(app_name))
+
+            # print("provides round: ", provided)
             if len(provided) == 0:
                 break
             self.appnames.update(provided)
@@ -204,7 +222,6 @@ class AppBuildset:
     def _check_conflicts(self):
         conflicts = []
         for app in self.appnames:
-            # print(app)
             if conflict_app_name := list(
                 filter(
                     lambda dep_name: dep_name in self.appnames,
@@ -231,6 +248,17 @@ class AppBuildset:
                 f"Unsatisfied dependencies for {', '.join(f'{missing_dep[0]}: {missing_dep[1]}' for missing_dep in unsatisfied)}"
             )
 
+    def _check_target_match(self):
+        incompatible = []
+        for app in self.appnames:
+            if not self.appmgr.get(app).supports_hardware_target(self.hw_target):
+                incompatible.append(app)
+
+        if len(incompatible):
+            raise AppBuilderException(
+                f"Apps incompatible with target {self.hw_target}: {', '.join(incompatible)}"
+            )
+
     def get_apps_cdefs(self):
         cdefs = set()
         for app in self.apps: