рефакторинг

App.xaml.cs

@@ -1,15 +1,28 @@
-namespace CommanderApp
+using CommanderApp.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CommanderApp;
+
+public partial class App : Application
 {
-    public partial class App : Application
+    public App()
+    {
+        InitializeComponent();
+
+        var services = new ServiceCollection();
+        ConfigureServices(services);
+        var serviceProvider = services.BuildServiceProvider();
+
+        MainPage = serviceProvider.GetService<MainPage>();
+    }
+
+    private void ConfigureServices(ServiceCollection services)
     {
-        public App()
-        {
-            InitializeComponent();
-        }
-
-        protected override Window CreateWindow(IActivationState? activationState)
-        {
-            return new Window(new AppShell());
-        }
+        services.AddSingleton<IFileSystemService, FileSystemService>();
+        services.AddSingleton<IPanelManager, PanelManager>();
+        services.AddSingleton<IFileOperations, FileOperations>();
+        services.AddSingleton<IKeyboardService, KeyboardService>();
+        services.AddSingleton<IPathHelper, PathHelper>();
+        services.AddSingleton<MainPage>();
     }
 }

FileOperations.cs

@@ -0,0 +1,129 @@
+namespace CommanderApp.Services;
+
+public class FileOperations : IFileOperations
+{
+    public async Task<bool> CopyAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        try
+        {
+            await Task.Run(() => File.Copy(sourcePath, targetPath, overwrite));
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Copy failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> MoveAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+                if (File.Exists(targetPath) && overwrite)
+                    File.Delete(targetPath);
+                File.Move(sourcePath, targetPath);
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Move failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> DeleteAsync(string path)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+                if (Directory.Exists(path))
+                    Directory.Delete(path, true);
+                else if (File.Exists(path))
+                    File.Delete(path);
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Delete failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> CreateDirectoryAsync(string path)
+    {
+        try
+        {
+            await Task.Run(() => Directory.CreateDirectory(path));
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"CreateDirectory failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> OpenFileAsync(string filePath)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+#if WINDOWS
+                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = filePath,
+                    UseShellExecute = true
+                });
+#else
+                var process = new System.Diagnostics.Process();
+                process.StartInfo.FileName = "open";
+                process.StartInfo.Arguments = $"\"{filePath}\"";
+                process.StartInfo.UseShellExecute = false;
+                process.Start();
+#endif
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"OpenFile failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> CopyDirectoryAsync(string sourceDir, string targetDir)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+                Directory.CreateDirectory(targetDir);
+
+                foreach (var file in Directory.GetFiles(sourceDir))
+                {
+                    var destFile = Path.Combine(targetDir, Path.GetFileName(file));
+                    File.Copy(file, destFile, true);
+                }
+
+                foreach (var directory in Directory.GetDirectories(sourceDir))
+                {
+                    var destDir = Path.Combine(targetDir, Path.GetFileName(directory));
+                    CopyDirectoryAsync(directory, destDir).Wait();
+                }
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"CopyDirectory failed: {ex.Message}");
+            return false;
+        }
+    }
+}

FileSystemService.cs

@@ -1,6 +1,5 @@
 using System.IO;
 using System.Linq;
-using Microsoft.Maui.Storage;
 
 namespace CommanderApp;
 
@@ -12,14 +11,12 @@ public class FileSystemService : IFileSystemService
         return FileSystem.AppDataDirectory;
 #else
         var path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
