public ViewViewModel()
        {
            chatService = ServiceLocator.Current.GetInstance<IChatService>();
            parentViewModel = ServiceLocator.Current.GetInstance<PhotosViewModel>();
            timer = new Timer(new TimerCallback((c) => {
                DispatcherHelper.CheckBeginInvokeOnUI(() =>
                {
                    App.RootFrame.Navigate(new Uri("/View/PhotosPage.xaml", UriKind.RelativeOrAbsolute));
                });
            }),
            null,
            Timeout.Infinite,
            Timeout.Infinite);

            HideCommand = new RelayCommand(async () =>

            {
                timer.Change(TimeSpan.FromSeconds(6), TimeSpan.FromMilliseconds(-1));
                var contentList = await chatService.ReadPhotoContentAsync(
                    parentViewModel.SelectedPhoto.PhotoContentSecretId);
                var content = contentList.FirstOrDefault();
                if (content != null)
                {
                    Uri = chatService.ReadPhotoAsUri(content.Uri);
                    Stream = chatService.ReadPhotoAsStream(content.Uri);
                }
                else
                {
                    Uri = null;
                    Stream = null;
                }

            });
        }

 public InCallMessagingViewModel(IChatService chatMng, IContactsService contactsMng)
     : base(chatMng, contactsMng)
 {
     Init();
     _chatsManager.RttReceived += OnRttReceived;
     _chatsManager.ConversationUpdated += OnChatRoomUpdated;
 }

 public ChatApiController(IUserService service, IChatService service2, ICommentService service3, ILiveChat service4)
 {
     this._userService = service;
     this._chatService = service2;
     this._commentService = service3;
     this._LiveChat = service4;
 }

 public SimpleMessagingViewModel(IChatService chatMng, IContactsService contactsMng)
     : base(chatMng, contactsMng)
 {
     Init();
     _chatsManager.ConversationUnReadStateChanged += OnUnreadStateChanged;
     _chatsManager.ConversationDeclineMessageReceived += OnDeclineMessageReceived;
 }

 public Chat(IApplicationSettings settings, IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository)
 {
     _settings = settings;
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
 }

 public Chat(IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository, ICache cache)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
     _cache = cache;
 }

        /// <summary>
        ///     Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel(IDataService dataService)
        {
            _dataService = dataService;
            _dataService.GetData(
                (item, error) =>
                {
                    if (error != null)
                    {
                        // Report error here
                        return;
                    }

                    WelcomeTitle = item.Title;
                });
            ConnectCommand = new RelayCommand(OnConnect, IsNeedConnect);
            SendCommand = new RelayCommand(OnSend, CanSendMessage);
            DisConnectCommand = new RelayCommand(OnDisConnect, IsNeedDisConnect);
            var instanceContext = new InstanceContext(this);
            var channel = new DuplexChannelFactory<IChatService>(instanceContext, "chartService");
            _chatService = channel.CreateChannel();
            Nickname = "frank";
            MessageText = "Hello!";

            RaiseCommandChanged();
        }

        public ChatViewModel(IChatService chatService)
        {
            this.contacts = new ObservableCollection<Contact>();
            this.contactsView = new CollectionView(this.contacts);
            this.sendMessageRequest = new InteractionRequest<SendMessageViewModel>();
            this.showReceivedMessageRequest = new InteractionRequest<ReceivedMessage>();
            this.showDetailsCommand = new DelegateCommand<bool?>(this.ExecuteShowDetails, this.CanExecuteShowDetails);

            this.contactsView.CurrentChanged += this.OnCurrentContactChanged;

            this.chatService = chatService;
            this.chatService.Connected = true;
            this.chatService.ConnectionStatusChanged += (s, e) => this.OnPropertyChanged(() => this.ConnectionStatus);
            this.chatService.MessageReceived += this.OnMessageReceived;

            this.chatService.GetContacts(
                result =>
                {
                    if (result.Error == null)
                    {
                        foreach (var item in result.Result)
                        {
                            this.contacts.Add(item);
                        }
                    }
                });
        }

        public ChatViewModel(IChatService chatService)
        {
            _contacts = new ObservableCollection<Contact>();
            _contactsView = new CollectionView(_contacts);
            _sendMessageRequest = new InteractionRequest<SendMessageViewModel>();
            _showReceivedMessageRequest = new InteractionRequest<ReceivedMessage>();
            _showDetailsCommand = new ShowDetailsCommandImplementation(this);

            _contactsView.CurrentChanged += OnCurrentContactChanged;

            _chatService = chatService;
            _chatService.Connected = true;
            _chatService.ConnectionStatusChanged += (s, e) => RaisePropertyChanged(() => CurrentConnectionState);
            _chatService.MessageReceived += OnMessageReceived;

            _chatService.GetContacts(
                result =>
                    {
                        if (result.Error != null) return;
                        foreach (var item in result.Result)
                        {
                            _contacts.Add(item);
                        }
                    });
            RaisePropertyChanged(() => CurrentConnectionState);
        }

        public ClientViewModel()
        {
            var channelFactory = new DuplexChannelFactory<IChatService>(new ClientService(), "IChatEndpoint");

            _server = channelFactory.CreateChannel();
            _this = this;
            CreateCommands();
        }

 public ChatHub(IChatService chatService)
 {
     if (chatService == null)
     {
         throw new ArgumentNullException("chatService");
     }
     this.chatService = chatService;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="XamarinChat.ChatViewModel"/> class.
 /// </summary>
 /// <param name="chatService">Chat service.</param>
 public ChatViewModel(IChatService chatService)
 {
     ChatService = chatService;
     Messages = new ObservableCollection<string>();
     SendCommand = new Command( async nothing => {
         await ChatService.Send(new XamarinChat.Models.ClientMessage{ Client = new XamarinChat.Models.Client { Name = Name }, Message = Message });
         Message = string.Empty;
     }, nothing => CanSend);
 }

 public CommandManager(string clientId,
                       string userId,
                       string roomName,
                       IChatService service,
                       IJabbrRepository repository,
                       INotificationService notificationService)
     : this(clientId, null, userId, roomName, service, repository, notificationService)
 {
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="XamarinChat.ConnectViewModel"/> class.
 /// </summary>
 /// <param name="chatService">Chat service.</param>
 public ConnectViewModel(IChatService chatService)
 {
     ChatService = chatService;
     ConnectCommand = new Command(async nothing => {
         await ChatService.Connect();
         await ChatService.NewClient(new XamarinChat.Models.Client { Name = Name });
         OnConnected();
     }, nothing => CanConnect);
 }

 public UploadCallbackHandler(UploadProcessor processor,
                              ContentProviderProcessor resourceProcessor,
                              IConnectionManager connectionManager,
                              IChatService service)
 {
     _processor = processor;
     _resourceProcessor = resourceProcessor;
     _hubContext = connectionManager.GetHubContext<Chat>();
     _service = service;
 }

 public Chat(ContentProviderProcessor resourceProcessor,
             IChatService service,
             IJabbrRepository repository,
             ICache cache,
             ILogger logger)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
     _cache = cache;
     _logger = logger;
 }

 public MessagingViewModel(IChatService chatMng, IContactsService contactsMng)
     : this()
 {
     this._chatsManager = chatMng;
     this._contactsManager = contactsMng;
     this._chatsManager.ConversationUpdated += OnConversationUpdated;
     this._chatsManager.NewConversationCreated += OnNewConversationCreated;
     this._chatsManager.ConversationClosed += OnConversationClosed;
     this._chatsManager.ContactsChanged += OnContactsChanged;
     this._chatsManager.ContactAdded += OnChatContactAdded;
     this._chatsManager.ContactRemoved += OnChatContactRemoved;
     this._contactsManager.LoggedInContactUpdated += OnLoggedContactUpdated;
 }

 public CommandManager(string clientId,
                       string userId,
                       string roomName,
                       IChatService service,
                       IJabbrRepository repository,
                       INotificationService notificationService)
 {
     _clientId = clientId;
     _userId = userId;
     _roomName = roomName;
     _chatService = service;
     _repository = repository;
     _notificationService = notificationService;
 }

        public PhotosViewModel()
        {
            chatService = ServiceLocator.Current.GetInstance<IChatService>();

            RefreshCommand = new RelayCommand(async () =>
            {
                Photos = await chatService.ReadPhotoRecordsAsync(App.CurrentUser.UserId);
            });

            ViewPhoto = new RelayCommand(() =>
            {
                App.RootFrame.Navigate(new Uri("/View/ViewPage.xaml", UriKind.RelativeOrAbsolute));
            });
        }

 public Chat(ContentProviderProcessor resourceProcessor,
             IChatService service,
             IRecentMessageCache recentMessageCache,
             IJabbrRepository repository,
             ICache cache,
             ILogger logger,
             ApplicationSettings settings)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _recentMessageCache = recentMessageCache;
     _repository = repository;
     _cache = cache;
     _logger = logger;
     _settings = settings;
 }