void OnApplicationPause(bool paused) { m_logger.Debug("OnApplicationPause({0})", paused); if (paused) { CallActions(); } else { lock (m_playingPlayers) { foreach (UnityAudioPlayer p in m_playingPlayers) { bool srcPlaying = (p.AudioSource)?p.AudioSource.isPlaying:false; m_logger.Debug("Resume: ({0}) src.playing={1} p.playing={2} {3}", p.Inst, srcPlaying, p.IsPlaying, p.Source); // This is a hack... if (!p.IsPlaying && srcPlaying) { p.AudioSource.Pause(); } } } } }
void Play(BatchContext context, PlayableContent playable, Action onClose) { if (!context.ActivationContext.IsClosed) { // If there's a script timer, use the activation time as a base to // play this content later. if (playable.Timer != null) { // Use clock manager so that we can use debug clock features var fireTime = playable.Timer.GetNextFireTime(context.ActivationContext.ActivationTime); var delta = ClockManager.Instance.GetTimespanFromNow(fireTime); if (delta.TotalSeconds > 0) { // Actual play time is real Now + delta - this can be different from the // computed fire time above if we're using a debug clock. var actualPlayTime = DateTime.Now + delta; Delegate.Preview(context.ActivationContext, playable, actualPlayTime); } context.Timer = Timer.Call(delta, () => { m_logger.Debug("Fired timer!"); Delegate.Play(context.ActivationContext, playable, () => { context.ActivationContext.Close(); if (onClose != null) { onClose(); } }); }); } else { Delegate.Play(context.ActivationContext, playable, () => { context.ActivationContext.Close(); if (onClose != null) { onClose(); } }); } } else { if (onClose != null) { onClose(); } } }
void m_videoPlayer_prepareCompleted(VideoPlayer source) { m_logger.Debug("PrepareCompleted"); ClipLoaded.Invoke(); if (m_paused) { m_videoPlayer.time = m_pauseTime; } if (m_playOnPrepare) { m_playOnPrepare = false; Play(); } }
void PauseAudio() { m_logger.Debug("PauseAudio player.isPlaying={0} isPlaying={1}", m_player.IsPlaying, m_isPlaying); if (m_player.IsPlaying) { m_player.Pause(); } }
void CheckForDeviceToken() { var token = UnityEngine.iOS.NotificationServices.deviceToken; var error = UnityEngine.iOS.NotificationServices.registrationError; if (count >= 100 || !string.IsNullOrEmpty(error)) { CancelInvoke("CheckForDeviceToken"); m_logger.Debug("Cancel polling"); return; } m_logger.Debug("CheckForDeviceToken: got {0} (err:{1})", token, error); if (token != null) { CancelInvoke("CheckForDeviceToken"); var tokenStr = System.BitConverter.ToString(token).Replace("-", ""); var platform = BuildSettings.IsDebug ? AppleSandbox : Apple; WebServices.Instance.UserManager.RegisterPushNotifications(platform, tokenStr, (success) => { m_logger.Debug("Register iOS push notifications {0} complete: success={1}", platform, success); }); } count++; }
public void OnStop(Action <bool> onComplete) { m_logger.Debug("OnStop ({0}) {1}", Inst, Source); m_channel.RemovePlayingPlayer(this); m_sampleTime = null; IsPlaying = false; m_samplePosition = 0; DidStartPlaying = false; if (Loader != null) { WWW www = Loader; Loader = null; www.Dispose(); } if (AudioSource) { AudioSource.Stop(); } if (onComplete != null) { onComplete(true); } if (m_audioEnded != null) { m_audioEnded(this, EventArgs.Empty); } }
public void Initialize() { try { Platform.Instance.LocalNotificationManager.CancelAllNotifications(); m_notifications = new Dictionary <string, LocalNotification>(); } catch (Exception e) { m_logger.Debug("Background Notifier failed to initialize.: \n{0}", e.Message); } }
public override bool CheckState(FrameOperationContext fop, VisualMarkerTrackingCondition condition, out object[] results) { bool met = true; List <IVisualMarker> matching = null; if (condition.VisualMarkers != null) { foreach (var vm in condition.VisualMarkers.OfType <IVisualMarker>()) { var isTracking = false; if (vm != null) { m_logger.Debug("Checking tracking for marker {0}", vm.GetIdentifier()); isTracking = ARMarkerManager.Instance.IsTracking(vm); if (isTracking) { if (matching == null) { matching = new List <IVisualMarker>(); } matching.Add(vm); } } met &= isTracking; } } if (matching != null) { results = matching.ToArray(); } else { results = null; } return(met); }
public void Activate() { if (Adapter) { IsActive = true; m_logger.Debug("Activate IsInitialized={0}", IsInitialized); if (InitializingPane) { InitializingPane.SetActive(true); } Adapter.Activate(); } }
void RenderTile(TileInfo info, int ox, int oy, int x, int y, int z) { m_logger.Debug("Render tile {0} ox={1} oy={2} x={3} y={4} z={5}", info.TileId, ox, oy, x, y, z); /* * var parameters = new Tile.Parameters * { * Fs = m_fileSource, * Id = new CanonicalTileId(z, (int)x, (int)y) * };*/ // Check to see if we need to render a new tile. if (//info.UnityTile != null && info.UnityTile && info.TileId.Z == z && (int)info.TileId.X == x && (int)info.TileId.Y == y) { m_logger.Debug("Place existing tile {0}", info.TileId); PlaceTile(info.UnityTile, ox, oy, x, y); /* * ?? who owns what here? * info.TileObj.transform.localScale = new Vector3(1 / info.UnityTile.Rect.width * sx, 1 / info.UnityTile.Rect.width * sy, 1 / info.UnityTile.Rect.height * sx); * info.TileObj.transform.localPosition = new Vector3((x - ox) * sx - (PlaneSize.x - sx) / 2 - BoundaryTiles * sx, 0, (y - oy) * sy - (PlaneSize.y - sy) / 2 - BoundaryTiles * sy); */ } else { m_logger.Debug("Load tile {0}", info.TileId); if (info.UnityTile) { m_logger.Debug("Disposing current tile {0} (canonical id={1}, name={2})", info.TileId, info.UnityTile.CanonicalTileId, info.UnityTile.gameObject.name); MapVisualizer.DisposeTile(info.TileId); info.UnityTile = null; } info.TileId = new Mapbox.Map.UnwrappedTileId(z, x, y); //MapVisualizer.LoadTile(info.TileId); /* * info.TileObj = Instantiate(TilePrefab); */ info.UnityTile = MapVisualizer.LoadTile(info.TileId); //info.TileObj.AddComponent<UnityTile>(); //info.UnityTile.Zoom = z; //info.UnityTile.RelativeScale = Conversions.GetTileScaleInMeters(0, z) / Conversions.GetTileScaleInMeters((float)MapController.Instance.MapView.CenterCoordinates.Latitude, z); //info.UnityTile.TileCoordinate = new Vector2(x, y); //info.UnityTile.Rect = Conversions.TileBounds(info.UnityTile.TileCoordinate, z); //info.TileObj.transform.SetParent(this.transform, false); //info.TileObj.transform.localScale = new Vector3(1 / info.UnityTile.Rect.width * sx, 1 / info.UnityTile.Rect.width * sy, 1 / info.UnityTile.Rect.height * sx); //info.TileObj.transform.localPosition = new Vector3((x - ox) * sx - (PlaneSize.x - sx) / 2 - BoundaryTiles * sx, 0, (y - oy) * sy - (PlaneSize.y - sy) / 2 - BoundaryTiles * sy); //info.UnityTile.transform.localScale = new Vector3(1 / info.UnityTile.Rect.width * sx, 1 / info.UnityTile.Rect.width * sy, 1 / info.UnityTile.Rect.height * sx); PlaceTile(info.UnityTile, ox, oy, x, y); //MapVisualization.ShowTile(info.UnityTile); } }
public void LoadCatalog <T>(string spaceName, string catalogName, Action <Catalog <T> > onLoad, bool?useDevCatalogs = null) { if (string.IsNullOrEmpty(catalogName)) { return; } var fileName = StorageManager.GetCatalogFileName(spaceName, catalogName + ".json"); // If the caller has specified a preference for using dev catalogs, use that, // otherwise defer to the setting here | the debug setting bool useDev = useDevCatalogs ?? (ShouldUseDevCatalogs || SettingsHelper.IsDebugSet("Debug_UseDevCatalogs")); if (InternetReachability == NetworkReachability.NotReachable) { if (RequireNetworkConnection) { SetDownloadError(WebServicesDownloadErrorCode.NoNetworkConnection); } else { var catalog = CatalogLoader.LoadCatalogFromCache <T>(fileName); if (catalog == null) { if (m_completeFailHandler != null) { m_completeFailHandler("Please connect to the network and re-try"); } } else { MediaDownloadManager.AddMediaItemProvider(catalog); onLoad(catalog); } } } else { CatalogLoader.LoadCatalog <T>(fileName, spaceName, catalogName, useDev, (status, catalog) => { if (status == ServiceCallLoadStatus.Success) { m_logger.Debug("Loaded catalog {0} with {1} item(s)", catalogName, catalog.Items == null ? 0 : catalog.Items.Length); // This callback happens outside of the Unity thread, // use the Thread Helper to move into the Unity context ThreadHelper.Instance.CallOnMainThread(() => { MediaDownloadManager.AddMediaItemProvider(catalog); onLoad(catalog); // Since we're in the Unity thread here we don't need // to protect this in a critical section }); } else { m_logger.Error("Error loading catalog {0}", catalogName); SetDownloadError(status); if (m_completeFailHandler != null) { ThreadHelper.Instance.CallOnMainThread(() => { m_completeFailHandler("Error loading catalog " + catalogName); }); } } }); } }
void PopPanel(PanelStack panelStack, Panel p, bool animate = true, RuntimeAnimatorController animController = null) { bool isTop = (p == panelStack.CurrentPanel); // Can only call PopPanel on the top panel /* rc - 11/28/2017: let panels get "popped" from * the middle of a stack. Most of the time the opposite * behaviour is unwanted (a middle panel taking anything that was * pushed after with it) * if (p != panelStack.CurrentPanel) * { * return; * }*/ AnalyticsHelper.FireEvent("PopPanel", new Dictionary <string, object> { { "Name", p.GetType().ToString() } }); m_logger.Debug("PopPanel {0} ({1}) stack={2} start", p.name, p.GetType().Name, panelStack.m_stackName); panelStack.Remove(p); m_pushedPanelStacks.Remove(p); m_showPanels.Remove(p); var curr = panelStack.CurrentPanel; var onClose = p.OnClose; p.OnClose = null; if (onClose != null) { onClose(); } if (!isTop) { // Skip animations, etc. The code // after this conditional is only // applicable when popping the top // panel SetPanelActive(p, false); p.DidPop(); return; } // If the current top panel is the one that we remembered // from before. This handles the case that "onClose" caused // the same panel to be pushed again (e.g. screen message -> // screen message) if (panelStack.CurrentPanel && (panelStack.CurrentPanel == curr)) { m_logger.Verbose("PopPanel from {0} -> {1} is ready={2}", p.GetType().Name, panelStack.CurrentPanel.GetType().Name, panelStack.CurrentPanel.IsReady); SetPanelActive(panelStack.CurrentPanel, true); panelStack.CurrentPanel.DidRegainTop(); } SetPanelOrientation(curr); // Hide this panel last // We might be re-showing the same panel as part of the onClose flow, // if so, don't tell the panel it hid because this will shut the panel down. if (panelStack.CurrentPanel != p) { Action doPop = () => { var animCtl = animController ?? p.PopAnimation; if (animCtl && animate) { p.DoAnimation(animCtl); } else { SetPanelActive(p, false); } p.DidPop(); }; if (panelStack.CurrentPanel && !panelStack.CurrentPanel.IsReady) { m_logger.Verbose("Current panel {0} is not ready!", panelStack.CurrentPanel.name); p.transform.SetAsLastSibling(); StartCoroutine(CallWhenReady(panelStack.CurrentPanel, () => { // Make sure the panel we're disabling didn't become the // current panel if (p != panelStack.CurrentPanel) { doPop(); } })); } else { m_logger.Verbose("Current panel {0} is ready!", panelStack.CurrentPanel ? panelStack.CurrentPanel.name : null); doPop(); } } if (m_showPanels.Count == 0) { ObjectHelper.SetObjectsActive(ShowWhenPanelsShowing, false); ObjectHelper.SetObjectsActive(ShowWhenNoPanelsShowing, true); } m_logger.Verbose("PopPanel {0} end", p.GetType().Name); }
public void BuyProductID(string productId) { // If Purchasing has been initialized ... if (IsInitialized) { // ... look up the Product reference with the general product identifier and the Purchasing // system's products collection. Product product = m_StoreController.products.WithID(productId); // If the look up found a product for this device's store and that product is ready to be sold ... if (product != null && product.availableToPurchase) { m_Logger.Debug(string.Format("PurchaseManager Purchasing product asychronously: '{0}'", product.definition.id)); // ... buy the product. Expect a response either through ProcessPurchase or OnPurchaseFailed // asynchronously. m_StoreController.InitiatePurchase(product); } // Otherwise ... else { // ... report the product look-up failure situation m_Logger.Debug("PurchaseManager BuyProductID: FAIL. Not purchasing product, either is not found or is not available for purchase"); } } // Otherwise ... else { // ... report the fact Purchasing has not succeeded initializing yet. Consider waiting longer or // retrying initiailization. m_Logger.Debug("PurchaseManager BuyProductID FAIL. Not initialized."); } }
void UpdateCache(Coordinates origin) { var originTile = MapTools.GetTileVector(origin.Latitude, origin.Longitude, TileZoomLevel); var minX = (int)(originTile.X - TileSpan / 2 + 1); var minY = (int)(originTile.Y - TileSpan / 2 + 1); var maxX = minX + TileSpan; var maxY = minY + TileSpan; if (minX == m_currMinX && minY == m_currMinY) { return; } m_currMinX = minX; m_currMinY = minY; List <Location> toAdd = new List <Location>(); List <Location> toRemove = new List <Location>(); BatchProcessor iter = new BatchProcessor(TileSpan * TileSpan, () => { LocationCache.Instance.UpdateCache(toAdd, toRemove); }); for (int x = minX; x < minX + TileSpan; x++) { for (int y = minY; y < minY + TileSpan; y++) { var ix = x % TileSpan; var iy = y % TileSpan; var info = m_tileInfos[ix, iy]; if (info == null || info.X != x || info.Y != y) { // Create a new one if (info != null) { lock (info) { if (info.ServiceCall != null) { info.ServiceCall.Abort(); } info.ServiceCall = null; if (info.Locations != null) { lock (toRemove) { toRemove.AddRange(info.Locations); } } } } else { info = new TileInfo(); } info.X = x; info.Y = y; m_tileInfos[ix, iy] = info; var _info = info; var _x = x; var _y = y; m_logger.Debug("Requesting locations for tile {0},{1},{2}", x, y, TileZoomLevel); Action <byte[]> processData = (data) => { // Since we're sharing the infos, these values could change lock (_info) { if (_info.X != _x || _info.Y != _y) { return; } if (data != null) { _info.Locations = GetLocations(data, _x, _y, TileZoomLevel); if (_info.Locations != null) { lock (toAdd) { toAdd.AddRange(_info.Locations); } } } } iter++; }; var cacheBytes = m_tileCache.GetTileData(TileSource, _x, _y, TileZoomLevel); if (cacheBytes != null) { processData(cacheBytes); } else { var serviceCall = GetServiceCall(x, y, TileZoomLevel); info.ServiceCall = serviceCall; serviceCall.Connect(() => { var data = serviceCall.ResponseBuffer; if (data != null) { processData(serviceCall.ResponseBuffer); m_tileCache.StoreTile(TileSource, _x, _y, TileZoomLevel, data); } }); } } else { iter++; } } } }
public void StartCollecting() { m_logger.Debug("StartCollecting"); m_spawnItemDriver.Start(); }