-        // Убедимся, что путь корректен
         return Path.GetFullPath(path);
 #endif
     }
 
     public IEnumerable<FileSystemItem> GetDirectoryContents(string path)
     {
-        // Нормализуем путь
         path = Path.GetFullPath(path.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
 
         if (!Directory.Exists(path))
@@ -65,7 +62,6 @@ public class FileSystemService : IFileSystemService
         catch (Exception ex)
         {
             System.Diagnostics.Debug.WriteLine($"Error reading directory {path}: {ex.Message}");
-            // Возвращаем хотя бы ".." если возможно
             if (items.Count == 0 && Directory.GetParent(path) != null)
             {
                 items.Add(new FileSystemItem

IFileOperations.cs

@@ -0,0 +1,18 @@
+namespace CommanderApp.Services;
+
+public interface IFileOperations
+{
+    Task<bool> CopyAsync(string sourcePath, string targetPath, bool overwrite = true);
+    Task<bool> MoveAsync(string sourcePath, string targetPath, bool overwrite = true);
+    Task<bool> DeleteAsync(string path);
+    Task<bool> CreateDirectoryAsync(string path);
+    Task<bool> OpenFileAsync(string filePath);
+    Task<bool> CopyDirectoryAsync(string sourceDir, string targetDir);
+}
+
+public class FileOperationResult
+{
+    public bool Success { get; set; }
+    public string Message { get; set; } = string.Empty;
+    public Exception Exception { get; set; }
+}

IFileSystemService.cs

@@ -1,8 +1,7 @@
-namespace CommanderApp
+namespace CommanderApp;
+
+public interface IFileSystemService
 {
-    public interface IFileSystemService
-    {
-        IEnumerable<FileSystemItem> GetDirectoryContents(string path);
-        string GetRootPath();
-    }
-}
+    string GetRootPath();
+    IEnumerable<FileSystemItem> GetDirectoryContents(string path);
+}

IKeyboardService.cs

@@ -0,0 +1,13 @@
+namespace CommanderApp.Services;
+
+public interface IKeyboardService
+{
+    void SetupKeyboardHandling(ContentPage page);
+    event EventHandler<KeyPressedEventArgs> KeyPressed;
+}
+
+public class KeyPressedEventArgs : EventArgs
+{
+    public string Key { get; set; } = string.Empty;
+    public string Platform { get; set; } = string.Empty;
+}

IPanelManager.cs

@@ -0,0 +1,35 @@
+using System.Collections.ObjectModel;
+
+namespace CommanderApp.Services;
+
+public interface IPanelManager
+{
+    event EventHandler<PanelStateChangedEventArgs> StateChanged;
+    
+    bool IsLeftPanelActive { get; }
+    FileSystemItem SelectedItem { get; }
+    string ActivePanelPath { get; }
+    string LeftPanelPath { get; }
+    string RightPanelPath { get; }
+    int LeftSelectedIndex { get; }
+    int RightSelectedIndex { get; }
+    
+    void SwitchToLeftPanel();
+    void SwitchToRightPanel();
+    void MoveSelection(int direction);
+    void SetSelection(int index, bool isLeftPanel);
+    void UpdatePanelPaths(string leftPath, string rightPath);
+    void ClearSelection();
+    
+    // Для привязки данных
+    ObservableCollection<FileSystemItem> LeftItems { get; }
+    ObservableCollection<FileSystemItem> RightItems { get; }
+}
+
+public class PanelStateChangedEventArgs : EventArgs
+{
+    public bool IsLeftPanelActive { get; set; }
+    public int LeftSelectedIndex { get; set; }
+    public int RightSelectedIndex { get; set; }
+    public FileSystemItem SelectedItem { get; set; }
+}

IPathHelper.cs

@@ -0,0 +1,10 @@
+namespace CommanderApp.Services;
+
+public interface IPathHelper
+{
+    string GetUserHomePath();
+    string GetRootPath();
+    string CombinePaths(params string[] paths);
+    string GetFileName(string path);
+    string GetDirectoryName(string path);
+}

KeyboardService.cs

@@ -0,0 +1,129 @@
+#if WINDOWS
+using Microsoft.UI.Xaml.Input;
+using Windows.System;
+#endif
+
+namespace CommanderApp.Services;
+
+public class KeyboardService : IKeyboardService
+{
+    public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+    public void SetupKeyboardHandling(ContentPage page)
+    {
+#if WINDOWS
+        SetupWindowsKeyboardHandling(page);
+#elif MACCATALYST
+        SetupMacKeyboardHandling(page);
+#endif
+    }
+
+#if WINDOWS
+    private void SetupWindowsKeyboardHandling(ContentPage page)
+    {
+        try
+        {
+            if (page.Handler?.PlatformView is Microsoft.UI.Xaml.FrameworkElement frameworkElement)
+            {
+                frameworkElement.KeyDown += OnWindowsKeyDown;
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Windows keyboard setup error: {ex.Message}");
+        }
+    }
+
+    private void OnWindowsKeyDown(object sender, KeyRoutedEventArgs e)
+    {
+        var key = e.Key switch
+        {
+            VirtualKey.W => "w",
+            VirtualKey.S => "s", 
+            VirtualKey.A => "a",
+            VirtualKey.D => "d",
+            VirtualKey.Space => " ",
+            VirtualKey.Enter => "enter",
+            VirtualKey.F5 => "f5",
+            VirtualKey.F6 => "f6", 
+            VirtualKey.F7 => "f7",
+            VirtualKey.F8 => "f8",
+            VirtualKey.F10 => "f10",
+            VirtualKey.H => "h",
+            _ => null
+        };
+
+        if (key != null)
+        {
+            KeyPressed?.Invoke(this, new KeyPressedEventArgs { Key = key, Platform = "Windows" });
+            e.Handled = true;
+        }
+    }
+#endif
+
+#if MACCATALYST
+    private void SetupMacKeyboardHandling(ContentPage page)
+    {
+        try
+        {
+            if (page.Handler?.PlatformView is UIKit.UIView uiView)
+            {
+                var keyHandler = new MacKeyHandler(OnMacKeyPressed);
+                keyHandler.Frame = uiView.Bounds;
+                keyHandler.AutoresizingMask = UIKit.UIViewAutoresizing.All;
+                uiView.AddSubview(keyHandler);
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Mac keyboard setup error: {ex.Message}");
+        }
+    }
+
+    private void OnMacKeyPressed(string key)
+    {
+        KeyPressed?.Invoke(this, new KeyPressedEventArgs { Key = key, Platform = "Mac" });
+    }
+
+    public class MacKeyHandler : UIKit.UIView
+    {
+        private readonly Action<string> _keyHandler;
+
+        public MacKeyHandler(Action<string> keyHandler)
+        {
+            _keyHandler = keyHandler;
+            this.BecomeFirstResponder();
+        }
+
+        public override bool CanBecomeFirstResponder => true;
+
+        public override UIKit.UIKeyCommand[] KeyCommands => new[]
+        {
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"w", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleW:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"s", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleS:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"a", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleA:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"d", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleD:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)" ", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleSpace:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"h", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleH:"))
+        };
+
+        [Foundation.Export("handleW:")]
+        void HandleW(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("w");
+
+        [Foundation.Export("handleS:")]
+        void HandleS(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("s");
+
+        [Foundation.Export("handleA:")]
+        void HandleA(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("a");
+
+        [Foundation.Export("handleD:")]
+        void HandleD(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("d");
+
+        [Foundation.Export("handleSpace:")]
+        void HandleSpace(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke(" ");
+
+        [Foundation.Export("handleH:")]
+        void HandleH(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("h");
+    }
+#endif
+}

MainPage.xaml

@@ -1,51 +1,61 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             x:Class="CommanderApp.MainPage"
-             Title="MAUI Commander">
+                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                x:Class="CommanderApp.MainPage"
+                Title="MAUI Commander">
 
     <Grid RowDefinitions="Auto, Auto, *, Auto" ColumnDefinitions="*, *">
         <!-- Пути -->
         <Label Text="{Binding LeftPath}" 
-               Grid.Row="1" Grid.Column="0"
-               Padding="12,6"
-               FontSize="14"
-               FontAttributes="Bold"
-               BackgroundColor="#f0f0f0"
-               TextColor="Black"
-               VerticalTextAlignment="Center"
-               LineBreakMode="MiddleTruncation" />
+                Grid.Row="1" Grid.Column="0"
+                Padding="12,6"
+                FontSize="14"
+                FontAttributes="Bold"
+                BackgroundColor="#f0f0f0"
+                TextColor="Black"
+                VerticalTextAlignment="Center"
+                LineBreakMode="MiddleTruncation" />
 
         <Label Text="{Binding RightPath}" 
-               Grid.Row="1" Grid.Column="1"
-               Padding="12,6"
-               FontSize="14"
-               FontAttributes="Bold"
-               BackgroundColor="#f0f0f0"
-               TextColor="Black"
-               VerticalTextAlignment="Center"
-               LineBreakMode="MiddleTruncation" />
+                Grid.Row="1" Grid.Column="1"
+                Padding="12,6"
+                FontSize="14"
+                FontAttributes="Bold"
+                BackgroundColor="#f0f0f0"
+                TextColor="Black"
+                VerticalTextAlignment="Center"
+                LineBreakMode="MiddleTruncation" />
 
         <!-- Левая панель -->
-        <CollectionView x:Name="LeftPanel"
+        <ScrollView x:Name="LeftScrollView"
                 Grid.Row="2" Grid.Column="0"
-                ItemsSource="{Binding LeftItems}"
-                SelectionMode="Single"
-                SelectionChanged="OnLeftSelectionChanged"
-                ItemSizingStrategy="MeasureAllItems">
-        </CollectionView>
+                BackgroundColor="White">
+            <VerticalStackLayout x:Name="LeftPanel" Spacing="0"/>
+        </ScrollView>
 
         <!-- Правая панель -->
-        <CollectionView x:Name="RightPanel"
+        <ScrollView x:Name="RightScrollView"
                 Grid.Row="2" Grid.Column="1"
-                ItemsSource="{Binding RightItems}"
-                SelectionMode="Single"
-                SelectionChanged="OnRightSelectionChanged"
-                ItemSizingStrategy="MeasureAllItems">
-        </CollectionView>
+                BackgroundColor="White">
+            <VerticalStackLayout x:Name="RightPanel" Spacing="0"/>
+        </ScrollView>
+
+        <!-- Визуальные индикаторы активной панели -->
+        <BoxView x:Name="LeftPanelIndicator"
+                Grid.Row="2" Grid.Column="0"
+                BackgroundColor="Transparent"
+                HeightRequest="3"
+                VerticalOptions="Start"/>
+                
+        <BoxView x:Name="RightPanelIndicator"
+                Grid.Row="2" Grid.Column="1"
+                BackgroundColor="Transparent"
+                HeightRequest="3"
+                VerticalOptions="Start"/>
 
         <!-- Toolbar -->
-        <FlexLayout Grid.Row="3"
+        <FlexLayout x:Name="ToolbarLayout"
+            Grid.Row="3"
             Grid.ColumnSpan="2"
             Padding="10"
             BackgroundColor="Transparent"
@@ -54,11 +64,12 @@
             JustifyContent="Center"
             AlignItems="Center">
 
-            <Button Text="F5 Copy"   Clicked="OnCopyClicked"   Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F6 Move"   Clicked="OnMoveClicked"   Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F7 Mkdir"  Clicked="OnMkdirClicked"  Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F8 Delete" Clicked="OnDeleteClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F10 Exit"  Clicked="OnExitClicked"   Padding="12,6" MinimumWidthRequest="80" Margin="0,0,0,8" />
+            <Button x:Name="CopyButton" Text="F5 Copy" Clicked="OnCopyClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="MoveButton" Text="F6 Move" Clicked="OnMoveClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="MkdirButton" Text="F7 Mkdir" Clicked="OnMkdirClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="DeleteButton" Text="F8 Delete" Clicked="OnDeleteClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="HomeButton" Text="Home" Clicked="OnHomeClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="ExitButton" Text="F10 Exit" Clicked="OnExitClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,0,8" />
 
         </FlexLayout>
     </Grid>

MainPage.xaml.cs

@@ -1,6 +1,6 @@
-using System.Collections.ObjectModel;
-using System.ComponentModel;
+using System.ComponentModel;
 using System.Runtime.CompilerServices;
+using CommanderApp.Services;
 using Microsoft.Maui.Controls;
 
 namespace CommanderApp;
@@ -8,468 +8,583 @@ namespace CommanderApp;
 public partial class MainPage : ContentPage, INotifyPropertyChanged
 {
     private readonly IFileSystemService _fileService;
+    private readonly IPanelManager _panelManager;
+    private readonly IFileOperations _fileOperations;
+    private readonly IKeyboardService _keyboardService;
+    private readonly IPathHelper _pathHelper;
 
-    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
-    public ObservableCollection<FileSystemItem> RightItems { get; } = new();
+    // Для визуального выделения
+    private readonly Color ActiveIndicatorColor = Color.FromArgb("#007ACC");
+    private readonly Color InactiveIndicatorColor = Colors.Transparent;
+    private readonly Color FocusedButtonColor = Color.FromArgb("#E3F2FD");
+    private readonly Color NormalButtonColor = Colors.Transparent;
 
-    private string _leftPath = string.Empty;
-    private string _rightPath = string.Empty;
-
-    // Для управления выделением и фокусом
-    private Button? _currentFocusedButton;
-    private bool _isLeftPanelActive = true;
-    private int _leftSelectedIndex = -1;
-    private int _rightSelectedIndex = -1;
+    // Для отслеживания двойного клика
+    private DateTime _lastClickTime = DateTime.MinValue;
+    private object _lastClickedButton = null;
 
     public string LeftPath
     {
-        get => _leftPath;
+        get => _panelManager.LeftPanelPath;
         set
         {
-            if (_leftPath != value)
+            if (_panelManager.LeftPanelPath != value)
             {
-                _leftPath = value;
-                NotifyPropertyChanged();
+                _panelManager.UpdatePanelPaths(value, _panelManager.RightPanelPath);
+                OnPropertyChanged();
             }
         }
     }
 
     public string RightPath
     {
-        get => _rightPath;
+        get => _panelManager.RightPanelPath;
         set
         {
-            if (_rightPath != value)
+            if (_panelManager.RightPanelPath != value)
             {
-                _rightPath = value;
-                NotifyPropertyChanged();
+                _panelManager.UpdatePanelPaths(_panelManager.LeftPanelPath, value);
+                OnPropertyChanged();
             }
         }
     }
 
-    private string _currentLeftPath = string.Empty;
-    private string _currentRightPath = string.Empty;
-
-    private FileSystemItem? _selectedLeftItem;
-    private FileSystemItem? _selectedRightItem;
-
-    // Для двойного нажатия
-    private FileSystemItem? _lastClickedItem;
-    private int _lastLeftSelectedIndex = 0;
-    private int _lastRightSelectedIndex = 0;
-    private bool? _lastIsLeftPanel;
-
-    public MainPage(IFileSystemService fileService)
+    public MainPage(IFileSystemService fileService, 
+                    IPanelManager panelManager,
+                    IFileOperations fileOperations,
+                    IKeyboardService keyboardService,
+                    IPathHelper pathHelper)
     {
         InitializeComponent();
+        
         _fileService = fileService;
+        _panelManager = panelManager;
+        _fileOperations = fileOperations;
+        _keyboardService = keyboardService;
+        _pathHelper = pathHelper;
+        
         BindingContext = this;
 
-        // Инициализация шаблонов
-        InitializeCollectionViews();
+        System.Diagnostics.Debug.WriteLine("=== MainPage constructor ===");
+
+        // Подписываемся на события
+        _panelManager.StateChanged += OnPanelStateChanged;
+        _keyboardService.KeyPressed += OnKeyPressed;
 
+        // Загружаем начальные директории
         var root = _fileService.GetRootPath();
         LoadDirectory(root, true);
         LoadDirectory(root, false);
 
-        // Устанавливаем фокус на страницу
-        this.Focus();
+        System.Diagnostics.Debug.WriteLine("=== MainPage constructor completed ===");
     }
 
-    private void InitializeCollectionViews()
+    protected override void OnAppearing()
     {
-        LeftPanel.ItemTemplate = PanelCollectionView.CreateItemTemplate(isLeftPanel: true, page: this);
-        RightPanel.ItemTemplate = PanelCollectionView.CreateItemTemplate(isLeftPanel: false, page: this);
+        base.OnAppearing();
+        System.Diagnostics.Debug.WriteLine("=== OnAppearing ===");
+        
+        Dispatcher.Dispatch(async () =>
+        {
+            await Task.Delay(300);
+            SetInitialFocus();
+        });
     }
 
+    protected override void OnHandlerChanged()
+    {
+        base.OnHandlerChanged();
+        System.Diagnostics.Debug.WriteLine($"=== OnHandlerChanged ===");
+        
+        _keyboardService.SetupKeyboardHandling(this);
+    }
 
-    //protected override void OnHandlerChanged()
-    //{
-    //    base.OnHandlerChanged();
-    //    this.Focus();
-    //}
-
-    public void HandleItemClick(FileSystemItem item, bool isLeftPanel)
+    private void OnKeyPressed(object sender, KeyPressedEventArgs e)
     {
-        if (_lastIsLeftPanel == isLeftPanel && _lastClickedItem == item)
-        {
-            // Двойной клик
-            if (isLeftPanel)
-                OnLeftItemDoubleTapped(item);
-            else
-                OnRightItemDoubleTapped(item);
-        }
-        else
+        System.Diagnostics.Debug.WriteLine($"=== KEY PRESSED: {e.Key} on {e.Platform} ===");
+        
+        MainThread.BeginInvokeOnMainThread(() =>
         {
-            // Одинарный клик - выделение
-            if (isLeftPanel)
-            {
-                _isLeftPanelActive = true;
-                _leftSelectedIndex = LeftItems.IndexOf(item);
-                _selectedLeftItem = item;
-                _selectedRightItem = null;
-            }
-            else
+            switch (e.Key)
             {
-                _isLeftPanelActive = false;
-                _rightSelectedIndex = RightItems.IndexOf(item);
-                _selectedRightItem = item;
-                _selectedLeftItem = null;
+                case "w": // W - вверх
+                    _panelManager.MoveSelection(-1);
+                    break;
+                case "s": // S - вниз
+                    _panelManager.MoveSelection(1);
+                    break;
+                case "a": // A - левая панель
+                    _panelManager.SwitchToLeftPanel();
+                    break;
+                case "d": // D - правая панель
+                    _panelManager.SwitchToRightPanel();
+                    break;
+                case " ": // Space - вход/запуск
+                case "enter": // Enter - вход/запуск
+                    OpenSelectedItem();
+                    break;
+                case "f5": // F5 - Копирование
+                    OnCopyClicked(this, EventArgs.Empty);
+                    break;
+                case "f6": // F6 - Перемещение
+                    OnMoveClicked(this, EventArgs.Empty);
+                    break;
+                case "f7": // F7 - Создать папку
+                    OnMkdirClicked(this, EventArgs.Empty);
+                    break;
+                case "f8": // F8 - Удаление
+                    OnDeleteClicked(this, EventArgs.Empty);
+                    break;
+                case "f10": // F10 - Выход
+                    OnExitClicked(this, EventArgs.Empty);
+                    break;
+                case "h": // H - Home
+                    OnHomeClicked(this, EventArgs.Empty);
+                    break;
             }
-            UpdateVisualSelection();
-        }
-        _lastIsLeftPanel = isLeftPanel;
-        _lastClickedItem = item;
+        });
     }
 
-    private void LoadDirectory(string path, bool isLeft)
+    private void OnPanelStateChanged(object sender, PanelStateChangedEventArgs e)
     {
-        var items = _fileService.GetDirectoryContents(path).ToList();
-
-        if (isLeft)
+        UpdateVisualState();
+        
+        // Устанавливаем фокус на выбранный элемент
+        if (e.IsLeftPanelActive && e.LeftSelectedIndex >= 0 && e.LeftSelectedIndex < LeftPanel.Children.Count)
         {
-            LeftItems.Clear();
-            foreach (var item in items) LeftItems.Add(item);
-            _currentLeftPath = path;
-            LeftPath = path;
-
-            // Сбрасываем выделение при загрузке новой директории
-            _leftSelectedIndex = items.Count > 0 ? 0 : -1;
+            var button = LeftPanel.Children[e.LeftSelectedIndex] as Button;
+            button?.Focus();
         }
-        else
+        else if (!e.IsLeftPanelActive && e.RightSelectedIndex >= 0 && e.RightSelectedIndex < RightPanel.Children.Count)
         {
-            RightItems.Clear();
-            foreach (var item in items) RightItems.Add(item);
-            _currentRightPath = path;
-            RightPath = path;
-
-            _rightSelectedIndex = items.Count > 0 ? 0 : -1;
+            var button = RightPanel.Children[e.RightSelectedIndex] as Button;
+            button?.Focus();
         }
-
-        UpdateVisualSelection();
-    }
-
-    // Переключаем фокус с указанием направления
-    private void MoveFocus(bool moveForward, bool isLeft)
-    {
-        var allFocusable = GetFocusableElements(isLeft);
-        var current = allFocusable.FirstOrDefault(x => x.IsFocused);
-        var next = moveForward ?
-                GetNextFocusable(current, allFocusable) :
-                GetPreviousFocusable(current, allFocusable);
-
-        next?.Focus();
     }
 
-    // Следующий элемент (для Down/Tab)
-    private View GetNextFocusable(View current, List<View> allElements)
+    private void SetInitialFocus()
     {
-        if (current == null) return allElements.FirstOrDefault();
-
-        var currentIndex = allElements.IndexOf(current);
-        if (currentIndex == -1) return allElements.FirstOrDefault();
-
-        var nextIndex = (currentIndex + 1) % allElements.Count;
-        return allElements[nextIndex];
+        try
+        {
+            System.Diagnostics.Debug.WriteLine("=== Setting initial focus ===");
+            
+            if (LeftPanel.Children.Count > 0)
+            {
+                var firstButton = LeftPanel.Children[0] as Button;
+                if (firstButton != null)
+                {
+                    var focused = firstButton.Focus();
+                    System.Diagnostics.Debug.WriteLine($"First button focus result: {focused}");
+                    
+                    if (focused)
+                    {
+                        _panelManager.SetSelection(0, true);
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error setting initial focus: {ex.Message}");
+        }
     }
 
-    // Предыдущий элемент (для Up/Shift+Tab)
-    private View GetPreviousFocusable(View current, List<View> allElements)
+    private void OpenSelectedItem()
     {
-        if (current == null) return allElements.LastOrDefault();
-
-        var currentIndex = allElements.IndexOf(current);
-        if (currentIndex == -1) return allElements.LastOrDefault();
-
-        var prevIndex = (currentIndex - 1 + allElements.Count) % allElements.Count;
-        return allElements[prevIndex];
+        var item = _panelManager.SelectedItem;
+            
+        if (item != null)
+        {
+            System.Diagnostics.Debug.WriteLine($"Opening: {item.Name} (IsDirectory: {item.IsDirectory})");
+            
+            if (item.IsDirectory)
+            {
+                LoadDirectory(item.FullName, _panelManager.IsLeftPanelActive);
+            }
+            else
+            {
+                _ = _fileOperations.OpenFileAsync(item.FullName);
+            }
+        }
+        else
+        {
+            System.Diagnostics.Debug.WriteLine("No item selected");
+        }
     }
 
-    private List<View> GetFocusableElements(bool isLeft)
+    private void UpdateVisualState()
     {
-        List<View>? elements = null;
-        if (isLeft)
+        // Визуальное выделение активной панели
+        if (_panelManager.IsLeftPanelActive)
         {
-            elements = LeftPanel.GetVisualTreeDescendants().OfType<View>()
-            .Where(x => x.IsEnabled && x.IsVisible && x is Button)
-            .OrderBy(GetVisualTreeOrder) // Сортируем по порядку в визуальном дереве
-            .ToList();
+            LeftPanelIndicator.BackgroundColor = ActiveIndicatorColor;
+            RightPanelIndicator.BackgroundColor = InactiveIndicatorColor;
         }
         else
         {
-            elements = RightPanel.GetVisualTreeDescendants().OfType<View>()
-            .Where(x => x.IsEnabled && x.IsVisible && x is Button)
-            .OrderBy(GetVisualTreeOrder) // Сортируем по порядку в визуальном дереве
-            .ToList();
+            LeftPanelIndicator.BackgroundColor = InactiveIndicatorColor;
+            RightPanelIndicator.BackgroundColor = ActiveIndicatorColor;
         }
 
-        //foreach (var el in elements)
-        //{
-        //    System.Diagnostics.Debug.WriteLine($"!!! {el.ToString()}");
-        //}
-
-        return elements;
+        UpdateButtonSelection();
     }
 
-    private int GetVisualTreeOrder(View view)
+    private void UpdateButtonSelection()
     {
-        // Простой способ - используем порядок в визуальном дереве
-        var parent = view.Parent as Layout;
-        if (parent != null)
+        // Сбрасываем выделение всех кнопок
+        foreach (var child in LeftPanel.Children)
+        {
+            if (child is Button button)
+            {
+                button.BackgroundColor = NormalButtonColor;
+            }
+        }
+        
+        foreach (var child in RightPanel.Children)
+        {
+            if (child is Button button)
+            {
+                button.BackgroundColor = NormalButtonColor;
+            }
+        }
+
+        // Выделяем активную кнопку
+        if (_panelManager.IsLeftPanelActive && _panelManager.LeftSelectedIndex >= 0 && _panelManager.LeftSelectedIndex < LeftPanel.Children.Count)
+        {
+            if (LeftPanel.Children[_panelManager.LeftSelectedIndex] is Button leftButton)
+            {
+                leftButton.BackgroundColor = FocusedButtonColor;
+            }
+        }
+        else if (!_panelManager.IsLeftPanelActive && _panelManager.RightSelectedIndex >= 0 && _panelManager.RightSelectedIndex < RightPanel.Children.Count)
         {
-            var index = parent.Children.IndexOf(view);
-            return index >= 0 ? index : 0;
+            if (RightPanel.Children[_panelManager.RightSelectedIndex] is Button rightButton)
+            {
+                rightButton.BackgroundColor = FocusedButtonColor;
+            }
         }
-        return 0;
     }
 
-    // Обработчики выделения (вызываются при изменении Selection в CollectionView)
-    private void OnLeftSelectionChanged(object sender, SelectionChangedEventArgs e)
+    private void LoadDirectory(string path, bool isLeft)
     {
-        if (e.CurrentSelection.FirstOrDefault() is FileSystemItem selectedItem)
+        try
         {
-            _leftSelectedIndex = LeftItems.IndexOf(selectedItem);
-            _isLeftPanelActive = true;
+            var items = _fileService.GetDirectoryContents(path).ToList();
+            var panel = isLeft ? LeftPanel : RightPanel;
+            var collection = isLeft ? _panelManager.LeftItems : _panelManager.RightItems;
 
-            // System.Diagnostics.Debug.WriteLine($"L !!! {_leftSelectedIndex} {_lastLeftSelectedIndex}");
-            if (_lastLeftSelectedIndex < LeftItems.Count && _lastLeftSelectedIndex >= 0)
+            panel.Children.Clear();
+            collection.Clear();
+
+            foreach (var item in items)
             {
-                // Автоматически переключаем фокус при достижении границ
-                if (_leftSelectedIndex > _lastLeftSelectedIndex)
-                {
-                    // Достигли конца списка - переходим к следующему элементу
-                    MoveFocus(moveForward: true, isLeft: true);
-                }
-                else if (_leftSelectedIndex < _lastLeftSelectedIndex)
-                {
-                    // Достигли начала списка - переходим к предыдущему элементу
-                    MoveFocus(moveForward: false, isLeft: true);
-                }
+                collection.Add(item);
+                AddItemToPanel(item, panel, isLeft);
+            }
+
+            if (isLeft)
+            {
+                LeftPath = path;
+                _panelManager.SetSelection(items.Count > 0 ? 0 : -1, true);
+            }
+            else
+            {
+                RightPath = path;
+                _panelManager.SetSelection(items.Count > 0 ? 0 : -1, false);
             }
 
-            UpdateVisualSelection();
+            System.Diagnostics.Debug.WriteLine($"Loaded {items.Count} items to {(isLeft ? "LEFT" : "RIGHT")} panel");
+            UpdateVisualState();
+
+            // Устанавливаем фокус на первый элемент
+            if (items.Count > 0)
+            {
+                Dispatcher.Dispatch(() =>
+                {
+                    var firstButton = panel.Children[0] as Button;
+                    firstButton?.Focus();
+                });
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error loading directory: {ex.Message}");
+            DisplayAlert("Error", $"Cannot load directory: {ex.Message}", "OK");
         }
     }
 
-    private void OnRightSelectionChanged(object sender, SelectionChangedEventArgs e)
+    private void AddItemToPanel(FileSystemItem item, VerticalStackLayout panel, bool isLeft)
     {
-        if (e.CurrentSelection.FirstOrDefault() is FileSystemItem selectedItem)
+        var button = new Button
         {
-            _rightSelectedIndex = RightItems.IndexOf(selectedItem);
-            _isLeftPanelActive = false;
-
-            // System.Diagnostics.Debug.WriteLine($"R !!! {_rightSelectedIndex} {_lastRightSelectedIndex}");
-            if (_lastRightSelectedIndex < RightItems.Count && _lastRightSelectedIndex >= 0)
+            Text = item.DisplayText,
+            Padding = new Thickness(15, 8),
+            HeightRequest = 40,
+            BackgroundColor = NormalButtonColor,
+            HorizontalOptions = LayoutOptions.FillAndExpand,
+            TextColor = Colors.Black,
+            FontSize = 14,
+            BorderColor = Colors.Transparent,
+            CornerRadius = 0
+        };
+
+        // Обработчик клика - выделение при клике, открытие при двойном клике
+        button.Clicked += (s, e) => HandleItemClick(button, item, isLeft);
+
+        // Обработчик фокуса
+        button.Focused += (s, e) => 
+        {
+            var index = panel.Children.IndexOf(button);
+            if (index >= 0)
             {
-                // Автоматически переключаем фокус при достижении границ
-                if (_rightSelectedIndex > _lastRightSelectedIndex)
-                {
-                    // Достигли конца списка - переходим к следующему элементу
-                    MoveFocus(moveForward: true, isLeft: false);
-                }
-                else if (_rightSelectedIndex < _lastRightSelectedIndex)
-                {
-                    // Достигли начала списка - переходим к предыдущему элементу
-                    MoveFocus(moveForward: false, isLeft: false);
-                }
+                _panelManager.SetSelection(index, isLeft);
             }
+        };
 
-           UpdateVisualSelection();
-        }
+        panel.Children.Add(button);
     }
 
-    private void UpdateVisualSelection()
+    private void HandleItemClick(Button button, FileSystemItem item, bool isLeft)
     {
-        //Сбрасываем предыдущий фокус
-        if (_currentFocusedButton != null)
-        {
-            VisualStateManager.GoToState(_currentFocusedButton, "Normal");
-            _currentFocusedButton = null;
-        }
+        var currentTime = DateTime.Now;
+        var isDoubleClick = (currentTime - _lastClickTime).TotalMilliseconds < 500 
+                          && _lastClickedButton == button;
 
-        if (_isLeftPanelActive && _leftSelectedIndex >= 0 && _leftSelectedIndex < LeftItems.Count)
+        _lastClickTime = currentTime;
+        _lastClickedButton = button;
+
+        System.Diagnostics.Debug.WriteLine($"=== CLICK: {item.Name} in {(isLeft ? "LEFT" : "RIGHT")} panel, Double: {isDoubleClick} ===");
+
+        // ВСЕГДА выделяем элемент при клике
+        var panel = isLeft ? LeftPanel : RightPanel;
+        var index = panel.Children.IndexOf(button);
+        
+        if (index >= 0)
         {
-            var item = LeftItems[_leftSelectedIndex];
-            SetFocusToItem(LeftPanel, item);
-            _selectedLeftItem = item;
-            _selectedRightItem = null;
+            _panelManager.SetSelection(index, isLeft);
+            
+            // Устанавливаем фокус на кнопку
+            button.Focus();
         }
-        else if (!_isLeftPanelActive && _rightSelectedIndex >= 0 && _rightSelectedIndex < RightItems.Count)
+
+        // Если это двойной клик - открываем/запускаем
+        if (isDoubleClick)
         {
-            var item = RightItems[_rightSelectedIndex];
-            SetFocusToItem(RightPanel, item);
-            _selectedRightItem = item;
-            _selectedLeftItem = null;
+            if (item.IsDirectory)
+            {
+                LoadDirectory(item.FullName, isLeft);
+            }
+            else
+            {
+                _ = _fileOperations.OpenFileAsync(item.FullName);
+            }
         }
     }
 
-    private void SetFocusToItem(CollectionView collectionView, FileSystemItem item)
+    // Команды тулбара
+    private async void OnCopyClicked(object sender, EventArgs e)
     {
-        // Используем Dispatcher чтобы дождаться рендеринга
-        Dispatcher.Dispatch(() =>
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F5 Copy ===");
+        
+        var sourceItem = _panelManager.SelectedItem;
+        var targetPath = _panelManager.IsLeftPanelActive ? RightPath : LeftPath;
+        
+        if (sourceItem != null)
         {
-            var container = FindButtonContainer(collectionView, item);
-            if (container is Button button)
+            try
             {
-                VisualStateManager.GoToState(button, "Focused");
-                _currentFocusedButton = button;
-                _lastClickedItem = item;
-
-                // Простой способ - используем текущие индексы
-                if (_isLeftPanelActive)
+                var targetFullPath = _pathHelper.CombinePaths(targetPath, sourceItem.Name);
+                
+                bool success;
+                if (sourceItem.IsDirectory)
                 {
-                    _lastLeftSelectedIndex = _leftSelectedIndex;
+                    success = await _fileOperations.CopyDirectoryAsync(sourceItem.FullName, targetFullPath);
+                    if (success)
+                        await DisplayAlert("Success", $"Directory '{sourceItem.Name}' copied successfully", "OK");
                 }
                 else
                 {
-                    _lastRightSelectedIndex = _rightSelectedIndex;
+                    success = await _fileOperations.CopyAsync(sourceItem.FullName, targetFullPath);
+                    if (success)
+                        await DisplayAlert("Success", $"File '{sourceItem.Name}' copied successfully", "OK");
+                }
+                
+                if (success)
+                {
+                    // Обновляем целевую панель
+                    LoadDirectory(targetPath, !_panelManager.IsLeftPanelActive);
+                }
+                else
+                {
+                    await DisplayAlert("Error", "Copy operation failed", "OK");
                 }
-
-                // Прокручиваем к выбранному элементу
-                collectionView.ScrollTo(item, position: ScrollToPosition.MakeVisible, animate: false);
             }
-        });
-    }
-
-    private Button? FindButtonContainer(CollectionView collectionView, FileSystemItem item)
-    {
-        // Ищем кнопку в логических дочерних элементах
-        foreach (var child in collectionView.LogicalChildren)
-        {
-            if (child is Button button && button.BindingContext == item)
+            catch (Exception ex)
             {
-                return button;
+                await DisplayAlert("Error", $"Copy failed: {ex.Message}", "OK");
             }
         }
-        return null;
-    }
-
-    public void OnLeftItemDoubleTapped(FileSystemItem item)
-    {
-        if (item.IsDirectory)
-        {
-            LoadDirectory(item.FullName, true);
-        }
-    }
-
-    public void OnRightItemDoubleTapped(FileSystemItem item)
-    {
-        if (item.IsDirectory)
+        else
         {
-            LoadDirectory(item.FullName, false);
+            await DisplayAlert("Info", "Please select an item to copy", "OK");
         }
     }
 
-    // Остальные методы без изменений
-    private async void OnCopyClicked(object sender, EventArgs e)
-    {
-        await ProcessFileOperation(async (src, destDir) =>
-        {
-            if (Directory.Exists(src))
-                await CopyDirectory(src, Path.Combine(destDir, Path.GetFileName(src)));
-            else
-                File.Copy(src, Path.Combine(destDir, Path.GetFileName(src)), overwrite: true);
-        }, "Copy");
-    }
-
     private async void OnMoveClicked(object sender, EventArgs e)
     {
-        await ProcessFileOperation((src, destDir) =>
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F6 Move ===");
+        
+        var sourceItem = _panelManager.SelectedItem;
+        var targetPath = _panelManager.IsLeftPanelActive ? RightPath : LeftPath;
+        
+        if (sourceItem != null)
         {
-            var dest = Path.Combine(destDir, Path.GetFileName(src));
-            if (Directory.Exists(src))
-                Directory.Move(src, dest);
-            else
-                File.Move(src, dest, overwrite: true);
-            return Task.CompletedTask;
-        }, "Move");
-    }
-
-    private async void OnDeleteClicked(object sender, EventArgs e)
-    {
-        var item = _selectedLeftItem ?? _selectedRightItem;
-        if (item == null) return;
-
-        var confirm = await DisplayAlert("Delete", $"Delete '{item.Name}'?", "Yes", "No");
-        if (confirm)
+            try
+            {
+                var targetFullPath = _pathHelper.CombinePaths(targetPath, sourceItem.Name);
+                
+                bool success;
+                if (sourceItem.IsDirectory)
+                {
+                    success = await _fileOperations.CopyDirectoryAsync(sourceItem.FullName, targetFullPath);
+                    if (success)
+                        success = await _fileOperations.DeleteAsync(sourceItem.FullName);
+                }
+                else
+                {
+                    success = await _fileOperations.MoveAsync(sourceItem.FullName, targetFullPath);
+                }
+                
+                if (success)
+                {
+                    await DisplayAlert("Success", $"Item '{sourceItem.Name}' moved successfully", "OK");
+                    
+                    // Обновляем обе панели
+                    LoadDirectory(_panelManager.IsLeftPanelActive ? LeftPath : RightPath, _panelManager.IsLeftPanelActive);
+                    LoadDirectory(targetPath, !_panelManager.IsLeftPanelActive);
+                }
+                else
+                {
+                    await DisplayAlert("Error", "Move operation failed", "OK");
+                }
+            }
+            catch (Exception ex)
+            {
+                await DisplayAlert("Error", $"Move failed: {ex.Message}", "OK");
+            }
+        }
+        else
         {
-            if (item.IsDirectory)
-                Directory.Delete(item.FullName, recursive: true);
-            else
-                File.Delete(item.FullName);
-
-            LoadDirectory(_currentLeftPath, true);
-            LoadDirectory(_currentRightPath, false);
+            await DisplayAlert("Info", "Please select an item to move", "OK");
         }
     }
 
     private async void OnMkdirClicked(object sender, EventArgs e)
     {
-        var result = await DisplayPromptAsync("New Folder", "Folder name:", "Create", "Cancel");
-        if (string.IsNullOrWhiteSpace(result)) return;
-
-        string targetPath = (_selectedLeftItem != null || LeftItems.Count > 0) ? _currentLeftPath : _currentRightPath;
-        string newPath = Path.Combine(targetPath, result.Trim());
-
-        if (!Directory.Exists(newPath))
-        {
-            Directory.CreateDirectory(newPath);
-            LoadDirectory(_currentLeftPath, true);
-            LoadDirectory(_currentRightPath, false);
-        }
-        else
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F7 Mkdir ===");
+        
+        var currentPath = _panelManager.IsLeftPanelActive ? LeftPath : RightPath;
+        
+        // Запрашиваем имя новой папки
+        var folderName = await DisplayPromptAsync("Create Folder", "Enter folder name:", "Create", "Cancel", "New Folder");
+        
+        if (!string.IsNullOrWhiteSpace(folderName))
         {
-            await DisplayAlert("Error", "Folder already exists.", "OK");
+            try
+            {
+                var newFolderPath = _pathHelper.CombinePaths(currentPath, folderName);
+                var success = await _fileOperations.CreateDirectoryAsync(newFolderPath);
+                
+                if (success)
+                {
+                    await DisplayAlert("Success", $"Folder '{folderName}' created successfully", "OK");
+                    
+                    // Обновляем текущую панель
+                    LoadDirectory(currentPath, _panelManager.IsLeftPanelActive);
+                }
+                else
+                {
+                    await DisplayAlert("Error", "Failed to create folder", "OK");
+                }
+            }
+            catch (Exception ex)
+            {
+                await DisplayAlert("Error", $"Cannot create folder: {ex.Message}", "OK");
+            }
         }
     }
 
-    private void OnExitClicked(object sender, EventArgs e)
-    {
-        Application.Current?.Quit();
-    }
-
-    private async Task CopyDirectory(string sourceDir, string targetDir)
+    private async void OnDeleteClicked(object sender, EventArgs e)
     {
-        Directory.CreateDirectory(targetDir);
-
-        foreach (var file in Directory.GetFiles(sourceDir))
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F8 Delete ===");
+        
+        var item = _panelManager.SelectedItem;
+        
+        if (item != null)
         {
-            await Task.Run(() => File.Copy(file, Path.Combine(targetDir, Path.GetFileName(file)), overwrite: true));
+            // Подтверждение удаления
+            var result = await DisplayAlert("Confirm Delete", 
+                $"Are you sure you want to delete '{item.Name}'?", 
+                "Delete", "Cancel");
+            
+            if (result)
+            {
+                try
+                {
+                    var success = await _fileOperations.DeleteAsync(item.FullName);
+                    
+                    if (success)
+                    {
+                        await DisplayAlert("Success", $"Item '{item.Name}' deleted successfully", "OK");
+                        
+                        // Обновляем текущую панель
+                        LoadDirectory(_panelManager.IsLeftPanelActive ? LeftPath : RightPath, _panelManager.IsLeftPanelActive);
+                    }
+                    else
+                    {
+                        await DisplayAlert("Error", "Delete operation failed", "OK");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await DisplayAlert("Error", $"Delete failed: {ex.Message}", "OK");
+                }
+            }
         }
-
-        foreach (var dir in Directory.GetDirectories(sourceDir))
+        else
         {
-            await CopyDirectory(dir, Path.Combine(targetDir, Path.GetFileName(dir)));
+            await DisplayAlert("Info", "Please select an item to delete", "OK");
         }
     }
 
-    private async Task ProcessFileOperation(Func<string, string, Task> operation, string actionName)
+    private void OnHomeClicked(object sender, EventArgs e)
     {
-        var srcItem = _selectedLeftItem ?? _selectedRightItem;
-        if (srcItem == null)
-        {
-            await DisplayAlert("Error", "Select a file or folder first.", "OK");
-            return;
-        }
-
-        string destDir = (srcItem == _selectedLeftItem) ? _currentRightPath : _currentLeftPath;
-
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: Home ===");
+        
         try
         {
-            await operation(srcItem.FullName, destDir);
-            LoadDirectory(_currentLeftPath, true);
-            LoadDirectory(_currentRightPath, false);
+            // Получаем домашнюю директорию пользователя
+            var homePath = _pathHelper.GetUserHomePath();
+            
+            // Переходим в домашнюю директорию на активной панели
+            LoadDirectory(homePath, _panelManager.IsLeftPanelActive);
+            
+            System.Diagnostics.Debug.WriteLine($"Navigated to home directory: {homePath}");
         }
         catch (Exception ex)
         {
-            await DisplayAlert("Error", $"{actionName} failed: {ex.Message}", "OK");
+            DisplayAlert("Error", $"Cannot navigate to home directory: {ex.Message}", "OK");
         }
     }
 
-    public new event PropertyChangedEventHandler? PropertyChanged;
+    private void OnExitClicked(object sender, EventArgs e) => Application.Current?.Quit();
 
-    protected virtual void NotifyPropertyChanged([CallerMemberName] string? propertyName = null)
+    // INotifyPropertyChanged
+    public event PropertyChangedEventHandler? PropertyChanged;
+    protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
     {
+        if (EqualityComparer<T>.Default.Equals(field, value)) return;
+        field = value;
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 }

MauiProgram.cs

@@ -16,7 +16,7 @@ namespace CommanderApp
                 });
 
 #if DEBUG
-    		builder.Logging.AddDebug();
+            builder.Logging.AddDebug();
 #endif
             builder.Services.AddSingleton<IFileSystemService, FileSystemService>();
             return builder.Build();

MockFileOperations.cs

@@ -0,0 +1,46 @@
+namespace CommanderApp.Services;
+
+public class MockFileOperations : IFileOperations
+{
+    public List<string> CopiedFiles { get; } = new();
+    public List<string> MovedFiles { get; } = new();
+    public List<string> DeletedItems { get; } = new();
+    public List<string> CreatedDirectories { get; } = new();
+    public List<string> OpenedFiles { get; } = new();
+
+    public Task<bool> CopyAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        CopiedFiles.Add($"{sourcePath} -> {targetPath}");
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> MoveAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        MovedFiles.Add($"{sourcePath} -> {targetPath}");
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> DeleteAsync(string path)
+    {
+        DeletedItems.Add(path);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> CreateDirectoryAsync(string path)
+    {
+        CreatedDirectories.Add(path);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> OpenFileAsync(string filePath)
+    {
+        OpenedFiles.Add(filePath);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> CopyDirectoryAsync(string sourceDir, string targetDir)
+    {
+        CopiedFiles.Add($"DIR: {sourceDir} -> {targetDir}");
+        return Task.FromResult(true);
+    }
+}

MockFileSystemItem.cs

@@ -0,0 +1,34 @@
+namespace CommanderApp;
+
+public static class MockFileSystemItem
+{
+    public static FileSystemItem CreateDirectory(string name, string path)
+    {
+        return new FileSystemItem
+        {
+            Name = name,
+            FullName = path,
+            IsDirectory = true
+        };
+    }
+
+    public static FileSystemItem CreateFile(string name, string path)
+    {
+        return new FileSystemItem
+        {
+            Name = name,
+            FullName = path,
+            IsDirectory = false
+        };
+    }
+
+    public static FileSystemItem CreateParentDirectory(string path)
+    {
+        return new FileSystemItem
+        {
+            Name = "..",
+            FullName = path,
+            IsDirectory = true
+        };
+    }
+}

MockFileSystemService.cs

@@ -0,0 +1,81 @@
+namespace CommanderApp;
+
+public class MockFileSystemService : IFileSystemService
+{
+    public string MockRootPath { get; set; } = "/mock/root";
+    
+    private readonly Dictionary<string, List<FileSystemItem>> _mockDirectories = new();
+
+    public MockFileSystemService()
+    {
+        // Инициализируем mock данными
+        SetupMockData();
+    }
+
+    private void SetupMockData()
+    {
+        _mockDirectories["/mock/root"] = new List<FileSystemItem>
+        {
+            new FileSystemItem { Name = "Documents", FullName = "/mock/root/Documents", IsDirectory = true },
+            new FileSystemItem { Name = "Pictures", FullName = "/mock/root/Pictures", IsDirectory = true },
+            new FileSystemItem { Name = "readme.txt", FullName = "/mock/root/readme.txt", IsDirectory = false },
+            new FileSystemItem { Name = "..", FullName = "/mock", IsDirectory = true }
+        };
+
+        _mockDirectories["/mock/root/Documents"] = new List<FileSystemItem>
+        {
+            new FileSystemItem { Name = "Project1", FullName = "/mock/root/Documents/Project1", IsDirectory = true },
+            new FileSystemItem { Name = "Project2", FullName = "/mock/root/Documents/Project2", IsDirectory = true },
+            new FileSystemItem { Name = "notes.txt", FullName = "/mock/root/Documents/notes.txt", IsDirectory = false },
+            new FileSystemItem { Name = "..", FullName = "/mock/root", IsDirectory = true }
+        };
+
+        _mockDirectories["/mock/root/Pictures"] = new List<FileSystemItem>
+        {
+            new FileSystemItem { Name = "vacation.jpg", FullName = "/mock/root/Pictures/vacation.jpg", IsDirectory = false },
+            new FileSystemItem { Name = "..", FullName = "/mock/root", IsDirectory = true }
+        };
+    }
+
+    public string GetRootPath()
+    {
+        return MockRootPath;
+    }
+
+    public IEnumerable<FileSystemItem> GetDirectoryContents(string path)
+    {
+        if (_mockDirectories.ContainsKey(path))
+        {
+            return _mockDirectories[path];
+        }
+
+        // Если директории нет в mock данных, возвращаем пустой список с ".."
+        var parent = GetParentPath(path);
+        if (parent != null)
+        {
+            return new List<FileSystemItem>
+            {
+                new FileSystemItem { Name = "..", FullName = parent, IsDirectory = true }
+            };
+        }
+
+        return Enumerable.Empty<FileSystemItem>();
+    }
+
+    // Метод для добавления mock данных в тестах
+    public void AddMockDirectory(string path, List<FileSystemItem> items)
+    {
+        _mockDirectories[path] = items;
+    }
+
+    private string GetParentPath(string path)
+    {
+        var separator = '/';
+        var lastSeparator = path.LastIndexOf(separator);
+        if (lastSeparator > 0)
+        {
+            return path.Substring(0, lastSeparator);
+        }
+        return null;
+    }
+}

MockKeyboardService.cs

@@ -0,0 +1,17 @@
+namespace CommanderApp.Services;
+
+public class MockKeyboardService : IKeyboardService
+{
+    public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+    public void SetupKeyboardHandling(ContentPage page)
+    {
+        // Mock implementation - does nothing
+    }
+
+    // Method to simulate key presses in tests
+    public void SimulateKeyPress(string key)
+    {
+        KeyPressed?.Invoke(this, new KeyPressedEventArgs { Key = key, Platform = "Test" });
+    }
+}

MockPanelManager.cs

@@ -0,0 +1,50 @@
+using System.Collections.ObjectModel;
+
+namespace CommanderApp.Services;
+
+public class MockPanelManager : IPanelManager
+{
+    public event EventHandler<PanelStateChangedEventArgs> StateChanged;
+
+    public bool IsLeftPanelActive { get; set; } = true;
+    public FileSystemItem SelectedItem { get; set; }
+    public string ActivePanelPath { get; set; } = "/mock/path";
+    public string LeftPanelPath { get; set; } = "/left/path";
+    public string RightPanelPath { get; set; } = "/right/path";
+    public int LeftSelectedIndex { get; set; } = 0;
+    public int RightSelectedIndex { get; set; } = -1;
+
+    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
+    public ObservableCollection<FileSystemItem> RightItems { get; } = new();
+
+    public void SwitchToLeftPanel() => IsLeftPanelActive = true;
+    public void SwitchToRightPanel() => IsLeftPanelActive = false;
+    
+    public void MoveSelection(int direction)
+    {
+        if (IsLeftPanelActive)
+            LeftSelectedIndex = Math.Max(0, LeftSelectedIndex + direction);
+        else
+            RightSelectedIndex = Math.Max(0, RightSelectedIndex + direction);
+    }
+
+    public void SetSelection(int index, bool isLeftPanel)
+    {
+        if (isLeftPanel)
+            LeftSelectedIndex = index;
+        else
+            RightSelectedIndex = index;
+    }
+
+    public void UpdatePanelPaths(string leftPath, string rightPath)
+    {
+        LeftPanelPath = leftPath;
+        RightPanelPath = rightPath;
+    }
+
+    public void ClearSelection()
+    {
+        LeftSelectedIndex = -1;
+        RightSelectedIndex = -1;
+    }
+}

MockPathHelper.cs

@@ -0,0 +1,13 @@
+namespace CommanderApp.Services;
+
+public class MockPathHelper : IPathHelper
+{
+    public string MockHomePath { get; set; } = "/mock/home";
+    public string MockRootPath { get; set; } = "/mock/root";
+
+    public string GetUserHomePath() => MockHomePath;
+    public string GetRootPath() => MockRootPath;
+    public string CombinePaths(params string[] paths) => string.Join("/", paths);
+    public string GetFileName(string path) => System.IO.Path.GetFileName(path);
+    public string GetDirectoryName(string path) => System.IO.Path.GetDirectoryName(path) ?? string.Empty;
+}

PanelCollectionView.cs

@@ -1,58 +0,0 @@
-using Microsoft.Maui.Controls;
-
-namespace CommanderApp;
-
-public static class PanelCollectionView
-{
-    public static DataTemplate CreateItemTemplate(bool isLeftPanel, MainPage page)
-    {
-        return new DataTemplate(() =>
-        {
-            var button = new Button
-            {
-                Padding = new Thickness(15, 8, 5, 8), // left, top, right, bottom
-                HeightRequest = 40,
-                BackgroundColor = Colors.Transparent,
-                BorderWidth = 0,
-                HorizontalOptions = LayoutOptions.Fill,
-            };
-
-            // Устанавливаем тематический цвет текста
-            button.SetAppThemeColor(Button.TextColorProperty, Colors.Black, Colors.White);
-            button.SetBinding(Button.TextProperty, new Binding("DisplayText"));
-            button.SetBinding(Button.CommandParameterProperty, new Binding("."));
-
-            // Обработчик нажатия
-            button.Clicked += (s, e) =>
-            {
-                if (s is Button btn && btn.CommandParameter is FileSystemItem item)
-                {
-                    page.HandleItemClick(item, isLeftPanel);
-                }
-            };
-
-            // Визуальные состояния для фокуса
-            var visualStateGroups = new VisualStateGroupList();
-            var commonStates = new VisualStateGroup { Name = "CommonStates" };
-
-            var normalState = new VisualState { Name = "Normal" };
-
-            var focusedState = new VisualState { Name = "Focused" };
-            focusedState.Setters.Add(new Setter { Property = Button.BorderColorProperty, Value = Colors.Blue });
-            focusedState.Setters.Add(new Setter { Property = Button.BorderWidthProperty, Value = 2 });
-
-            var pressedState = new VisualState { Name = "Pressed" };
-            pressedState.Setters.Add(new Setter { Property = Button.BackgroundColorProperty, Value = Color.FromArgb("#e0e0e0") });
-
-            commonStates.States.Add(normalState);
-            commonStates.States.Add(focusedState);
-            //commonStates.States.Add(pressedState);
-            visualStateGroups.Add(commonStates);
-
-            VisualStateManager.SetVisualStateGroups(button, visualStateGroups);
-
-            return button;
-        });
-    }
-
-}

PanelManager.cs

@@ -0,0 +1,119 @@
+using System.Collections.ObjectModel;
+
+namespace CommanderApp.Services;
+
+public class PanelManager : IPanelManager
+{
+    public event EventHandler<PanelStateChangedEventArgs> StateChanged;
+
+    private bool _isLeftPanelActive = true;
+    private int _leftSelectedIndex = -1;
+    private int _rightSelectedIndex = -1;
+    private string _leftPanelPath = string.Empty;
+    private string _rightPanelPath = string.Empty;
+
+    public bool IsLeftPanelActive => _isLeftPanelActive;
+    public FileSystemItem SelectedItem => GetSelectedItem();
+    public string ActivePanelPath => _isLeftPanelActive ? _leftPanelPath : _rightPanelPath;
+    public string LeftPanelPath => _leftPanelPath;
+    public string RightPanelPath => _rightPanelPath;
+    public int LeftSelectedIndex => _leftSelectedIndex;
+    public int RightSelectedIndex => _rightSelectedIndex;
+
+    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
+    public ObservableCollection<FileSystemItem> RightItems { get; } = new();
+
+    public void SwitchToLeftPanel()
+    {
+        if (!_isLeftPanelActive && LeftItems.Count > 0)
+        {
+            _isLeftPanelActive = true;
+            OnStateChanged();
+        }
+    }
+
+    public void SwitchToRightPanel()
+    {
+        if (_isLeftPanelActive && RightItems.Count > 0)
+        {
+            _isLeftPanelActive = false;
+            OnStateChanged();
+        }
+    }
+
+    public void MoveSelection(int direction)
+    {
+        if (_isLeftPanelActive)
+        {
+            if (LeftItems.Count == 0) return;
+            var newIndex = Math.Max(0, Math.Min(LeftItems.Count - 1, _leftSelectedIndex + direction));
+            if (newIndex != _leftSelectedIndex)
+            {
+                _leftSelectedIndex = newIndex;
+                OnStateChanged();
+            }
+        }
+        else
+        {
+            if (RightItems.Count == 0) return;
+            var newIndex = Math.Max(0, Math.Min(RightItems.Count - 1, _rightSelectedIndex + direction));
+            if (newIndex != _rightSelectedIndex)
+            {
+                _rightSelectedIndex = newIndex;
+                OnStateChanged();
+            }
+        }
+    }
+
+    public void SetSelection(int index, bool isLeftPanel)
+    {
+        if (isLeftPanel)
+        {
+            if (index >= 0 && index < LeftItems.Count)
+            {
+                _leftSelectedIndex = index;
+                _isLeftPanelActive = true;
+            }
+        }
+        else
+        {
+            if (index >= 0 && index < RightItems.Count)
+            {
+                _rightSelectedIndex = index;
+                _isLeftPanelActive = false;
+            }
+        }
+        OnStateChanged();
+    }
+
+    public void UpdatePanelPaths(string leftPath, string rightPath)
+    {
+        _leftPanelPath = leftPath;
+        _rightPanelPath = rightPath;
+    }
+
+    public void ClearSelection()
+    {
+        _leftSelectedIndex = -1;
+        _rightSelectedIndex = -1;
+        OnStateChanged();
+    }
+
+    private FileSystemItem GetSelectedItem()
+    {
+        return _isLeftPanelActive ? 
+            (_leftSelectedIndex >= 0 ? LeftItems[_leftSelectedIndex] : null) :
+            (_rightSelectedIndex >= 0 ? RightItems[_rightSelectedIndex] : null);
+    }
+
+    private void OnStateChanged()
+    {
+        StateChanged?.Invoke(this, new PanelStateChangedEventArgs
+        {
+            IsLeftPanelActive = _isLeftPanelActive,
+            LeftSelectedIndex = _leftSelectedIndex,
+            RightSelectedIndex = _rightSelectedIndex,
+            SelectedItem = GetSelectedItem()
+        });
+    }
+}

PathHelper.cs

@@ -0,0 +1,28 @@
+namespace CommanderApp.Services;
+
+public class PathHelper : IPathHelper
+{
+    public string GetUserHomePath()
+    {
+#if WINDOWS
+        return Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+#else
+        return Environment.GetFolderPath(Environment.SpecialFolder.Personal);
+#endif
+    }
+
+    public string GetRootPath()
+    {
+#if WINDOWS
+        return Path.GetPathRoot(Environment.SystemDirectory) ?? "C:\\";
+#else
+        return "/";
+#endif
+    }
+
+    public string CombinePaths(params string[] paths) => Path.Combine(paths);
+
+    public string GetFileName(string path) => Path.GetFileName(path);
+
+    public string GetDirectoryName(string path) => Path.GetDirectoryName(path) ?? string.Empty;
+}

README.md

@@ -1,3 +1,173 @@
-# commander
+## Файловый менеджер на .NET MAUI
 
-MAUI Commander
+**Разработчик:** Пилипенко Степан Андреевич (2025 год)
+
+---
+
+## Введение
+
+### Цель работы
+Разработка кроссплатформенного файлового менеджера с использованием современной технологии .NET MAUI, обеспечивающего эффективную работу с файловой системой на различных операционных системах.
+
+### Актуальность
+В современном мире с ростом мобильных устройств и разнообразием операционных систем возрастает потребность в кроссплатформенных решениях. Файловые менеджеры остаются одним из наиболее востребованных типов приложений, а возможность их работы на разных платформах из единой кодовой базы значительно сокращает затраты на разработку и поддержку.
+
+## Выбор технологий
+
+### .NET MAUI как основная платформа
+**Обоснование выбора:**
+
+1. **Единая кодовая база** - возможность разработки для Windows, macOS, Android и iOS из одного проекта
+2. **Производительность** - нативная компиляция и прямой доступ к API платформ
+3. **Современный UI** - поддержка последних стандартов пользовательского интерфейса
+4. **Экосистема .NET** - богатая библиотека компонентов и инструментов
+5. **Поддержка Microsoft** - долгосрочная поддержка и активное развитие платформы
+
+### Преимущества перед альтернативами
+- **По сравнению с Electron**: меньший расход памяти, лучшая производительность
+- **По сравнению с Flutter**: интеграция с экосистемой .NET, знакомый язык C#
+- **По сравнению с нативной разработкой**: сокращение времени разработки в 2-3 раза
+
+## Архитектура решения
+
+### Многослойная архитектура
+
+```
+┌─────────────────────────────────────────┐
+│             Presentation Layer          │
+│              (MainPage.xaml)            │
+└─────────────────────────────────────────┘
+┌─────────────────────────────────────────┐
+│              Business Logic             │
+│          (Сервисы, Менеджеры)           │
+└─────────────────────────────────────────┘
+┌─────────────────────────────────────────┐
+│              Data Access                │
+│        (FileSystemService, etc.)        │
+└─────────────────────────────────────────┘
+```
+
+### Ключевые компоненты
+
+#### 1. **Presentation Layer**
+- **MainPage.xaml** - основной пользовательский интерфейс
+- Две панели для навигации по файловой системе
+- Панель инструментов с основными операциями
+
+#### 2. **Business Logic Layer**
+
+##### PanelManager
+- Управление состоянием панелей
+- Навигация и выделение элементов
+- Координация между левой и правой панелями
+
+##### FileOperations
+- Копирование файлов и директорий
+- Перемещение элементов
+- Удаление и создание папок
+- Открытие файлов
+
+##### KeyboardService
+- Обработка клавиатурных сокращений
+- Кроссплатформенная поддержка горячих клавиш
+- Навигация с помощью WASD
+
+#### 3. **Data Access Layer**
+
+##### FileSystemService
+- Абстракция над файловой системой
+- Получение содержимого директорий
+- Кроссплатформенные пути
+
+##### PathHelper
+- Работа с путями файловой системы
+- Определение домашней директории
+- Кроссплатформенные операции с путями
+
+### Принципы проектирования
+
+#### 1. **Инверсия зависимостей (DIP)**
+```csharp
+public interface IPanelManager
+public interface IFileOperations
+public interface IKeyboardService
+```
+
+#### 2. **Принцип единственной ответственности (SRP)**
+Каждый сервис отвечает за конкретную функциональность
+
+#### 3. **Интерфейс-ориентированное программирование**
+Легкая замена реализаций и тестирование
+
+## Функциональные возможности
+
+### Основные операции
+1. **Навигация** - просмотр файловой системы через две панели
+2. **Копирование** (F5) - копирование файлов и папок между панелями
+3. **Перемещение** (F6) - перемещение элементов между панелями
+4. **Создание папок** (F7) - создание новых директорий
+5. **Удаление** (F8) - удаление файлов и папок
+6. **Быстрая навигация** - переход в домашнюю директорию
+
+### Управление с клавиатуры
+- **WASD** - навигация по файлам
+- **Space/Enter** - открытие файлов и папок
+- **F5-F8** - операции с файлами
+- **H** - переход в домашнюю директорию
+
+### Кроссплатформенность
+- Поддержка Windows и macOS
+- Единый код для разных платформ
+- Адаптация к особенностям файловых систем
+
+## Технические особенности
+
+### Обработка файловых операций
+```csharp
+public async Task<bool> CopyAsync(string sourcePath, string targetPath)
+public async Task<bool> MoveAsync(string sourcePath, string targetPath)
+public async Task<bool> DeleteAsync(string path)
+```
+
+### Навигационная система
+- Рекурсивный обход директорий
+- Поддержка специальных элементов (".." для навигации вверх)
+- Оптимизированная работа с большими директориями
+
+### Пользовательский интерфейс
+- Интуитивная двухпанельная layout
+- Визуальное выделение активных элементов
+- Статус-бар с текущими путями
+
+## Результаты разработки
+
+### Достигнутые цели
+1. ✅ Создан полнофункциональный файловый менеджер
+2. ✅ Обеспечена кроссплатформенность (Windows/macOS)
+3. ✅ Реализованы все основные файловые операции
+4. ✅ Обеспечена высокая производительность
+5. ✅ Создан удобный пользовательский интерфейс
+
+### Производительность
+- Быстрая загрузка директорий
+- Эффективная работа с большими файлами
+- Минимальное потребление памяти
+
+### Качество кода
+- Чистая архитектура с разделением ответственности
+- Полная покрытие интерфейсами для тестирования
+- Современные практики C# и .NET
+
+## Заключение
+
+Разработанный файловый менеджер демонстрирует эффективность использования .NET MAUI для создания кроссплатформенных приложений. Приложение успешно решает поставленные задачи и предоставляет пользователю удобный инструмент для работы с файловой системой на разных платформах.
+
+### Перспективы развития
+1. Добавление поддержки сетевых протоколов (FTP, SFTP)
+2. Реализация поиска по файловой системе
+3. Добавление предпросмотра файлов
+4. Поддержка плагинов и расширений
+5. Интеграция с облачными хранилищами
+
+### Выводы
+Использование .NET MAUI позволило создать производительное кроссплатформенное приложение с минимальными затратами на разработку. Архитектура на основе сервисов и интерфейсов обеспечивает легкую расширяемость и поддерживаемость кода, что делает решение перспективным для дальнейшего развития.