private void OnRightItemTapped(object sender, RightTappedRoutedEventArgs e)
{
IMegaNode itemTapped = ((FrameworkElement)e.OriginalSource)?.DataContext as IMegaNode;
if (itemTapped == null)
{
return;
}
this.ViewModel.ActiveFolderView.FocusedNode = itemTapped;
var view = (ListViewBase)sender;
if (view == null)
{
return;
}
if (this.ViewModel.ActiveFolderView.ItemCollection.IsMultiSelectActive)
{
view.SelectedItems.Add(itemTapped);
}
else
{
view.SelectedItem = itemTapped;
}
}
public TransferObjectModel(MegaSDK megaSdk, IMegaNode selectedNode, TransferType transferType,
string filePath, string downloadFolderPath = null) : base(megaSdk)
{
switch (transferType)
{
case TransferType.Download:
{
DisplayName = selectedNode.Name;
break;
}
case TransferType.Upload:
{
DisplayName = Path.GetFileName(filePath);
break;
}
}
Type = transferType;
FilePath = filePath;
DownloadFolderPath = downloadFolderPath;
Status = TransferStatus.NotStarted;
SelectedNode = selectedNode;
CancelButtonState = true;
TransferButtonIcon = new Uri("/Assets/Images/cancel transfers.Screen-WXGA.png", UriKind.Relative);
AutoLoadImageOnFinish = false;
CancelTransferCommand = new DelegateCommand(CancelTransfer);
SetThumbnail();
}
/// <summary>
/// Move the node from its current location to a new folder destination
/// </summary>
/// <param name="newParentNode">The root node of the destination folder</param>
/// <returns>Result of the action</returns>
public NodeActionResult Copy(IMegaNode newParentNode)
{
// User must be online to perform this operation
if (!IsUserOnline())
{
return(NodeActionResult.NotOnline);
}
this.MegaSdk.copyNode(this.OriginalMNode, newParentNode.OriginalMNode, new CopyNodeRequestListener());
return(NodeActionResult.IsBusy);
}
public void BrowseToFolder(IMegaNode node)
{
if (node == null)
{
return;
}
this.FolderRootNode = node;
LoadChildNodes();
}
private void Initialize(IMegaNode selectedNode, MTransferType transferType,
string transferPath, string externalDownloadPath = null)
{
this.TypeAndState = new object[2];
switch (transferType)
{
case MTransferType.TYPE_DOWNLOAD:
this.DisplayName = selectedNode.Name;
this.TotalBytes = selectedNode.Size;
break;
case MTransferType.TYPE_UPLOAD:
this.DisplayName = Path.GetFileName(transferPath);
if (FileService.FileExists(transferPath))
{
Task.Run(async() =>
{
try
{
var srcFile = await StorageFile.GetFileFromPathAsync(transferPath);
if (srcFile != null)
{
var fileProperties = await srcFile.GetBasicPropertiesAsync();
this.TotalBytes = fileProperties.Size;
}
}
catch (Exception e)
{
var message = (this.DisplayName == null) ? "Error getting transfer size" :
string.Format("Error getting transfer size. File: '{0}'", this.DisplayName);
LogService.Log(MLogLevel.LOG_LEVEL_WARNING, message, e);
}
});
}
break;
}
this.IsBusy = false;
this.Type = transferType;
this.TransferPath = transferPath;
this.ExternalDownloadPath = externalDownloadPath;
this.TransferState = MTransferState.STATE_NONE;
this.TransferedBytes = 0;
this.TransferSpeed = string.Empty;
this.SelectedNode = selectedNode;
this.AutoLoadImageOnFinish = false;
this.PauseOrResumeTransferCommand = new RelayCommand(PauseOrResumeTransfer);
this.CancelTransferCommand = new RelayCommand(CancelTransfer);
this.RetryTransferCommand = new RelayCommand(RetryTransfer);
this.RemoveTransferCommand = new RelayCommand(RemoveTransfer);
SetThumbnail();
}
private void CheckAndBrowseToFolder(BreadCrumb breadCrumb, IMegaNode folderNode)
{
if (breadCrumb.Equals(IncomingSharedBreadCrumb))
{
((SharedItemsViewModel)this.DataContext).InShares.BrowseToFolder(folderNode);
return;
}
if (breadCrumb.Equals(OutgoingSharedBreadCrumb))
{
((SharedItemsViewModel)this.DataContext).OutShares.BrowseToFolder(folderNode);
}
}
private void OnItemDoubleTapped(object sender, DoubleTappedRoutedEventArgs e)
{
this.CloudDriveSplitView.IsPaneOpen = false;
IMegaNode itemTapped = ((FrameworkElement)e.OriginalSource)?.DataContext as IMegaNode;
if (itemTapped == null)
{
return;
}
this.ViewModel.ActiveFolderView.OnChildNodeTapped(itemTapped);
}
private void Initialize(IMegaNode selectedNode, MTransferType transferType,
string transferPath, string externalDownloadPath = null)
{
this.TypeAndState = new object[2];
switch (transferType)
{
case MTransferType.TYPE_DOWNLOAD:
DisplayName = selectedNode.Name;
TotalBytes = selectedNode.Size;
break;
case MTransferType.TYPE_UPLOAD:
DisplayName = Path.GetFileName(transferPath);
if (FileService.FileExists(transferPath))
{
Task.Run(async() =>
{
try
{
var srcFile = await StorageFile.GetFileFromPathAsync(transferPath);
if (srcFile != null)
{
var fileProperties = await srcFile.GetBasicPropertiesAsync();
this.TotalBytes = fileProperties.Size;
}
}
catch (Exception e)
{
var message = (this.DisplayName == null) ? "Error getting transfer size" :
string.Format("Error getting transfer size. File: '{0}'", this.DisplayName);
LogService.Log(MLogLevel.LOG_LEVEL_WARNING, message, e);
}
});
}
break;
}
Type = transferType;
TransferPath = transferPath;
ExternalDownloadPath = externalDownloadPath;
TransferState = MTransferState.STATE_NONE;
TransferedBytes = 0;
TransferSpeed = string.Empty;
SelectedNode = selectedNode;
TransferButtonIcon = new Uri("/Assets/Images/cancel transfers.Screen-WXGA.png", UriKind.Relative);
AutoLoadImageOnFinish = false;
CancelTransferCommand = new DelegateCommand(CancelTransfer);
SetThumbnail();
}
/// <summary>
/// Check if a node is in the selected nodes group for move, copy or any other action.
/// </summary>
/// <param name="node">Node to check if is in the selected node list</param>
/// <returns>True if is a selected node or false in other case</returns>
private bool IsSelectedNode(IMegaNode node)
{
if ((SelectedNodes != null) && (SelectedNodes.Count > 0))
{
for (int index = 0; index < SelectedNodes.Count; index++)
{
var selectedNode = SelectedNodes[index];
if ((selectedNode != null) && (node.OriginalMNode.getBase64Handle() == selectedNode.OriginalMNode.getBase64Handle()))
{
//Update the selected nodes list values
node.DisplayMode = NodeDisplayMode.SelectedForCopyOrMove;
SelectedNodes[index] = node;
return(true);
}
}
}
return(false);
}
public static string GetFolderName(IMegaNode node)
{
var folderName = string.Empty;
switch (node.Type)
{
case MNodeType.TYPE_ROOT:
folderName = ResourceService.UiResources.GetString("UI_CloudDriveName");
break;
case MNodeType.TYPE_RUBBISH:
folderName = ResourceService.UiResources.GetString("UI_RubbishBinName");
break;
case MNodeType.TYPE_FOLDER:
folderName = node.Name;
break;
}
return(folderName);
}
private void OnItemTapped(object sender, TappedRoutedEventArgs e)
{
IMegaNode itemTapped = ((FrameworkElement)e.OriginalSource)?.DataContext as IMegaNode;
if (itemTapped == null)
{
return;
}
if (DeviceService.GetDeviceType() != DeviceFormFactorType.Desktop)
{
this.ViewModel.ActiveFolderView.OnChildNodeTapped(itemTapped);
return;
}
if ((itemTapped is ImageNodeViewModel) && (itemTapped as ImageNodeViewModel != null))
{
(itemTapped as ImageNodeViewModel).InViewingRange = true;
}
this.ViewModel.ActiveFolderView.FocusedNode = itemTapped;
}
public NodeActionResult Move(IMegaNode newParentNode)
{
// User must be online to perform this operation
if (!IsUserOnline())
{
return(NodeActionResult.NotOnline);
}
if (this.MegaSdk.checkMove(this.OriginalMNode, newParentNode.OriginalMNode).getErrorCode() != MErrorType.API_OK)
{
OnUiThread(() =>
{
new CustomMessageDialog(AppMessages.MoveFailed_Title, AppMessages.MoveFailed,
App.AppInformation, MessageDialogButtons.Ok).ShowDialog();
});
return(NodeActionResult.Failed);
}
this.MegaSdk.moveNode(this.OriginalMNode, newParentNode.OriginalMNode, new MoveNodeRequestListener());
return(NodeActionResult.IsBusy);
}
public void OnChildNodeTapped(IMegaNode node)
{
switch (node.Type)
{
case MNodeType.TYPE_UNKNOWN:
break;
case MNodeType.TYPE_FILE:
// If the user is moving nodes don't process the file node
if (CurrentDisplayMode != DriveDisplayMode.CopyOrMoveItem)
{
ProcessFileNode(node);
}
break;
case MNodeType.TYPE_FOLDER:
// If the user is moving nodes and the folder is one of the selected nodes don't navigate to it
if ((CurrentDisplayMode == DriveDisplayMode.CopyOrMoveItem) && (IsSelectedNode(node)))
{
return;
}
BrowseToFolder(node);
break;
case MNodeType.TYPE_ROOT:
break;
case MNodeType.TYPE_INCOMING:
break;
case MNodeType.TYPE_RUBBISH:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void ProcessFileNode(IMegaNode node)
{
this.FocusedNode = node;
var existingNode = SavedForOffline.ReadNodeByFingerprint(this.MegaSdk.getNodeFingerprint(node.OriginalMNode));
if (existingNode != null && !String.IsNullOrWhiteSpace(existingNode.LocalPath) &&
FileService.FileExists(existingNode.LocalPath))
{
var offlineNode = new OfflineFileNodeViewModel(new FileInfo(existingNode.LocalPath));
offlineNode.Open();
}
else
{
if (node.IsImage)
{
OnUiThread(() => NavigateService.NavigateTo(typeof(PreviewImagePage), NavigationParameter.Normal, this));
}
else
{
this.FocusedNode.Download(TransfersService.MegaTransfers);
}
}
}
private void CheckAndBrowseToFolder(BreadCrumb breadCrumb, IMegaNode folderNode)
{
((CameraUploadsPageViewModel)this.DataContext).CameraUploads.BrowseToFolder(folderNode);
}
public TransferObjectModel(MegaSDK megaSdk, IMegaNode selectedNode, MTransferType transferType,
string transferPath, string externalDownloadPath = null) : base(megaSdk)
{
Initialize(selectedNode, transferType, transferPath, externalDownloadPath);
}
private void GoToAction(IMegaNode bringIntoViewNode)
{
LstCloudDrive.BringIntoView(bringIntoViewNode);
}
private void CheckAndBrowseToFolder(BreadCrumb breadCrumb, IMegaNode folderNode)
{
((FolderLinkViewModel)this.DataContext).FolderLink.BrowseToFolder(folderNode);
}
public void onNodesUpdate(MegaSDK api, MNodeList nodes)
{
// exit methods when node list is incorrect
if (nodes == null || nodes.size() < 1)
{
return;
}
try
{
// Retrieve the listsize for performance reasons and store local
int listSize = nodes.size();
for (int i = 0; i < listSize; i++)
{
bool isProcessed = false;
// Get the specific node that has an update. If null exit the method
// and process no notification
MNode megaNode = nodes.get(i);
if (megaNode == null)
{
return;
}
// PROCESS THE FOLDERS LISTENERS
if (megaNode.isRemoved())
{
// REMOVED Scenario
foreach (var folder in Folders)
{
IMegaNode nodeToRemoveFromView = folder.ChildNodes.FirstOrDefault(
node => node.Base64Handle.Equals(megaNode.getBase64Handle()));
// If node is found in current view, process the remove action
if (nodeToRemoveFromView != null)
{
// Needed because we are in a foreach loop to prevent the use of the wrong
// local variable in the dispatcher code.
var currentFolder = folder;
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
currentFolder.ChildNodes.Remove(nodeToRemoveFromView);
((FolderNodeViewModel)currentFolder.FolderRootNode).SetFolderInfo();
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
isProcessed = true;
break;
}
}
if (!isProcessed)
{
// REMOVED in subfolder scenario
MNode parentNode = api.getParentNode(megaNode);
if (parentNode != null)
{
foreach (var folder in Folders)
{
IMegaNode nodeToUpdateInView = folder.ChildNodes.FirstOrDefault(
node => node.Base64Handle.Equals(parentNode.getBase64Handle()));
// If parent folder is found, process the update action
if (nodeToUpdateInView != null)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
nodeToUpdateInView.Update(parentNode, folder.Type);
var folderNode = nodeToUpdateInView as FolderNodeViewModel;
if (folderNode != null)
{
folderNode.SetFolderInfo();
}
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
}
}
}
}
}
// UPDATE / ADDED scenarions
else
{
// UPDATE Scenario
// PROCESS THE SINGLE NODE(S) LISTENER(S) (NodeDetailsPage live updates)
foreach (var node in Nodes)
{
if (megaNode.getBase64Handle() == node.getNodeBase64Handle())
{
Deployment.Current.Dispatcher.BeginInvoke(() => node.updateNode(megaNode));
}
}
// Used in different scenario's
MNode parentNode = api.getParentNode(megaNode);
foreach (var folder in Folders)
{
IMegaNode nodeToUpdateInView = folder.ChildNodes.FirstOrDefault(
node => node.Base64Handle.Equals(megaNode.getBase64Handle()));
// If node is found, process the update action
if (nodeToUpdateInView != null)
{
bool isMoved = !folder.FolderRootNode.Base64Handle.Equals(parentNode.getBase64Handle());
// Is node is move to different folder. Remove from current folder view
if (isMoved)
{
// Needed because we are in a foreach loop to prevent the use of the wrong
// local variable in the dispatcher code.
var currentFolder = folder;
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
currentFolder.ChildNodes.Remove(nodeToUpdateInView);
((FolderNodeViewModel)currentFolder.FolderRootNode).SetFolderInfo();
UpdateFolders(currentFolder);
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
}
// Node is updated with new data. Update node in current view
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
nodeToUpdateInView.Update(megaNode, folder.Type);
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
isProcessed = true;
break;
}
}
}
// ADDED scenario
if (parentNode != null && !isProcessed)
{
foreach (var folder in Folders)
{
bool isAddedInFolder = folder.FolderRootNode.Base64Handle.Equals(parentNode.getBase64Handle());
// If node is added in current folder, process the add action
if (isAddedInFolder)
{
// Retrieve the index from the SDK
// Substract -1 to get a valid list index
int insertIndex = api.getIndex(megaNode,
UiService.GetSortOrder(parentNode.getBase64Handle(),
parentNode.getName())) - 1;
// If the insert position is higher than the ChilNodes size insert in the last position
if (insertIndex >= folder.ChildNodes.Count())
{
// Needed because we are in a foreach loop to prevent the use of the wrong
// local variable in the dispatcher code.
var currentFolder = folder;
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
currentFolder.ChildNodes.Add(NodeService.CreateNew(api,
_appInformation, megaNode, currentFolder.Type));
((FolderNodeViewModel)currentFolder.FolderRootNode).SetFolderInfo();
UpdateFolders(currentFolder);
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
}
// Insert the node at a specific position
else
{
// Insert position can never be less then zero
// Replace negative index with first possible index zero
if (insertIndex < 0)
{
insertIndex = 0;
}
// Needed because we are in a foreach loop to prevent the use of the wrong
// local variable in the dispatcher code.
var currentFolder = folder;
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
currentFolder.ChildNodes.Insert(insertIndex,
NodeService.CreateNew(api, _appInformation, megaNode, currentFolder.Type));
((FolderNodeViewModel)currentFolder.FolderRootNode).SetFolderInfo();
UpdateFolders(currentFolder);
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
}
break;
}
// ADDED in subfolder scenario
IMegaNode nodeToUpdateInView = folder.ChildNodes.FirstOrDefault(
node => node.Base64Handle.Equals(parentNode.getBase64Handle()));
if (nodeToUpdateInView != null)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
nodeToUpdateInView.Update(parentNode, folder.Type);
var folderNode = nodeToUpdateInView as FolderNodeViewModel;
if (folderNode != null)
{
folderNode.SetFolderInfo();
}
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
break;
}
// Unconditional scenarios
// Move/delete/add actions in subfolders
var localFolder = folder;
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
try
{
UpdateFolders(localFolder);
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
});
}
}
}
}
}
catch (Exception)
{
// Dummy catch, surpress possible exception
}
}
public static MNodeList GetChildren(MegaSDK megaSdk, IMegaNode rootNode)
{
return(megaSdk.getChildren(rootNode.OriginalMNode, UiService.GetSortOrder(rootNode.Base64Handle, rootNode.Name)));
}
