Raise Guard method changed? - wpf

Question

Here is code of my ViewModel:
public BindableCollection<ICaller> Callers { get { return callService.Current.Callers; } }
public void TalkPrivate(ICaller caller)
{
callService.TalkPrivate(caller);
}
public bool CanTalkPrivate(ICaller caller)
{
return caller.OnHold || callService.IsConference;
}
The XAML:
<ItemsControl ItemsSource="{Binding Callers}" Grid.Row="0" Margin="10,22,10,10"
Visibility="{Binding Callers.Count, Converter={StaticResource CollectionSizeToVisibilityConverter}, ConverterParameter=false}">
<ItemsControl.ItemTemplate>
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="40"/>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="120"/>
</Grid.ColumnDefinitions>
<controls:CircleContentControl Height="40" Width="40" Grid.Column="0">
<Image Source="{Binding Image}" Stretch="Uniform" />
</controls:CircleContentControl>
<TextBlock Text="{Binding Display}" Grid.Column="1" FontSize="24" VerticalAlignment="Center" Margin="5,0,0,0"/>
<StackPanel Grid.Column="2" Orientation="Horizontal">
<Button cal:Message.Attach="TalkPrivate($dataContext)" Style="{StaticResource CallActionButtonStyle}" ToolTip="Falar privado"
Height="50" Width="50">
<Rectangle Width="20" Height="20" Fill="{Binding Path=Foreground, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Button}}}">
<Rectangle.OpacityMask>
<VisualBrush Stretch="Fill" Visual="{DynamicResource appbar_phone}" />
</Rectangle.OpacityMask>
</Rectangle>
</Button>
Call Service will change OnHold property of the Callers. However, the UI is not changed accordinly; that is, the buttons are not disabled/enabled. It seems CanTalkPrivate is not called after TalkPrivate method is called.
How can I force the button availability to refresh?
EDITED for more insights of my code:
CallerViewModel
public class CallerViewModel : PropertyChangedBase, ICaller
{
public CallerViewModel(string phoneNumber, string name, string image = null)
{
PhoneNumber = phoneNumber;
Name = name;
Display = name;
Image = image;
}
public CallerViewModel(string phoneNumber, Contact contact)
: this(phoneNumber, contact.Display, contact.Image) { }
private string name;
public string Name
{
get { return name; }
set
{
name = value;
NotifyOfPropertyChange();
}
}
private string display;
public string Display
{
get { return display; }
set
{
display = value;
NotifyOfPropertyChange();
}
}
private string phoneNumber;
public string PhoneNumber
{
get { return phoneNumber; }
set
{
phoneNumber = value;
NotifyOfPropertyChange();
}
}
private string image;
public string Image
{
get { return image; }
set
{
image = value;
NotifyOfPropertyChange();
}
}
private bool onHold;
public bool OnHold
{
get { return onHold; }
set
{
onHold = value;
NotifyOfPropertyChange();
}
}
public void AppendToDisplay(string value)
{
if (Display == Name)
Display = value;
else
Display += value;
}
public void ResetDisplay()
{
Display = Name;
}
}
}
CallService:
public class CallService : ICallService
{
private readonly ICallerSearch callerSearch;
public bool IsInCall { get { return Current != null; } }
public bool IsConference { get; private set; }
public ICurrentCall Current { get; private set; }
public string IncomingPhoneNumber { get; set; }
public CallService(ICallerSearch callerSearch)
{
this.callerSearch = callerSearch;
}
public ICurrentCall CreateCall(string number)
{
var caller = callerSearch.FindByNumber(number);
Current = new CurrentCall(caller);
return Current;
}
public ICurrentCall CreateCall(ICaller caller)
{
Current = new CurrentCall(caller);
return Current;
}
public void EndCall(ICaller caller = null)
{
if (caller == null)
EndAll();
else
{
Current.Callers.Remove(caller);
if (IsConference)
IsConference = false;
}
}
private void EndAll()
{
if (Current != null)
Current.Dispose();
Current = null;
}
public ICaller AddCaller(string number)
{
foreach (var caller in Current.Callers)
caller.OnHold = true;
var newCaller = callerSearch.FindByNumber(number);
Current.Add(newCaller);
return newCaller;
}
public void MergeCalls()
{
IsConference = true;
}
public void TalkPrivate(ICaller caller)
{
foreach (var item in Current.Callers)
item.OnHold = true;
caller.OnHold = false;
if (IsConference)
IsConference = false;
}
}
#nigel, ICaller is in fact a ViewModel already. But ICallService isn't.
EDIT2 - SOLUTION
#Nigel pointed in the right direction. What I did was: CallerViewModel listen to ICallService ConferenceStarted and ConferenceEnded and update the CanTalkPrivate:
public CallerViewModel(ICallService callService, string phoneNumber, string name, string image = null)
{
this.callService = callService;
callService.ConferenceStarted += ConferenceStarted;
PhoneNumber = phoneNumber;
Name = name;
Display = name;
Image = image;
}
private void ConferenceStarted(object sender, System.EventArgs e)
{
NotifyOfPropertyChange(() => CanTalkPrivate);
}
private bool onHold;
public bool OnHold
{
get { return onHold; }
set
{
onHold = value;
NotifyOfPropertyChange();
NotifyOfPropertyChange(()=>CanTalkPrivate);
}
}
public bool CanTalkPrivate
{
get
{
return OnHold || callService.IsConference;
}
}
However, I can't use the guard method, because it still doesn't work. But now I can bind IsEnabled to CanTalkPrivate:
<Button cal:Message.Attach="TalkPrivate($dataContext)" IsEnabled="{Binding CanTalkPrivate}" Style="{StaticResource CallActionButtonStyle}" ToolTip="Falar privado"
Height="50" Width="50">
<Rectangle Width="20" Height="20" Fill="{Binding Path=Foreground, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Button}}}">
<Rectangle.OpacityMask>
<VisualBrush Stretch="Fill" Visual="{DynamicResource appbar_phone}" />
</Rectangle.OpacityMask>
</Rectangle>
</Button>
Didn't like much all of this, but it works. Thanks everyone!

