public async Task EventChannel_Acknowledge_IsReceivedBySender()
{
var eventChannel = new EventChannel <object>();
var expected = true;
var task = eventChannel.SendAsync(expected);
eventChannel.Acknowledge(expected);
Assert.Equal(expected, await task);
}
private void setupListeners()
{
externalEventChannel = new EventChannel(InventoryContext.EventBus);
externalEventChannel.AddListener <ClothingDesignerUIEvents.ShowAllTemplates>(onShowAllTemplates);
externalEventChannel.AddListener <ClothingDesignerUIEvents.ShowEquippedItems>(onShowEquippedItems);
externalEventChannel.AddListener <ClothingDesignerUIEvents.ShowHiddenItems>(onShowHiddenItems);
externalEventChannel.AddListener <ClothingDesignerUIEvents.CategoryChange>(onChangeCategory);
externalEventChannel.AddListener <InventoryModelEvents.CurrentAvatarEquipmentChanged>(onCurrentAvatarEquipmentChanged);
externalEventChannel.AddListener <InventoryModelEvents.EquipmentItemVisibilityChanged>(onEquipmentItemVisibilityChanged);
Service.Get <EventDispatcher>().AddListener <EditableItemEvents.EditStateChanged>(onEditStateChanged);
}
private void setupCustomizerListeners()
{
customizerEventChannel = new EventChannel(CustomizationContext.EventBus);
customizerEventChannel.AddListener <CustomizerDragEvents.DragDecalButton>(onDragDecalButton);
customizerEventChannel.AddListener <CustomizerDragEvents.DragOffChannel>(onDragFabric);
customizerEventChannel.AddListener <CustomizerDragEvents.DragFabricButton>(onDragFabricButton);
customizerEventChannel.AddListener <CustomizerDragEvents.RotatePenguin>(onRotatePenguin);
customizerEventChannel.AddListener <CustomizerDragEvents.GestureComplete>(onGestureComplete);
customizerEventChannel.AddListener <CustomizerModelEvents.ResetItemModelEvent>(onItemModelReset);
customizerEventChannel.AddListener <CustomizerModelEvents.CustomizerStateChangedEvent>(onStateChange);
}
private void Awake()
{
dispatcher = Service.Get <EventDispatcher>();
eventChannel = new EventChannel(dispatcher);
rend = GetComponent <Renderer>();
if (rend.material.HasProperty("_Color"))
{
originalColor = rend.material.color;
}
base.gameObject.SetActive(value: false);
}
private void Start()
{
Button componentInParent = GetComponentInParent <Button>();
trayInputButton = componentInParent.GetComponent <TrayInputButton>();
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <FishingEvents.ActivateBobberButton>(onActivateBobberButton);
eventChannel.AddListener <FishingEvents.DeactivateBobberButton>(onDeactivateBobberButton);
eventChannel.AddListener <FishingEvents.PulseBobberButton>(onPulseBobberButton);
eventChannel.AddListener <FishingEvents.StopBobberButtonPulse>(onTopBobberButtonPulse);
}
private void Awake()
{
SceneRefs.Set(this);
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <PopupEvents.ShowCameraSpacePopup>(onShowPopup);
popupManagerTransform = base.transform;
canvas = GetComponent <Canvas>();
defaultPlaneDistance = canvas.planeDistance;
defaultOrderInLayer = canvas.sortingOrder;
disableCamera();
}
private EventChannelAttribute GetDefaultChannelAttribute(EventChannel channel)
{
EventChannelAttribute channelAttribute = new EventChannelAttribute();
channelAttribute.EventChannelType = this.EventChannelToChannelType(channel);
if (channelAttribute.EventChannelType <= EventChannelType.Operational)
{
channelAttribute.Enabled = true;
}
return(channelAttribute);
}
public override void OnEnter()
{
base.OnEnter();
InteractiveZoneController componentInParent = base.Owner.GetComponentInParent <InteractiveZoneController>();
if (componentInParent != null && componentInParent.Dispatcher != null)
{
eventChannel = new EventChannel(componentInParent.Dispatcher);
componentInParent.Dispatcher.AddListener <InteractionZoneEvents.IteractiveItemCountEvent>(OnInteractiveItemCountChanged);
}
}
private void Start()
{
defaultSortOrder = GetComponent <Canvas>().sortingOrder;
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <TutorialUIEvents.ShowHighlightOverlay>(onShowOverlay);
eventChannel.AddListener <TutorialUIEvents.HideHighlightOverlay>(onHideOverlay);
eventChannel.AddListener <TutorialUIEvents.SortTutorialUIToTop>(onSortToTop);
eventChannel.AddListener <TutorialUIEvents.ResetTutorialUISorting>(onResetSorting);
eventChannel.AddListener <AccessibilityEvents.AccessibilityScaleUpdated>(onAccessibilityScaleUpdate);
updateAccessibilityMultiplier();
}
private void Start()
{
customizationEventChannel = new EventChannel(CustomizationContext.EventBus);
customizationEventChannel.AddListener <CustomizerUIEvents.StartPurchaseMoment>(onStartPurchaseMoment);
customizationEventChannel.AddListener <CustomizerUIEvents.EndPurchaseMoment>(onEndPurchaseMoment);
if (Service.Get <CatalogServiceProxy>().GetActiveThemeScheduleId() > 0)
{
Service.Get <TutorialManager>().TryStartTutorial(Catalog1TutorialDefinition.Id);
}
Content.LoadAsync(onPrefabLoaded, AndroidPrefabContentKey);
}
private void OnEnable()
{
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <FriendsServiceEvents.FriendsListUpdated>(onFriendsListUpdated);
eventChannel.AddListener <FriendsServiceEvents.IncomingInvitationsListUpdated>(onIncomingInvitationsListUpdated);
eventChannel.AddListener <FriendsServiceEvents.OutgoingInvitationsListUpdated>(onOutgoingInvitationsListUpdated);
eventChannel.AddListener <FriendsScreenEvents.AvatarImageReady>(onAvatarImageReady);
eventChannel.AddListener <FriendsScreenEvents.SendFindUser>(onSendFindUser);
PreloadIcon.SetActive(value: false);
ResultPrefabContainer.SetActive(value: false);
MessageText.text = "";
}
private void Awake()
{
id = poolID++;
coll = base.gameObject.GetComponent <Collider>();
if (coll != null)
{
coll.enabled = true;
}
originalScale = base.transform.localScale;
dispatcher = Service.Get <EventDispatcher>();
eventChannel = new EventChannel(dispatcher);
}
public IEventStream CreateFor(ServiceKey service)
{
//if (_flutterEventChannel == null)
Android.Util.Log.WriteLine(Android.Util.LogPriority.Info, "Vistian.Flutter.Remoting.Droid.Example", $"Creating Event Channel - {GetEventChannelName(service)}");
var flutterEventChannel = new EventChannel(_messenger, GetEventChannelName(service));
var eventStream = new FlutterEventStream(flutterEventChannel);
Android.Util.Log.WriteLine(Android.Util.LogPriority.Info, "Vistian.Flutter.Remoting.Droid.Example", $"Complete Event Channel - {GetEventChannelName(service)}");
return(eventStream);
}
private void Start()
{
eventDispatcher = Service.Get <EventDispatcher>();
eventChannel = new EventChannel(eventDispatcher);
eventChannel.AddListener <HudEvents.HideCellPhoneHud>(onHideCellPhoneHud);
eventChannel.AddListener <HudEvents.ShowCellPhoneHud>(onShowCellPhoneHud);
eventChannel.AddListener <CellPhoneEvents.CellPhoneClosed>(onCellPhoneClosed);
notificationHandler = GetComponent <CellPhoneNotificationHandler>();
if (Service.Get <SceneTransitionService>().HasSceneArg(SceneTransitionService.SceneArgs.ShowCellPhoneOnEnterScene.ToString()))
{
CoroutineRunner.Start(showPhone(playTransitionAnimation: false), this, "showPhone(false)");
}
else
{
if (!Service.Get <GameStateController>().IsFTUEComplete || Service.Get <ZoneTransitionService>().IsInIgloo)
{
return;
}
bool flag = true;
DateTime dateTime = Service.Get <ContentSchedulerService>().PresentTime();
if (shouldPreventPhoneFromOpening())
{
flag = false;
PlayerPrefs.SetString("DailyChallengesLastOpen", dateTime.GetTimeInMilliseconds().ToString());
}
else if (PlayerPrefs.HasKey("DailyChallengesLastOpen"))
{
string @string = PlayerPrefs.GetString("DailyChallengesLastOpen");
if (!string.IsNullOrEmpty(@string))
{
DateTime dateTime2 = Convert.ToInt64(@string).MsToDateTime();
if (dateTime.Day == dateTime2.Day)
{
flag = false;
}
}
}
if (flag)
{
autoOpened = true;
if (!Service.Get <LoadingController>().IsLoading)
{
CoroutineRunner.Start(playRingAnimationAndShowPhone(), this, "CellPhoneRing");
}
else
{
eventDispatcher.AddListener <LoadingController.LoadingScreenHiddenEvent>(onLoadingScreenHidden);
}
logOpenPhoneBi();
PlayerPrefs.SetString("DailyChallengesLastOpen", dateTime.GetTimeInMilliseconds().ToString());
}
}
}
/// <summary>
/// 해당 채널에 이벤트를 전송한다.
/// </summary>
/// <param name="to">대상 채널</param>
/// <param name="evt">전송할 이벤트</param>
public void Send(EventChannel to, IBaseEvent evt)
{
if (DebugMode)
{
Debug.Log("EventService.Send : " + evt);
}
if (null != to && to.isSendable)
{
to.Broadcast(evt);
}
}
public void Subscribe_OneSubscription_HandlerShouldBeCalledWithCorrectMessage()
{
// Arrange
var channel = new EventChannel <string>();
var mockHandler = new Mock <ITestHandler <string> >();
// Act
channel.Subscribe(mockHandler.Object.Handle);
channel.Publish("Apple");
// Assert
mockHandler.Verify(h => h.Handle("Apple"), Times.Once());
}
public static EventSubscription AddSubscription(EventChannel channel, EventSubscriptionService subscriptionService)
{
var subscriptionResult = subscriptionService.SubscribeAsync(new EventSubscription
{
Channel = channel,
Key = Guid.NewGuid().ToString()
}).Result;
subscriptionResult.Should().NotBeNull();
subscriptionResult.IsSuccessful.Should().BeTrue();
return(subscriptionResult.Result);
}
private void Start()
{
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <HudEvents.ResetQuestNotifier>(onResetQuestNotifier);
eventChannel.AddListener <HudEvents.SetObjectiveText>(onObjectiveTextSet);
eventChannel.AddListener <HudEvents.ShowHideQuestNotifier>(onShowHideQuestNotifier);
eventChannel.AddListener <CinematicSpeechEvents.ShowSpeechEvent>(onShowSpeech);
eventChannel.AddListener <CinematicSpeechEvents.SpeechCompleteEvent>(onSpeechComplete);
eventChannel.AddListener <SplashScreenEvents.SplashScreenClosed>(onSplashScreenClosed);
toggleCommunicatorHudEnabled(enabled: false);
toggleMessageHudEnabled(enabled: false);
QuestPointerPanel.SetActive(value: false);
}
public void AddListeners()
{
if (!isAlreadyOwned)
{
if (catalogChannel == null)
{
catalogChannel = new EventChannel(CatalogContext.EventBus);
}
catalogChannel.AddListener <CatalogUIEvents.ShopItemClickedEvent>(onOtherShopItemClickedEvent);
catalogChannel.AddListener <CatalogUIEvents.BuyPanelCloseButtonClickedEvent>(onBackButtonClicked);
catalogChannel.AddListener <CatalogUIEvents.BuyPanelPurchaseButtonClickedEvent>(onPurchaseClicked);
}
}
/// <summary>
/// 채널을 하나 등록한다.
/// </summary>
/// <returns>생성된 채널</returns>
public EventChannel CreateChannel()
{
EventChannel channel = new EventChannel();
channelList.Add(channel);
if (DebugMode)
{
Debug.Log("EventService.CreateChannel : " + channel.ID + " . " + channel.Name + " :: ChannelCount : " + ChannelCount);
}
return(channel);
}
public void Start()
{
eventChannel = new EventChannel(CustomizationContext.EventBus);
eventChannel.AddListener <CustomizerUIEvents.SelectChannelEvent>(onChannelSelected);
eventChannel.AddListener <CustomizerModelEvents.ChannelChangedEvent>(onChangedChannel);
eventChannel.AddListener <CustomizerUIEvents.InputStateChange>(OnInputStateChange);
eventChannel.AddListener <CustomizerUIEvents.InputOverChannel>(OnInputOverChannel);
eventChannel.AddListener <CustomizerUIEvents.SaveCancel>(onSaveCancelButton);
eventChannel.AddListener <CustomizerWidgetEvents.RotationWidgetRotated>(onRotationWidgetRotated);
eventChannel.AddListener <CustomizerWidgetEvents.TileValueChanged>(onTilingToggled);
eventChannel.AddListener <CustomizerWidgetEvents.SliderWidgetValueChanged>(onScaleChanged);
eventChannel.AddListener <CustomizerActiveSwatchEvents.ToggleActiveSwatch>(onToggleActiveSwatch);
}
private void Awake()
{
backButtonController = Service.Get <BackButtonController>();
eventChannel = new EventChannel(CustomizationContext.EventBus);
eventChannel.AddListener <CustomizerUIEvents.BackButtonClickedEvent>(onBackButtonClicked);
eventChannel.AddListener <CustomizerUIEvents.SaveItem>(onSaveClothingItemSuccess);
eventChannel.AddListener <CustomizerUIEvents.SaveItemFailure>(onSaveClothingItemFailure);
eventChannel.AddListener <CustomizerModelEvents.TemplateChangedEvent>(onTemplateChosen);
eventChannel.AddListener <CustomizerUIEvents.TemplateConfirmed>(onTemplateConfirmed);
eventChannel.AddListener <CustomizerUIEvents.SwitchToCustomize>(onSwitchToCustomize);
eventChannel.AddListener <CustomizerUIEvents.SwitchToSave>(onSwitchToSave);
eventChannel.AddListener <CustomizerUIEvents.StartPurchaseMoment>(onStartPurchaseMoment);
eventChannel.AddListener <CustomizerUIEvents.EndPurchaseMoment>(onEndPurchaseMoment);
}
private void Start()
{
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <ControlsScreenEvents.SetLeftOption>(onSetLeftOption);
eventChannel.AddListener <ControlsScreenEvents.SetDefaultLeftOption>(onSetDefaultLeftOption);
eventChannel.AddListener <ControlsScreenEvents.ReturnToDefaultLeftOption>(onReturnToDefaultLeftOption);
eventChannel.AddListener <ControlsScreenEvents.SetRightOption>(onSetRightOption);
eventChannel.AddListener <ControlsScreenEvents.ReturnToDefaultRightOption>(onReturnToDefaultRightOption);
eventChannel.AddListener <ControlsScreenEvents.SetButton>(onSetButton);
eventChannel.AddListener <SessionEvents.SessionEndedEvent>(onSessionEnded);
DataEntityHandle handle = dataEntityCollection.AddEntity("ControlsScreenData");
controlsScreenData = dataEntityCollection.AddComponent <ControlsScreenData>(handle);
}
private void Awake()
{
rectTransform = base.transform as RectTransform;
animator = GetComponent <Animator>();
_originalPosition = rotationTarget.localPosition;
_originalRotation = rotationTarget.localRotation;
if (rotationCenter == null)
{
rotationCenter = rotationTarget;
}
eventChannel = new EventChannel(CustomizationContext.EventBus);
eventChannel.AddListener <CustomizerWidgetEvents.RotationWdigetSetIsInteractable>(onSetInteractable);
eventChannel.AddListener <CustomizerWidgetEvents.RotationWidgetSetValue>(onSetValue);
}
public QuestService(Manifest manifest, PersistentBreadcrumbTypeDefinitionKey breadcrumbType)
{
this.breadcrumbType = breadcrumbType;
dispatcher = Service.Get <EventDispatcher>();
MascotService mascotService = Service.Get <MascotService>();
List <QuestDefinition> list = new List <QuestDefinition>();
ScriptableObject[] assets = manifest.Assets;
foreach (ScriptableObject scriptableObject in assets)
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(scriptableObject.name);
Mascot mascot = mascotService.GetMascot(fileNameWithoutExtension);
ScriptableObject[] assets2 = ((Manifest)scriptableObject).Assets;
foreach (ScriptableObject scriptableObject2 in assets2)
{
QuestDefinition questDefinition = (QuestDefinition)scriptableObject2;
knownQuests[scriptableObject2.name] = questDefinition;
questToMascotMap[scriptableObject2.name] = mascot;
list.Add(questDefinition);
}
mascot.KnownQuests = list.ToArray();
list.Clear();
}
eventChannel = new EventChannel(dispatcher);
eventChannel.AddListener <QuestEvents.SuspendQuest>(onSuspendQuestRequest);
eventChannel.AddListener <QuestEvents.ResumeQuest>(onResumeQuestRequest);
eventChannel.AddListener <QuestEvents.StartQuest>(onStartQuestRequest);
eventChannel.AddListener <QuestEvents.ReplayQuest>(onReplayQuestRequest);
eventChannel.AddListener <QuestEvents.RestartQuest>(onRestartQuestRequest);
eventChannel.AddListener <SplashScreenEvents.SplashScreenOpened>(onSplashScreenOpened);
eventChannel.AddListener <SplashScreenEvents.SplashScreenClosed>(onSplashScreenClosed);
eventChannel.AddListener <QuestEvents.QuestUpdated>(onQuestUpdated);
eventChannel.AddListener <QuestEvents.QuestInitializationComplete>(onQuestInitializationComplete);
eventChannel.AddListener <RewardEvents.RewardPopupComplete>(onRewardPopupComplete);
eventChannel.AddListener <QuestEvents.SetPlayerOutOfWorld>(onSetPlayerOutOfWorld);
eventChannel.AddListener <SceneTransitionEvents.TransitionStart>(onSceneTransition);
eventChannel.AddListener <QuestEvents.RegisterQuestSubFsm>(onRegisterQuestSubFsm);
eventChannel.AddListener <InWorldUIEvents.DisableActionIndicators>(onDisableActionIndicators);
eventChannel.AddListener <InWorldUIEvents.EnableActionIndicators>(onEnableActionIndicators);
eventChannel.AddListener <QuestServiceEvents.QuestStatesRecieved>(onQuestStatesReceived);
eventChannel.AddListener <QuestServiceErrors.QuestProgressionError>(onQuestProgressionError);
eventChannel.AddListener <ProgressionEvents.LevelUp>(onLevelUp);
updateQuestGivers(0);
timeLockedCheckTimer = new Timer(2f, repeat: true, delegate
{
onTimerTick();
});
CoroutineRunner.StartPersistent(timeLockedCheckTimer.Start(), this, "timeLockedQuestTimer");
}
private void Awake()
{
dataEntityCollection = Service.Get <CPDataEntityCollection>();
locomotionTracker = GetComponent <LocomotionTracker>();
locomotionStateSetter = GetComponent <AvatarLocomotionStateSetter>();
playerDataHandle = GetComponent <AvatarDataHandle>();
positionTimeline = new PositionTimeline(MaxQueueTimeMS, WarningQueueTimeMS);
remoteSnowballLauncher = GetComponent <RemotePenguinSnowballThrower>();
timer = new Stopwatch();
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <PlayerActionServiceEvents.LocomotionActionReceived>(onLocomotionAction);
locomotionEventBroadcaster = GetComponent <LocomotionEventBroadcaster>();
locomotionEventBroadcaster.OnControlsLocked += onControlsLocked;
locomotionEventBroadcaster.OnControlsUnLocked += onControlsUnLocked;
}
public CatalogServiceProxy()
{
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <CatalogServiceProxyEvents.OnCatalogItemsByCategory>(onItemsByCategory);
eventChannel.AddListener <CatalogServiceProxyEvents.OnCatalogItemsByFriend>(onItemsByFriend);
eventChannel.AddListener <CatalogServiceProxyEvents.OnCatalogItemsByPopular>(onItemsByPopular);
eventChannel.AddListener <CatalogServiceProxyEvents.OnCatalogItemsByRecent>(onItemsByRecent);
eventChannel.AddListener <CatalogServiceEvents.CurrentThemesRetrievedEvent>(onThemes);
eventChannel.AddListener <CatalogServiceEvents.CurrentThemesErrorEvent>(onThemesError);
eventChannel.AddListener <CatalogServiceEvents.UserStatsRetrievedEvent>(onStats);
eventChannel.AddListener <CatalogServiceProxyEvents.ChallengesReponse>(onThemesRetrieved);
eventChannel.AddListener <WorldServiceEvents.SelfRoomJoinedEvent>(onRoomJoined);
themeColors = new CatalogThemeColors();
cache = new CatalogCache();
}
public void Start()
{
trayState = TrayState.OPEN;
controlsState = TrayState.OPEN;
previousTrayState = trayState;
previousControlsState = controlsState;
Service.Get<TrayNotificationManager>().SetParentRectTransform(NotificationsTransform);
eventChannel = new EventChannel(Service.Get<EventDispatcher>());
myTrayHeightNoKB = DefaultTrayHeight;
resizeTray(myTrayHeightNoKB);
eventChannel.AddListener<TrayEvents.OpenTray>(onOpenTray);
eventChannel.AddListener<TrayEvents.CloseTray>(onCloseTray);
eventChannel.AddListener<TrayEvents.RestoreTray>(onRestoreTray);
eventChannel.AddListener<TrayEvents.TrayHeightAdjust>(onResizeTray);
}
public void Awake()
{
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <FriendsServiceEvents.FriendsListUpdated>(onFriendsListUpdated);
eventChannel.AddListener <FriendsServiceEvents.IncomingInvitationsListUpdated>(onIncomingInvitationsListUpdated);
eventChannel.AddListener <FriendsServiceEvents.OutgoingInvitationsListUpdated>(onOutgoingInvitationsListUpdated);
eventChannel.AddListener <PlayerCardEvents.DismissPlayerCard>(onPlayerCardDismiss);
eventChannel.AddListener <PlayerCardEvents.SendFriendInvitation>(onSendFriendInvitation);
eventChannel.AddListener <PlayerCardEvents.AcceptFriendInvitation>(onAcceptFriendInvitation);
eventChannel.AddListener <PlayerCardEvents.ReportPlayer>(onReportPlayer);
eventChannel.AddListener <PlayerCardEvents.JoinPlayer>(onJoinPlayer);
eventChannel.AddListener <PlayerCardEvents.UnfriendPlayer>(onUnfriendPlayer);
DetailsController.SetPlayerCardController(this);
dataEntityCollection = Service.Get <CPDataEntityCollection>();
}
private void Awake()
{
dispatcher = playgroundController.EventDispatcher;
eventChannel = new EventChannel(dispatcher);
contentSchedulerService = Service.Get <ContentSchedulerService>();
localizer = Service.Get <Localizer>();
dataEntityCollection = Service.Get <CPDataEntityCollection>();
evergreenMusicTarget = GameObject.Find(EvergreenMusicTargetPath);
EventManager.Instance.PostEvent(MusicEventName, EventAction.PlaySound, evergreenMusicTarget);
createCoMusicTarget = GameObject.Find(CrateCoMusicTargetPath);
Service.Get <EventDispatcher>().AddListener <ZoneTransitionEvents.ZoneTransition>(onZoneTransition);
Service.Get <EventDispatcher>().AddListener <RewardServiceEvents.RewardsEarned>(onRewardsEarned);
Service.Get <EventDispatcher>().AddListener <IslandTargetsEvents.ClockTowerStateChanged>(onClockTowerStateChange);
if (DisableWhenNoGameServer.IsGameServerAvailable())
{
gameTimer = new Timer(1f, repeat: true, delegate
{
onGameTimerTick();
});
animatorFloatingClock = ClockTimer.GetComponentInChildren <Animator>();
CoroutineRunner.Start(setScarecrowVisible(isVisible: true), this, "setScarecrowVisible");
CoroutineRunner.Start(setClockTimerVisible(isVisible: false), this, "setClockTimerVisible");
eventChannel.AddListener <IslandTargetsEvents.TargetsRemainingUpdated>(onTargetsRemainingUpdated);
eventChannel.AddListener <IslandTargetsEvents.GameRoundStarted>(onRoundStarted);
eventChannel.AddListener <IslandTargetsEvents.GameRoundEnded>(onRoundEnded);
eventChannel.AddListener <IslandTargetsEvents.TargetGameTimeOut>(onGameTimeOut);
eventChannel.AddListener <IslandTargetsEvents.StatsUpdated>(onStatsUpdated);
if (TimeUtils.isMultipleOfXMinutesAfterTheHour(contentSchedulerService.PresentTime(), islandTargetsPlayground.EveryXMinutesAfterTheHour))
{
gotoFiveSecsGameStartMarkState();
}
else
{
InvokeRepeating("displayGameStartCountdown", 0f, 1f);
}
}
else
{
ClockTimer.SetActive(value: false);
WinStreakText.SetText(BestEverStreak.ToString());
DailyRecordText.transform.parent.gameObject.SetActive(value: false);
}
if (string.IsNullOrEmpty(BI_Tier1Name))
{
BI_Tier1Name = "crate_co_game";
Log.LogError(this, $"Error: Tier1 name for BI is not set on '{base.gameObject.GetPath()}'");
}
}
/// <summary>
/// Global eventing Subscribe stub.
/// </summary>
/// <param name="header">Header object.</param>
/// <param name="reader">An XmlReader positioned at the begining of the Subscribe request body element.</param>
/// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the event source specified in the filter.</param>
/// <returns>Byte array containing a Subscribe response.</returns>
internal WsMessage Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
{
WsMessage msg = null;
// Parse Subscribe Request
/////////////////////////////
DpwsWseEventSink eventSink = new DpwsWseEventSink();
try
{
reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri))
{
eventSink.EndTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace);
}
reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri))
{
eventSink.NotifyTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace);
}
else
{
throw new WsFaultException(header, WsFaultType.WseDeliverModeRequestedUnavailable);
}
reader.ReadEndElement();
if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
{
long expires = new WsDuration(reader.ReadElementString()).DurationInSeconds;
if (expires > 0)
{
eventSink.Expires = expires;
}
else
{
throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
}
}
else
{
// Never Expires
eventSink.Expires = -1;
}
if (reader.IsStartElement("Filter", WsWellKnownUri.WseNamespaceUri))
{
if (reader.MoveToAttribute("Dialect") == false || reader.Value != m_version.WsdpNamespaceUri + "/Action")
{
throw new WsFaultException(header, WsFaultType.WseFilteringRequestedUnavailable);
}
reader.MoveToElement();
String filters = reader.ReadElementString();
if (filters != String.Empty)
{
eventSink.Filters = filters.Split(' ');
}
}
XmlReaderHelper.SkipAllSiblings(reader);
reader.ReadEndElement(); // Subscribe
}
catch (XmlException e)
{
throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
}
// Parse urn:uuid from the To address
string endpointAddress = FixToAddress(header.To);
// Build a temporary collection of device services that match the specified endpoint address.
WsServiceEndpoints matchingServices = new WsServiceEndpoints();
for (int i = 0; i < serviceEndpoints.Count; ++i)
{
if (serviceEndpoints[i].EndpointAddress == endpointAddress)
matchingServices.Add(serviceEndpoints[i]);
}
// For each service with a matching endpoint and event sources add an event sink to the
// event source collection
for (int i = 0; i < matchingServices.Count; ++i)
{
DpwsWseEventSources eventSources = ((DpwsHostedService)matchingServices[i]).EventSources;
// Set the EventSinkID
eventSink.ID = "urn:uuid:" + Guid.NewGuid().ToString();
// If subscribing to all event sources
if (eventSink.Filters == null)
{
int count = eventSources.Count;
for (int ii = 0; i < count; i++)
{
DpwsWseEventSource eventSource = eventSources[ii];
eventSink.StartTime = DateTime.Now.Ticks;
Uri key = eventSink.NotifyTo.Address;
if(m_evtChannelLookup.Contains(key))
{
EventChannel ec = (EventChannel)m_evtChannelLookup[key];
eventSink.RequestChannel = ec.Channel;
Interlocked.Increment(ref ec.RefCount);
}
else
{
WS2007HttpBinding binding = new WS2007HttpBinding(new HttpTransportBindingConfig(eventSink.NotifyTo.Address, m_persistEventConnections));
eventSink.RequestChannel = binding.CreateClientChannel(new ClientBindingContext(m_version));
if(m_persistEventConnections)
{
eventSink.RequestChannel.Open();
}
m_evtChannelLookup[key] = new EventChannel(eventSink.RequestChannel);
}
eventSource.EventSinks.Add(eventSink);
}
}
else
{
// If subscribing to a specific event based on an event filter.
DpwsWseEventSource eventSource;
string[] filterList = eventSink.Filters;
int length = filterList.Length;
for (int ii = 0; i < length; i++)
{
if ((eventSource = eventSources[filterList[ii]]) != null)
{
eventSink.StartTime = DateTime.Now.Ticks;
Uri key = eventSink.NotifyTo.Address;
if(m_evtChannelLookup.Contains(key))
{
EventChannel ec = (EventChannel)m_evtChannelLookup[key];
eventSink.RequestChannel = ec.Channel;
Interlocked.Increment(ref ec.RefCount);
}
else
{
WS2007HttpBinding binding = new WS2007HttpBinding(new HttpTransportBindingConfig(eventSink.NotifyTo.Address, m_persistEventConnections));
eventSink.RequestChannel = binding.CreateClientChannel(new ClientBindingContext(m_version));
if(m_persistEventConnections)
{
eventSink.RequestChannel.Open();
}
m_evtChannelLookup[key] = new EventChannel(eventSink.RequestChannel);
}
eventSource.EventSinks.Add(eventSink);
}
else
{
throw new Exception("Event source " + filterList[ii] + " was not found.");
}
}
}
}
// Generate Response
//////////////////////////
using(XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create())
{
WsWsaHeader responseHeader = new WsWsaHeader(
WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse", // Action
header.MessageID, // RelatesTo
header.ReplyTo.Address.AbsoluteUri, // To
null, null, null); // ReplyTo, From, Any
msg = new WsMessage(responseHeader, null, WsPrefix.Wse, null,
new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID));
WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version);
smw.WriteSoapMessageStart(xmlWriter, msg);
// write body
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscribeResponse", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscriptionManager", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "Address", null);
// Create a uri. Use the path (by default will be a uuid) for the sub manager endpoint
Uri subMgrUri = new Uri(((DpwsHostedService)matchingServices[0]).EndpointAddress);
xmlWriter.WriteString("http://" + Device.IPV4Address + ":" + Device.Port + "/" + subMgrUri.AbsolutePath);
xmlWriter.WriteEndElement(); // End Address
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "ReferenceParameters", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Identifier", null);
xmlWriter.WriteString(eventSink.ID);
xmlWriter.WriteEndElement(); // End Identifier
xmlWriter.WriteEndElement(); // End ReferenceParameters
xmlWriter.WriteEndElement(); // End SubscriptionManager
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null);
xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString);
xmlWriter.WriteEndElement(); // End Expires
xmlWriter.WriteEndElement(); // End SubscribeResponse
smw.WriteSoapMessageEnd(xmlWriter);
// Return stream buffer
msg.Body = xmlWriter.ToArray();
}
return msg;
}
private string GetChannelName(EventChannel channel, string eventName)
{
string ret = null;
if (channelTab == null || !channelTab.TryGetValue((int)channel, out ret))
throw new ArgumentException("Use of undefined channel value " + channel + " for event " + eventName);
return ret;
}
private string GetChannelName(EventChannel channel, string eventName)
{
string str = null;
if ((this.channelTab == null) || !this.channelTab.TryGetValue((int) channel, out str))
{
throw new ArgumentException(string.Concat(new object[] { "Use of undefined channel value ", channel, " for event ", eventName }));
}
return str;
}
private string GetChannelName(EventChannel channel, string eventName)
{
ChannelInfo info = null;
if (channelTab == null || !channelTab.TryGetValue((int)channel, out info))
throw new ArgumentException(Environment.GetResourceString("EventSource_UndefinedChannel", channel, eventName));
return info.Name;
}
