protected virtual MvxBasePresentationAttribute CreateAttributeForViewModel(Type viewModelType)
{
var viewType = ViewsContainer.GetViewType(viewModelType);
if (viewType.IsSubclassOf(typeof(DialogFragment)))
{
MvxTrace.Trace("PresentationAttribute not found for {0}. Assuming DialogFragment presentation", viewModelType.Name);
return(new MvxDialogFragmentPresentationAttribute()
{
ViewType = viewType, ViewModelType = viewModelType
});
}
if (viewType.IsSubclassOf(typeof(Fragment)))
{
MvxTrace.Trace("PresentationAttribute not found for {0}. Assuming Fragment presentation", viewModelType.Name);
return(new MvxFragmentPresentationAttribute(GetCurrentActivityViewModelType(), Android.Resource.Id.Content)
{
ViewType = viewType, ViewModelType = viewModelType
});
}
MvxTrace.Trace("PresentationAttribute not found for {0}. Assuming Activity presentation", viewModelType.Name);
return(new MvxActivityPresentationAttribute()
{
ViewType = viewType, ViewModelType = viewModelType
});
}
private void OnStartup(object sender, StartupEventArgs e)
{
ViewsContainer container = new ViewsContainer();
ViewsContainer.mainView = new MainWindow();
ViewsContainer.mainView.Show();
}
public virtual MvxBasePresentationAttribute GetPresentationAttribute(MvxViewModelRequest request)
{
var viewType = ViewsContainer.GetViewType(request.ViewModelType);
var overrideAttribute = GetOverridePresentationAttribute(request, viewType);
if (overrideAttribute != null)
{
return(overrideAttribute);
}
var attribute = viewType
.GetCustomAttributes(typeof(MvxBasePresentationAttribute), true)
.FirstOrDefault() as MvxBasePresentationAttribute;
if (attribute != null)
{
if (attribute.ViewType == null)
{
attribute.ViewType = viewType;
}
if (attribute.ViewModelType == null)
{
attribute.ViewModelType = request.ViewModelType;
}
return(attribute);
}
return(CreatePresentationAttribute(request.ViewModelType, viewType));
}
protected virtual void ShowHostActivity(MvxFragmentPresentationAttribute attribute)
{
ValidateArguments(attribute);
if (attribute.ActivityHostViewModelType == null)
{
throw new ArgumentException("ActivityHostViewModelType not set on attribute");
}
var viewType = ViewsContainer?.GetViewType(attribute.ActivityHostViewModelType);
if (viewType?.IsSubclassOf(typeof(Activity)) != true)
{
throw new MvxException("The host activity doesn't inherit Activity");
}
var hostViewModelRequest = MvxViewModelRequest.GetDefaultRequest(attribute.ActivityHostViewModelType);
if (PendingRequest != null)
{
hostViewModelRequest.PresentationValues = PendingRequest.PresentationValues;
}
Show(hostViewModelRequest);
}
public ViewFactory(CanvasContainer canvasContainer, ViewsContainer viewsContainer,
ICameraManager cameraManager, ILoggerManager loggerManager)
{
_cameraManager = cameraManager;
_canvasContainer = canvasContainer;
_viewsContainer = viewsContainer;
_logger = loggerManager.GetLogger();
}
public void RemoveEnemy(EnemyView inEnemyView)
{
inEnemyView.RemoveAllComponents();
inEnemyView.Visibility = false;
SystemFacade.Level.Level.RemoveView(inEnemyView.name, inEnemyView.index);
ViewsContainer.RemoveView(inEnemyView);
Enemies.Remove(inEnemyView);
Object.Destroy(inEnemyView.gameObject);
}
protected virtual void ShowHostActivity(MvxFragmentPresentationAttribute attribute)
{
var viewType = ViewsContainer.GetViewType(attribute.ActivityHostViewModelType);
if (!viewType.IsSubclassOf(typeof(Activity)))
throw new MvxException("The host activity doesn't inherit Activity");
var hostViewModelRequest = MvxViewModelRequest.GetDefaultRequest(attribute.ActivityHostViewModelType);
hostViewModelRequest.PresentationValues = _pendingRequest.PresentationValues;
Show(hostViewModelRequest);
}
private void InitializeHelpers()
{
// --------------------------------------------------------------------------------
// Create and Initialize Helper classes
// --------------------------------------------------------------------------------
ViewsContainer = new ViewsContainer(this);
ObjectMap.Initialize(this);
SystemFacade.Initialize(this);
ViewFacade.Initialize(this);
}
public override async ValueTask<MvxBasePresentationAttribute?> GetPresentationAttribute(MvxViewModelRequest request)
{
var viewType = ViewsContainer.GetViewType(request.ViewModelType);
var overrideAttribute = await GetOverridePresentationAttribute(request, viewType).ConfigureAwait(false);
if (overrideAttribute != null)
return overrideAttribute;
IList<MvxBasePresentationAttribute> attributes = viewType.GetCustomAttributes<MvxBasePresentationAttribute>(true).ToList();
if (attributes?.Count > 0)
{
MvxBasePresentationAttribute? attribute = null;
if (attributes.Count > 1)
{
var fragmentAttributes = attributes.OfType<MvxFragmentPresentationAttribute>();
// check if fragment can be displayed as child fragment first
foreach (var item in fragmentAttributes.Where(att => att.FragmentHostViewType != null))
{
var fragment = GetFragmentByViewType(item.FragmentHostViewType);
// if the fragment exists, and is on top, then use the current attribute
if (fragment != null && fragment.IsVisible && fragment.View.FindViewById(item.FragmentContentId) != null)
{
attribute = item;
break;
}
}
// if attribute is still null, check if fragment can be displayed in current activity
if (attribute == null)
{
var currentActivityHostViewModelType = GetCurrentActivityViewModelType();
foreach (var item in fragmentAttributes.Where(att => att.ActivityHostViewModelType != null))
{
if (CurrentActivity.FindViewById(item.FragmentContentId) != null && item.ActivityHostViewModelType == currentActivityHostViewModelType)
{
attribute = item;
break;
}
}
}
}
if (attribute == null)
attribute = attributes.FirstOrDefault();
attribute.ViewType = viewType;
return attribute;
}
return await CreatePresentationAttribute(request.ViewModelType, viewType).ConfigureAwait(false);
}
public void RemovePlayer()
{
Player.OnTakeDamage -= OnPlayerTakeDamage;
Player.Destroyed -= OnPlayerDie;
SystemFacade.Level.Level.RemoveView(Player.name, Player.index);
ViewsContainer.RemoveView(Player);
Object.Destroy(Player.gameObject);
Player = null;
Log("Game is over !!");
}
public virtual MvxBasePresentationAttribute GetPresentationAttribute(MvxViewModelRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.ViewModelType == null)
{
throw new InvalidOperationException("Cannot get view types for null ViewModelType");
}
if (ViewsContainer == null)
{
throw new InvalidOperationException($"Cannot get view types from null {nameof(ViewsContainer)}");
}
var viewType = ViewsContainer.GetViewType(request.ViewModelType);
if (viewType == null)
{
throw new InvalidOperationException($"Could not get View Type for ViewModel Type {request.ViewModelType}");
}
var overrideAttribute = GetOverridePresentationAttribute(request, viewType);
if (overrideAttribute != null)
{
return(overrideAttribute);
}
var attribute = viewType
.GetCustomAttributes(typeof(MvxBasePresentationAttribute), true)
.FirstOrDefault();
if (attribute is MvxBasePresentationAttribute basePresentationAttribute)
{
if (basePresentationAttribute.ViewType == null)
{
basePresentationAttribute.ViewType = viewType;
}
if (basePresentationAttribute.ViewModelType == null)
{
basePresentationAttribute.ViewModelType = request.ViewModelType;
}
return(basePresentationAttribute);
}
return(CreatePresentationAttribute(request.ViewModelType, viewType));
}
protected override void ShowHostActivity(MvxFragmentPresentationAttribute attribute)
{
var viewType = ViewsContainer.GetViewType(attribute.ActivityHostViewModelType);
if (!viewType.IsSubclassOf(typeof(FragmentActivity)))
{
throw new MvxException("The host activity doesnt inherit FragmentActivity");
}
var hostViewModelRequest = MvxViewModelRequest.GetDefaultRequest(attribute.ActivityHostViewModelType);
Show(hostViewModelRequest);
}
public override void ChangePresentation(MvxPresentationHint hint)
{
var navigation = GetPageOfType <NavigationPage>().Navigation;
if (hint is MvxPopToRootPresentationHint popToRootHint)
{
navigation.PopToRootAsync(popToRootHint.Animated);
return;
}
if (hint is MvxPopPresentationHint popHint)
{
foreach (var page in navigation.NavigationStack)
{
page.Navigation.PopAsync(popHint.Animated);
if (page is IMvxPage mvxPage && mvxPage.ViewModel.GetType() == popHint.ViewModelToPopTo)
{
return;
}
}
return;
}
if (hint is MvxRemovePresentationHint removeHint)
{
var page = navigation.NavigationStack
.OfType <IMvxPage>()
.FirstOrDefault(view => view.ViewModel.GetType() == removeHint.ViewModelToRemove) as Page;
if (page != null)
{
navigation.RemovePage(page);
}
return;
}
if (hint is MvxPagePresentationHint pageHint)
{
var pageType = ViewsContainer.GetViewType(pageHint.ViewModel);
if (GetPageOfTypeByType(pageType) is Page page)
{
if (page.Parent is TabbedPage tabbedPage)
{
tabbedPage.CurrentPage = page;
}
else if (page.Parent is CarouselPage carouselPage && page is ContentPage contentPage)
{
carouselPage.CurrentPage = contentPage;
}
}
return;
}
base.ChangePresentation(hint);
}
public void ResolveWindow_RegisterCommandWIthCommandFactory_CommandsAreResolvedByFactory()
{
UnityContainer container = new UnityContainer();
var viewsContainer = new ViewsContainer(container);
viewsContainer.With<System.Windows.Window>()
.RegisterViewModel<DummyViewModel>()
.RegisterCommand<DummyViewModel>((vm) => vm.CommandA, (v, vm) => new CommandB())
.RegisterCommand<DummyViewModel>((vm) => vm.CommandB, (v, vm) => new CommandB());
var resolvedWindow = viewsContainer.ResolveWindow<System.Windows.Window>();
var dummyViewModel = (DummyViewModel)resolvedWindow.DataContext;
Assert.IsInstanceOfType(dummyViewModel.CommandA, typeof(CommandB));
Assert.IsInstanceOfType(dummyViewModel.CommandB, typeof(CommandB));
}
private static ConnectionResolverViewModel CreateViewModel()
{
var container = new UnityContainer();
var viewsContainer = new ViewsContainer(container);
MabadoViewBootLoader viewBootLoader = new MabadoViewBootLoader(container, viewsContainer);
viewBootLoader.RegisterConnectionResolverModule();
OverrideMockedDependencies(container);
ConnectionResolverView view = viewsContainer.ResolveWindow<ConnectionResolverView>();
var viewModel = view.DataContext as ConnectionResolverViewModel;
return viewModel;
}
public override MvxBasePresentationAttribute GetPresentationAttribute(MvxViewModelRequest request)
{
ValidateArguments(request);
var viewType = ViewsContainer?.GetViewType(request.ViewModelType);
if (viewType == null)
{
throw new InvalidOperationException($"Could not get view type for ViewModel Type: {request.ViewModelType}");
}
var overrideAttribute = GetOverridePresentationAttribute(request, viewType);
if (overrideAttribute != null)
{
return(overrideAttribute);
}
IList <MvxBasePresentationAttribute> attributes =
viewType.GetCustomAttributes <MvxBasePresentationAttribute>(true).ToList();
if (attributes.Count > 0)
{
MvxBasePresentationAttribute?attribute = null;
if (attributes.Count > 1)
{
var fragmentAttributes = attributes.OfType <MvxFragmentPresentationAttribute>().ToArray();
// check if fragment can be displayed as child fragment first
attribute = GetAttributeForFragmentChildPresentation(fragmentAttributes);
// if attribute is still null, check if fragment can be displayed in current activity
attribute ??= GetAttributeForFragmentPresentation(fragmentAttributes);
}
// fallback to first attribute
attribute ??= attributes[0];
attribute.ViewType = viewType;
return(attribute);
}
return(CreatePresentationAttribute(request.ViewModelType, viewType));
}
public PlayerView CreatePlayer()
{
// --------------------------------------------------------------------------------
// Setup Player
// --------------------------------------------------------------------------------
//here we can add the ability to select a specific player (if we have more than one)
Sprites = SystemFacade.Resources.LoadSpriteAtlas(ResourcesMap.Players);
var player = new PlayerView(this.application, "Player", LayerNames.Player, _config.profile);
player.SetSprite(Sprites[22]);
SystemFacade.Level.Level.AddView(player, _config.startPosition);
ViewsContainer.AddView(player);
// --------------------------------------------------------------------------------
// Setup Physics (Add Collider Component)
// --------------------------------------------------------------------------------
var boxSize = new Vector2(Sprites[22].bounds.size.x, Sprites[22].bounds.size.y);
player.AddComponent(new HitBox(player, boxSize, _config.profile.mass));
// --------------------------------------------------------------------------------
// Setup Animation (Add Animator Component)
// --------------------------------------------------------------------------------
player.profile.SetAnimationsSource(this.Sprites); //set sprite sheet source to all animations
player.AddComponent(new GameAnimator(player, player.SpriteRenderer));
// --------------------------------------------------------------------------------
// Setup Player Controller (Add Control View Component)
// --------------------------------------------------------------------------------
player.AddComponent(new ControlView(player, _config.profile));
// --------------------------------------------------------------------------------
// Add Parallax Effect to background
// --------------------------------------------------------------------------------
SystemFacade.Level.AddParallaxEffect(player);
// --------------------------------------------------------------------------------
// Setup Camera follow
// --------------------------------------------------------------------------------
SystemFacade.Camera.AddTargetToFollow(player.gameObject.transform);
return(player);
}
private bool TryShowPage(MvxViewModelRequest request)
{
var viewType = ViewsContainer.GetViewType(request.ViewModelType);
var page = FormsPagePresenter.CreatePage(viewType, request, null);
if (page == null)
{
return(false);
}
var mainPage = _formsApplication.MainPage as NavigationPage;
if (mainPage == null)
{
_formsApplication.MainPage = new NavigationPage(page);
mainPage = FormsApplication.MainPage as NavigationPage;
CustomPlatformInitialization(mainPage);
}
else
{
try
{
// check for modal presentation parameter
string modalParameter;
if (request.PresentationValues != null && request.PresentationValues.TryGetValue(ModalPresentationParameter, out modalParameter) && bool.Parse(modalParameter))
{
mainPage.Navigation.PushModalAsync(page);
}
else
{
// calling this sync blocks UI and never navigates hence code continues regardless here
mainPage.PushAsync(page);
}
}
catch (Exception e)
{
Mvx.Error("Exception pushing {0}: {1}\n{2}", page.GetType(), e.Message, e.StackTrace);
return(false);
}
}
return(true);
}
public void AddEnemy(Vector2 inPosition, NpcDataHolder inNpcData)
{
// --------------------------------------------------------------------------------
// Setup Player
// --------------------------------------------------------------------------------
//here we can add ability to add a specific player (if we have more than one)
Sprites = SystemFacade.Resources.LoadSpriteAtlas(ResourcesMap.Enemies);
var enemy = new EnemyView(this.application, inNpcData.name, LayerNames.GameObjects, inNpcData.profile);
enemy.SetSprite(Sprites[22]);
// --------------------------------------------------------------------------------
// Setup Physics (Add Collider Component)
// --------------------------------------------------------------------------------
var boxSize = new Vector2(Sprites[22].bounds.size.x, Sprites[22].bounds.size.y);
enemy.AddComponent(new HitBox(enemy, boxSize, inNpcData.profile.mass, false));
// --------------------------------------------------------------------------------
// Setup Animation (Add Animator Component)
// --------------------------------------------------------------------------------
enemy.Profile.SetAnimationsSource(this.Sprites); //set sprite sheet source to all animations
enemy.AddComponent(new GameAnimator(enemy, enemy.SpriteRenderer));
// --------------------------------------------------------------------------------
// Setup Controller (Add NpcController Component)
// --------------------------------------------------------------------------------
var controller = enemy.AddComponent(new NpcController(enemy, inNpcData.startFacing));
// --------------------------------------------------------------------------------
// Setup AI (Add StateMachine Component)
// --------------------------------------------------------------------------------
var entryState = SystemFacade.AI.CreateEnemyAi(controller, inNpcData);
var stateMachine = enemy.AddComponent(new StateMachine(enemy, entryState));
stateMachine.Start();
SystemFacade.Level.Level.AddView(enemy, inPosition);
ViewsContainer.AddView(enemy);
Enemies.Add(enemy);
}
private Core.Level CreateLevel()
{
// --------------------------------------------------------------------------------
// Setup Level
// --------------------------------------------------------------------------------
Level = CreateEmptyLevel();
Level.Move(Vector2.zero);
var levelSprite = SystemFacade.Resources.LoadSprite(ResourcesMap.Level);
var levelView = new SpriteView(this.application, "Level", LayerNames.Level);
levelView.SetSprite(levelSprite);
Level.AddLevel(levelView, new Vector3(0, 0, 1));
ViewsContainer.AddView(levelView);
// --------------------------------------------------------------------------------
// Setup Background
// --------------------------------------------------------------------------------
/*var bgPos = new Vector2(
* (SystemFacade.Renderer.ScreenWidth / 2 / SystemFacade.Renderer.CurrentResolution)
* ,(SystemFacade.Renderer.ScreenHeight / 2 / SystemFacade.Renderer.CurrentResolution));*/
var bgSprite = SystemFacade.Resources.LoadSprite(ResourcesMap.Background);
_background = new SpriteView(this.application, "Background", LayerNames.Background);
_background.SetSprite(bgSprite);
//- duplicate the background to fit the level platform
var duplicated = new SpriteView(this.application, "Background", LayerNames.Background);
duplicated.SetSprite(bgSprite);
_background.AddChild(duplicated);
duplicated.SetPosition(new Vector2(_background.GetSize().x, 0)); //apply offset
Level.AddBackground(_background, _config.backgroundPosition);
ViewsContainer.AddView(_background);
return(Level);
}
public CameraSystem(GameController inController, Application inApp, SystemConfig inConfig = null) : base(inController, inApp, inConfig)
{
// --------------------------------------------------------------------------------
// Set system config
// --------------------------------------------------------------------------------
_config = inConfig as CameraSystemConfig;
if (_config == null)
{
throw new Exception($"System config must be not null.");
}
// --------------------------------------------------------------------------------
// Create Camera view
// --------------------------------------------------------------------------------
//cameraView = new CameraView(this.application, Camera.gameObject); //here if we want to set an existing camera from unity
CameraView = new CameraView(this.application, "Camera", _config);
ViewsContainer.AddView(CameraView);
_targetFollow = null;
// --------------------------------------------------------------------------------
// Add Camera Shake Component
// --------------------------------------------------------------------------------
//Todo : Add camera shake
}
public async override Task <bool> ChangePresentation(MvxPresentationHint hint)
{
#if DEBUG // Only wrap in try-finally when in debug
try
{
#endif
var navigation = GetPageOfType <NavigationPage>()?.Navigation;
if (hint is MvxPopToRootPresentationHint popToRootHint)
{
// Make sure all modals are closed
await CloseAllModals(popToRootHint.Animated);
// Double check we have a navigation page, otherwise
// we can just return as we must be already at the root page
if (navigation == null)
{
return(true);
}
// Close all pages back to the root
await navigation.PopToRootAsync(popToRootHint.Animated);
return(true);
}
if (hint is MvxPopPresentationHint popHint)
{
var matched = await PopModalToViewModel(navigation, popHint);
if (matched)
{
return(true);
}
await PopToViewModel(navigation, popHint.ViewModelToPopTo, popHint.Animated);
return(true);
}
if (hint is MvxRemovePresentationHint removeHint)
{
foreach (var modal in navigation.ModalStack)
{
var removed = RemoveByViewModel(modal.Navigation, removeHint.ViewModelToRemove);
if (removed)
{
return(true);
}
}
RemoveByViewModel(navigation, removeHint.ViewModelToRemove);
return(true);
}
if (hint is MvxPagePresentationHint pageHint)
{
var pageType = ViewsContainer.GetViewType(pageHint.ViewModel);
if (GetPageOfTypeByType(pageType) is Page page)
{
if (page.Parent is TabbedPage tabbedPage)
{
tabbedPage.CurrentPage = page;
}
else if (page.Parent is CarouselPage carouselPage && page is ContentPage contentPage)
{
carouselPage.CurrentPage = contentPage;
}
}
return(true);
}
if (hint is MvxPopRecursivePresentationHint popRecursiveHint)
{
var levels = popRecursiveHint.LevelsDeep;
if (levels > navigation.NavigationStack.Count())
{
levels = navigation.NavigationStack.Count();
}
for (int i = 0; i < levels; i++)
{
await navigation.PopAsync(popRecursiveHint.Animated);
}
return(true);
}
return(true);
#if DEBUG // Only showing this when debugging MVX
}
finally
{
MvxFormsLog.Instance.Trace(FormsApplication.Hierarchy());
}
#endif
}
//- Enemies
public static EnemyView Enemy(string inEnemyName) => ViewsContainer.GetView("inEnemyName") as EnemyView;
public ConnectToLabCommand(IUnityContainer container, ViewsContainer viewsContainer)
{
_container = container;
_viewsContainer = viewsContainer;
}
public override MvxBasePresentationAttribute GetPresentationAttribute(Type viewModelType)
{
var viewType = ViewsContainer.GetViewType(viewModelType);
var overrideAttribute = GetOverridePresentationAttribute(viewModelType, viewType);
if (overrideAttribute != null)
{
return(overrideAttribute);
}
IList <MvxBasePresentationAttribute> attributes = viewType.GetCustomAttributes <MvxBasePresentationAttribute>(true).ToList();
if (attributes != null && attributes.Count > 0)
{
MvxBasePresentationAttribute attribute = null;
if (attributes.Count > 1)
{
var fragmentAttributes = attributes.OfType <MvxFragmentPresentationAttribute>();
// check if fragment can be displayed as child fragment first
foreach (var item in fragmentAttributes.Where(att => att.FragmentHostViewType != null))
{
var fragment = GetFragmentByViewType(item.FragmentHostViewType);
// if the fragment exists, and is on top, then use the current attribute
if (fragment != null && fragment.IsVisible && fragment.View.FindViewById(item.FragmentContentId) != null)
{
attribute = item;
break;
}
}
// if attribute is still null, check if fragment can be displayed in current activity
if (attribute == null)
{
var currentActivityHostViewModelType = GetCurrentActivityViewModelType();
foreach (var item in fragmentAttributes.Where(att => att.ActivityHostViewModelType != null && att.ActivityHostViewModelType == currentActivityHostViewModelType))
{
// check for MvxTabLayoutPresentationAttribute
if (item is MvxTabLayoutPresentationAttribute tabLayoutAttribute &&
CurrentActivity.FindViewById(tabLayoutAttribute.TabLayoutResourceId) != null)
{
attribute = item;
break;
}
// check for MvxViewPagerFragmentPresentationAttribute
if (item is MvxViewPagerFragmentPresentationAttribute viewPagerAttribute &&
CurrentActivity.FindViewById(viewPagerAttribute.ViewPagerResourceId) != null)
{
attribute = item;
break;
}
// check for MvxFragmentPresentationAttribute
if (CurrentActivity.FindViewById(item.FragmentContentId) != null)
{
attribute = item;
break;
}
}
}
}
if (attribute == null)
{
attribute = attributes.FirstOrDefault();
}
attribute.ViewType = viewType;
return(attribute);
}
return(CreatePresentationAttribute(viewModelType, viewType));
}
public MabadoViewBootLoader(IUnityContainer container, ViewsContainer viewsContainer)
{
_container = container;
_viewsContainer = viewsContainer;
}
protected virtual MvxBasePresentationAttribute GetAttributeForViewModel(Type viewModelType)
{
IList <MvxBasePresentationAttribute> attributes;
if (ViewModelToPresentationAttributeMap.TryGetValue(viewModelType, out attributes))
{
MvxBasePresentationAttribute attribute = null;
if (attributes.Count > 1)
{
var fragmentAttributes = attributes.OfType <MvxFragmentPresentationAttribute>();
// check if fragment can be displayed as child fragment first
foreach (var item in fragmentAttributes.Where(att => att.FragmentHostViewType != null))
{
var fragment = GetFragmentByViewType(item.FragmentHostViewType);
// if the fragment exists, and is on top, then use the current attribute
if (fragment != null && fragment.IsVisible && fragment.View.FindViewById(item.FragmentContentId) != null)
{
attribute = item;
break;
}
}
// if attribute is still null, check if fragment can be displayed in current activity
if (attribute == null)
{
var currentActivityHostViewModelType = GetCurrentActivityViewModelType();
foreach (var item in fragmentAttributes.Where(att => att.ActivityHostViewModelType != null))
{
if (CurrentActivity.FindViewById(item.FragmentContentId) != null && item.ActivityHostViewModelType == currentActivityHostViewModelType)
{
attribute = item;
break;
}
}
}
}
if (attribute == null)
{
attribute = attributes.FirstOrDefault();
}
if (attribute.ViewType?.GetInterfaces().OfType <IMvxOverridePresentationAttribute>().FirstOrDefault() is IMvxOverridePresentationAttribute view)
{
var presentationAttribute = view.PresentationAttribute();
if (presentationAttribute != null)
{
return(presentationAttribute);
}
}
return(attribute);
}
var viewType = ViewsContainer.GetViewType(viewModelType);
if (viewType.IsSubclassOf(typeof(DialogFragment)))
{
MvxTrace.Trace($"PresentationAttribute not found for {viewModelType.Name}. " +
$"Assuming DialogFragment presentation");
return(new MvxDialogFragmentPresentationAttribute());
}
if (viewType.IsSubclassOf(typeof(Fragment)))
{
MvxTrace.Trace($"PresentationAttribute not found for {viewModelType.Name}. " +
$"Assuming Fragment presentation");
return(new MvxFragmentPresentationAttribute(GetCurrentActivityViewModelType(), Android.Resource.Id.Content));
}
MvxTrace.Trace($"PresentationAttribute not found for {viewModelType.Name}. " +
$"Assuming Activity presentation");
return(new MvxActivityPresentationAttribute()
{
ViewModelType = viewModelType
});
}
public async override void ChangePresentation(MvxPresentationHint hint)
{
var navigation = GetPageOfType <NavigationPage>().Navigation;
if (hint is MvxPopToRootPresentationHint popToRootHint)
{
// Make sure all modals are closed
CloseAllModals(popToRootHint.Animated);
// Double check we have a navigation page, otherwise
// we can just return as we must be already at the root page
if (navigation == null)
{
return;
}
// Close all pages back to the root
await navigation.PopToRootAsync(popToRootHint.Animated);
return;
}
if (hint is MvxPopPresentationHint popHint)
{
var matched = await PopModalToViewModel(navigation, popHint);
if (matched)
{
return;
}
await PopToViewModel(navigation, popHint.ViewModelToPopTo, popHint.Animated);
return;
}
if (hint is MvxRemovePresentationHint removeHint)
{
foreach (var modal in navigation.ModalStack)
{
var removed = RemoveByViewModel(modal.Navigation, removeHint.ViewModelToRemove);
if (removed)
{
return;
}
}
RemoveByViewModel(navigation, removeHint.ViewModelToRemove);
return;
}
if (hint is MvxPagePresentationHint pageHint)
{
var pageType = ViewsContainer.GetViewType(pageHint.ViewModel);
if (GetPageOfTypeByType(pageType) is Page page)
{
if (page.Parent is TabbedPage tabbedPage)
{
tabbedPage.CurrentPage = page;
}
else if (page.Parent is CarouselPage carouselPage && page is ContentPage contentPage)
{
carouselPage.CurrentPage = contentPage;
}
}
return;
}
base.ChangePresentation(hint);
#if DEBUG // Only showing this when debugging MVX
MvxTrace.Trace(FormsApplication.Hierarchy());
#endif
}
