Esempio n. 1
0
        protected ImageLoaderTaskBase(IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, bool clearCacheOnOutOfMemory)
        {
            _clearCacheOnOutOfMemory = clearCacheOnOutOfMemory;
            CancellationToken        = new CancellationTokenSource();
            Parameters           = parameters;
            NumberOfRetryNeeded  = parameters.RetryCount;
            MainThreadDispatcher = mainThreadDispatcher;
            Logger = miniLogger;
            ConfigureParameters();

            _hasCustomCacheKey = !string.IsNullOrWhiteSpace(Parameters.CustomCacheKey);
            _keys = new ConcurrentDictionary <string, string>();

            _transformationsKey = new Lazy <string>(() =>
            {
                if (Parameters.Transformations == null || Parameters.Transformations.Count == 0)
                {
                    return(string.Empty);
                }

                return(";" + string.Join(";", Parameters.Transformations.Select(t => t.Key)));
            });

            _downsamplingKey = new Lazy <string>(() =>
            {
                if (Parameters.DownSampleSize == null)
                {
                    return(string.Empty);
                }

                return(string.Concat(";", Parameters.DownSampleSize.Item1, "x", Parameters.DownSampleSize.Item2));
            });

            _rawKey = new Lazy <string>(() => GetKeyInternal(null, true));
        }
        protected ImageLoaderTaskBase(IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, bool clearCacheOnOutOfMemory, bool verboseLoadingCancelledLogging)
        {
            _verboseLoadingCancelledLogging = verboseLoadingCancelledLogging;
            _clearCacheOnOutOfMemory = clearCacheOnOutOfMemory;
            CancellationToken = new CancellationTokenSource();
            Parameters = parameters;
            NumberOfRetryNeeded = parameters.RetryCount;
            MainThreadDispatcher = mainThreadDispatcher;
            Logger = miniLogger;
            ConfigureParameters();

            _hasCustomCacheKey = !string.IsNullOrWhiteSpace(Parameters.CustomCacheKey);
            _keys = new ConcurrentDictionary<string, string>();

            _transformationsKey = new Lazy<string>(() =>
            {
                if (Parameters.Transformations == null || Parameters.Transformations.Count == 0)
                    return string.Empty;

                return ";" + string.Join(";", Parameters.Transformations.Select(t => t.Key));
            });

            _downsamplingKey = new Lazy<string>(() =>
            {
                if (Parameters.DownSampleSize == null)
                    return string.Empty;

                return string.Concat(";", Parameters.DownSampleSize.Item1, "x", Parameters.DownSampleSize.Item2);
            });

            _rawKey = new Lazy<string>(() => GetKeyInternal(null, true));

            _streamKey = new Lazy<string>(() => "Stream" + GetNextStreamIndex());
        }
 protected ImageLoaderTaskBase(IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters)
 {
     Parameters           = parameters;
     NumberOfRetryNeeded  = parameters.RetryCount;
     MainThreadDispatcher = mainThreadDispatcher;
     Logger = miniLogger;
     ConfigureParameters();
 }
        public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, Func<Image> getNativeControl, Action<WriteableBitmap, bool> doWithImage)
            : base(mainThreadDispatcher, miniLogger, parameters)
        {
            _getNativeControl = getNativeControl;
            _doWithImage = doWithImage;

            DownloadCache = downloadCache;
        }
Esempio n. 5
0
        public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, Func <Image> getNativeControl, Action <WriteableBitmap, bool, bool> doWithImage)
            : base(mainThreadDispatcher, miniLogger, parameters, false)
        {
            _getNativeControl = getNativeControl;
            _doWithImage      = doWithImage;

            DownloadCache = downloadCache;
        }
Esempio n. 6
0
		public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, Func<UIView> getNativeControl, Action<UIImage, bool> doWithImage, nfloat imageScale)
			: base(mainThreadDispatcher, miniLogger, parameters)
		{
			_getNativeControl = getNativeControl;
			_doWithImage = doWithImage;
			_imageScale = imageScale;
			DownloadCache = downloadCache;
		}