Answer 1

As most people have suggested using a property for CanTalkPrivate is best as you can control when notifications about changes happen. Using Guard methods instead of properties only work well when the parameters are coming from the UI and Caliburn.Micro can monitor them for property changes.
The way I tend to approach a problem like this where you have this sort of view logic a dedicated view model like CallerViewModel and Callers be a collection of these.
public class CallerViewModel : PropertyChangedBase
{
private readonly ICaller caller;
private readonly ICallService callService;
public CallerViewModel(ICaller caller, ICallService callService)
{
this.caller = caller;
this.callService = callService;
}
public void TalkPrivate()
{
callService.TalkPrivate(caller);
}
public bool CanTalkPrivate
{
get
{
return caller.OnHold || callService.IsConference;
}
}
}
You will still need a method of telling this view model that CanTalkPrivate has changed. If ICaller and ICallService use property changed notifications this could work. Of you may need a method on CallerViewModel that you can call when you know things have changed. It's hard to answer that part since I don't know how those two properties are altered, this part is specific to your app.
Edit due to question been updated.
Having ICaller as CallerViewModel certainly makes this solution a lot easier. Adding NotifyOfPropertyChange(() => CanTalkPrviate); to OnHold solves half the problem of correctly updating the UI correctly.
A potential solution for updating the UI on IsConferenceChanging is to one of a few solutions.
Use the event aggregator to broadcast a "call changed message" that CallerViewModel listens for.
Use simple .NET events on ICallService for when the call changes that CallerViewModel subscribes to.
Add code to the methods that use MergeCalls, AddCaller etc to update the CallerViewModel as well.

Answer 2

Caliburn.Micro uses databinding to evaluate when a guard method has to be called.
Implement INotifyPropertyChanged on your ICaller instances and raise PropertyChanged for OnHold and IsConference properties (if you haven't already done that).
Change your method signatures for both TalkPrivate and CanTalkPrivate to have parameters for every value that may change:
public bool CanTalkPrivate(ICaller caller, bool onHold, bool isConference)
{
return onHold || isConference;
}
Change your Action Message accordingly:
TalkPrivate($datacontext, $datacontext.OnHold, $datacontext.IsConference)
Alternatively, you could create an additional property CanTalkPrivate and use that instead:
TalkPrivate($datacontext, $datacontext.CanTalkPrivate)

Answer 3

Or another option is to change it so that the CanTalkPrivate is a bool property and just make a Notification call when you have a change on the underlying service.
public bool CanTalkPrivate
{
get{ return OnHold || IsConference;}
}
NotifyOfPropertyChange(() => CanTalkPrivate);