Esempio n. 7
0
 public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, Func <UIView> getNativeControl, Action <UIImage> doWithImage, nfloat imageScale)
     : base(mainThreadDispatcher, miniLogger, parameters)
 {
     CancellationToken = new CancellationTokenSource();
     _getNativeControl = getNativeControl;
     _doWithImage      = doWithImage;
     _imageScale       = imageScale;
     DownloadCache     = downloadCache;
 }
		public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, ITarget<BitmapDrawable, ImageLoaderTask> target)
			: base(mainThreadDispatcher, miniLogger, parameters, true, ImageService.Instance.Config.VerboseLoadingCancelledLogging)
		{
			if (target == null)
				throw new ArgumentNullException(nameof(target));

			_target = target;
			DownloadCache = downloadCache;
		}
		public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, nfloat imageScale, ITarget<UIImage, ImageLoaderTask> target, bool clearCacheOnOutOfMemory)
			: base(mainThreadDispatcher, miniLogger, parameters, true, clearCacheOnOutOfMemory)
		{
			if (target == null)
				throw new ArgumentNullException(nameof(target));
			
			_target = target;
			DownloadCache = downloadCache;
		}
		protected ImageLoaderTaskBase(IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters)
		{
			CancellationToken = new CancellationTokenSource();
			Parameters = parameters;
			NumberOfRetryNeeded = parameters.RetryCount;
			MainThreadDispatcher = mainThreadDispatcher;
			Logger = miniLogger;
			ConfigureParameters();
		}
Esempio n. 11
0
		public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, ImageView imageView)
			: base(mainThreadDispatcher, miniLogger, parameters)
		{
			CancellationToken = new CancellationTokenSource();
			Context = Android.App.Application.Context.ApplicationContext;
			DownloadCache = downloadCache;
			_imageWeakReference = new WeakReference<ImageView>(imageView);

			UseFadeInBitmap = true;
		}
Esempio n. 12
0
		public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, ImageView imageView)
			: base(mainThreadDispatcher, miniLogger, parameters, true)
		{
			DownloadCache = downloadCache;

			if (imageView != null)
			{
				_imageWeakReference = new WeakReference<ImageView>(imageView);
			}
		}
Esempio n. 13
0
        public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, ImageView imageView)
            : base(mainThreadDispatcher, miniLogger, parameters, true)
        {
            DownloadCache = downloadCache;

            if (imageView != null)
            {
                _imageWeakReference = new WeakReference <ImageView>(imageView);
            }
        }
Esempio n. 14
0
        public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, ITarget <BitmapDrawable, ImageLoaderTask> target)
            : base(mainThreadDispatcher, miniLogger, parameters, true)
        {
            if (target == null)
            {
                throw new ArgumentNullException(nameof(target));
            }

            _target       = target;
            DownloadCache = downloadCache;
        }
		public static IDataResolver GetResolver(ImageSource source, TaskParameter parameter, IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher)
		{
			switch (source)
			{
				case ImageSource.ApplicationBundle:
				case ImageSource.Filepath:
					return new FilePathDataResolver(source);
				case ImageSource.CompiledResource:
					return new AssetCatalogDataResolver(mainThreadDispatcher);
				case ImageSource.Url:
					return new UrlDataResolver(parameter, downloadCache);
				default:
					throw new ArgumentException("Unknown type of ImageSource");
			}
		}
Esempio n. 16
0
        /// <summary>
        /// If you are planing to use MainThreadDispatcher,
        /// make sure you call the Init method before using any MainThreadDispatcher public API.
        ///
        /// The Init methods will initialize platform specific MainThreadDispatcher implementation.
        /// </summary>
        public static void Init()
        {
            if (s_MainThreadDispatcher != null)
            {
                return;
            }

            if (Application.isEditor)
            {
                s_MainThreadDispatcher = new MainThreadDispatcherEditor();
            }
            else
            {
                s_MainThreadDispatcher = new MainThreadDispatcherRuntime();
            }
        }
Esempio n. 17
0
 internal CreateHumanPlayerCharacterTransaction(
     CharacterService characterService,
     ICharacterNameValidator nameValidator,
     ILoggerFactory loggerFactory,
     ICharacterManagementContextFactory contextFactory,
     ISpawnPointProvider spawnPointProvider,
     ICharacterTemplateSelector characterTemplateSelector,
     CharacterBuilder characterBuilder,
     IMainThreadDispatcher dispatcher)
 {
     _CharacterService          = characterService;
     _NameValidator             = nameValidator ?? throw new ArgumentNullException(nameof(nameValidator));
     _ContextFactory            = contextFactory ?? throw new ArgumentNullException(nameof(contextFactory));
     _SpawnPointProvider        = spawnPointProvider ?? throw new ArgumentNullException(nameof(spawnPointProvider));
     _CharacterTemplateSelector = characterTemplateSelector ?? throw new ArgumentNullException(nameof(characterTemplateSelector));
     _CharacterBuilder          = characterBuilder ?? throw new ArgumentNullException(nameof(characterBuilder));
     _Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
     _Log        = loggerFactory.GetLogger(GetType()) ?? throw new ArgumentNullException(nameof(loggerFactory));
 }
Esempio n. 18
0
        internal AuthenticationService(
            ClientList clientList,
            IAuthenticationContextFactory contextFactory,
            IPasswordService passwordService,
            IMainThreadDispatcher dispatcher,
            ILoggerFactory loggerFactory,
            ServerOptionsProvider optionsProvider,
            IPacketWriterPool packetWriterPool,
            ComponentSelector <Account> componentSelector)
        {
            if (clientList == null)
            {
                throw new ArgumentNullException(nameof(clientList));
            }

            if (loggerFactory == null)
            {
                throw new ArgumentNullException(nameof(loggerFactory));
            }

            if (optionsProvider == null)
            {
                throw new ArgumentNullException(nameof(optionsProvider));
            }

            _ContextFactory    = contextFactory ?? throw new ArgumentNullException(nameof(contextFactory));
            _PasswordService   = passwordService ?? throw new ArgumentNullException(nameof(passwordService));
            _Dispatcher        = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
            _PacketWriterPool  = packetWriterPool ?? throw new ArgumentNullException(nameof(packetWriterPool));
            _ComponentSelector = componentSelector ?? throw new ArgumentNullException(nameof(componentSelector));
            _Log = loggerFactory.GetLogger(GetType());

            _ClientIdLoggedIn = new bool[optionsProvider.Slot];


            clientList.ClientDisconnected += (sender, args) => LogoutClient(args.Client);
            ClientLoggedOut += (sender, args) => _Log.Info($"User '{args.Account.UserName}' has logged out");
            ClientLoggedIn  += (sender, args) => _Log.Info($"User '{args.Session.Account.UserName}' logged has logged in");
            AccountCreated  += (sender, args) => _Log.Info($"Account with username '{args.NewAccount.UserName}' has been created");
        }
		public AssetCatalogDataResolver(IMainThreadDispatcher mainThreadDispatcher)
		{
			_mainThreadDispatcher = mainThreadDispatcher;
		}
Esempio n. 20
0
 /// <summary>
 /// Initializes a new instance of the <see cref="iOSViewDispatcher"/> class.
 /// </summary>
 /// <param name="dispatcher">The dispatcher.</param>
 /// <param name="presenter">The presenter.</param>
 public iOSViewDispatcher(IMainThreadDispatcher dispatcher, IViewPresenter viewPresenter)
 {
     this.dispatcher    = dispatcher;
     this.viewPresenter = viewPresenter;
 }
Esempio n. 21
0
		/// <summary>
		/// This constructor is useful for child classes only. It can help when having a totally different loading logic.
		/// </summary>
		/// <param name="miniLogger">Logger</param>
		/// <param name="key">Key.</param>
		/// <param name="imageView">Image view.</param>
		protected ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, string key, ImageView imageView)
			: this(downloadCache, mainThreadDispatcher, miniLogger, TaskParameter.FromFile(key), imageView)
		{
		}
        public static IDataResolver GetResolver(ImageSource source, TaskParameter parameter, IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher)
        {
            switch (source)
            {
            case ImageSource.ApplicationBundle:
            case ImageSource.Filepath:
                return(new FilePathDataResolver(source));

            case ImageSource.CompiledResource:
                return(new AssetCatalogDataResolver(mainThreadDispatcher));

            case ImageSource.Url:
                return(new UrlDataResolver(parameter, downloadCache));

            default:
                throw new ArgumentException("Unknown type of ImageSource");
            }
        }
Esempio n. 23
0
 public static IObservable <T> RunOnMainThread <T>(this IMainThreadDispatcher dispatcher, Func <IObservable <T> > func)
 {
     return(dispatcher.RunOnMainThread <IObservable <T> >(func).Switch());
 }
Esempio n. 24
0
 public GameClientMessageRouter(IMainThreadDispatcher dispatcher)
 {
     this.dispatcher = dispatcher;
 }
Esempio n. 25
0
 /// <summary>
 /// This constructor is useful for child classes only. It can help when having a totally different loading logic.
 /// </summary>
 /// <param name="miniLogger">Logger</param>
 /// <param name="key">Key.</param>
 /// <param name="imageView">Image view.</param>
 protected ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, string key, ITarget <BitmapDrawable, ImageLoaderTask> target)
     : this(downloadCache, mainThreadDispatcher, miniLogger, TaskParameter.FromFile(key), target)
 {
 }
 public GameServerMessageRouter(IMainThreadDispatcher dispatcher)
 {
     this.dispatcher = dispatcher;
 }