private async void ChatsServicesOnMensajeRecibido(object sender, ChatMensajeArgs e)
{
if (e.ChatRecibido != null && e.ChatRecibido.UltimoMensaje != null && !string.IsNullOrWhiteSpace(e.ChatRecibido.UltimoMensaje.Mensaje))
{
bool mensajeYaExiste = false;
if (Mensajes != null && Mensajes.Count > 0)
{
using (await _lockeable.LockAsync())
{
mensajeYaExiste = Mensajes.Where(x => x.ConsecutivoMensaje == e.ChatRecibido.UltimoMensaje.Consecutivo && e.ChatRecibido.UltimoMensaje.Consecutivo > 0).Any();
}
}
// Si el mensaje no existe entonces lo muestro en el chat, mas que todo se usa para evitar que el mensaje que yo envie en este dispositivo lo muestre doble, ya que lo recibo tambien
// Lo recibo tambien porque si escribo en este dispositivo pero estoy logeado en otro dispositivo el tambien debe recibir el mensaje aunque los dos estemos en la misma cuenta
if (!mensajeYaExiste)
{
e.ChatRecibido.UltimoMensaje.CodigoChatRecibe = e.ChatRecibido.CodigoChatRecibe;
e.ChatRecibido.UltimoMensaje.CodigoChatEnvia = e.ChatRecibido.Consecutivo;
Device.BeginInvokeOnMainThread(async() =>
{
using (await _lockeable.LockAsync())
{
if (Mensajes != null)
{
Mensajes.Insert(0, new ChatMensajesModel(e.ChatRecibido.UltimoMensaje, Chat.CodigoChatRecibe));
}
else
{
Mensajes = new ObservableRangeCollection <ChatMensajesModel>(new List <ChatMensajesModel> {
new ChatMensajesModel(e.ChatRecibido.UltimoMensaje, Chat.CodigoChatRecibe)
});
}
}
});
}
}
}
public static async Task ReconectarChatHub()
{
if (string.IsNullOrWhiteSpace(ConnectionIDChatHub) && Persona != null && _appInicializada && !_reconectando)
{
try
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5));
using (await _lockeable.LockAsync(cancellationTokenSource.Token))
{
await Task.Run(async() =>
{
_reconectando = true;
ChatsServices chatService = new ChatsServices();
while (string.IsNullOrWhiteSpace(ConnectionIDChatHub))
{
if (await CrossConnectivity.Current.IsRemoteReachable(URL.Host, msTimeout: 1000))
{
try
{
await chatService.ConectarChatHub(Persona.Consecutivo);
if (!string.IsNullOrWhiteSpace(ConnectionIDChatHub))
{
_reconectando = false;
break;
}
}
catch (Exception)
{
}
}
await Task.Delay(3000);
}
});
}
}
catch (Exception)
{
}
}
}
public override async void Init(object initData)
{
base.Init(initData);
try
{
await CargarItemsNotificaciones(0, 3);
LastRefresh = DateTime.Now;
}
catch (Exception)
{
}
ChatsServices.NotificacionRecibida += async(obj, evt) =>
{
if (evt.NotificacionRecibida != null)
{
using (await _lockeable.LockAsync())
{
LastRefresh = DateTime.Now;
bool notificacionYaExiste = false;
// Verificamos que la notificacion ya existe, tomando en cuenta que el consecutivo debe ser valido para descartar las notificaciones de otros sources que no sea la tabla de Notificaciones (Como las noticias del admin)
if (TimeLine != null && TimeLine.Count > 0)
{
notificacionYaExiste = TimeLine.Where(x => x.ConsecutivoNotificacion == evt.NotificacionRecibida.ConsecutivoNotificacion && x.ConsecutivoNotificacion > 0).Any();
}
// Si la notificacion no existe, procedo a agregarla
if (!notificacionYaExiste)
{
evt.NotificacionRecibida = BuildearNotificacionesTraducidas(evt.NotificacionRecibida);
evt.NotificacionRecibida.EsNuevoMensaje = true;
Device.BeginInvokeOnMainThread(() =>
{
if (TimeLine != null)
{
TimeLine = new ObservableRangeCollection <TimeLineNotificaciones>(new List <TimeLineNotificaciones> {
evt.NotificacionRecibida
});
}
else
{
TimeLine.Insert(0, evt.NotificacionRecibida);
}
});
// Aumentamos el contador del Badge
App.InteractuarValorBadgeNotificacion(1);
//Set or Get the state of the Effect sounds.
_audioManager.EffectsOn = true;
//Set the volume level of the Effects from 0 to 1.
_audioManager.EffectsVolume = 0.4f;
try
{
//await _audioManager.PlaySound("notificationSound.mp3");
await _audioManager.PlayNotificationDefaultSound();
}
catch (Exception)
{
}
if (evt.NotificacionRecibida.TipoDeLaNotificacion == TipoNotificacionEnum.PlanAprobado)
{
PlanesUsuariosDTO planUsuario = new PlanesUsuariosDTO
{
Consecutivo = App.Usuario.CodigoPlanUsuario,
IdiomaBase = App.IdiomaPersona
};
PlanesUsuariosDTO planDelUsuario = await _planService.BuscarPlanUsuario(planUsuario);
if (planDelUsuario != null)
{
App.Usuario.PlanesUsuarios = planDelUsuario;
}
}
if (evt.NotificacionRecibida.TipoDeLaNotificacion == TipoNotificacionEnum.PersonaEliminada)
{
if (evt.NotificacionRecibida.CodigoPersonaOrigen > 0)
{
PerfilPageModel.DispararEventoPersonaBorrada(this, evt.NotificacionRecibida.CodigoPersonaOrigen);
}
}
}
}
}
};
ConnectionChanged += async(sender, args) =>
{
if (args.IsConnect && NecesitaRefrescar)
{
try
{
await CargarItemsNotificaciones(0, 100, true, true);
NecesitaRefrescar = false;
}
catch (Exception)
{
}
}
if (!args.IsConnect)
{
NecesitaRefrescar = true;
}
};
}
public override async void Init(object initData)
{
base.Init(initData);
try
{
if (_chats != null && _chats.Count > 0)
{
await CargarConversaciones(0, 10, true);
}
else
{
await CargarConversaciones(0, 10);
}
LastRefresh = DateTime.Now;
}
catch (Exception)
{
}
ChatsServices.MensajeRecibido += async(obj, evt) =>
{
if (evt.ChatRecibido != null && evt.ChatRecibido.UltimoMensaje != null && !string.IsNullOrWhiteSpace(evt.ChatRecibido.UltimoMensaje.Mensaje))
{
LastRefresh = DateTime.Now;
int numeroMensajesNuevos = 0;
using (await _lockeable.LockAsync())
{
if (_chats != null && _chats.Count > 0)
{
// Elimino el chat si ya existe para que no salga repetido
ChatsDTO chatExistente = _chats.Where(x => (x.CodigoPersonaOwner == evt.ChatRecibido.CodigoPersonaOwner && x.CodigoPersonaNoOwner == evt.ChatRecibido.CodigoPersonaNoOwner) || (x.CodigoPersonaOwner == evt.ChatRecibido.CodigoPersonaNoOwner && x.CodigoPersonaNoOwner == evt.ChatRecibido.CodigoPersonaOwner)).FirstOrDefault();
if (chatExistente != null)
{
_chats.Remove(chatExistente);
numeroMensajesNuevos = chatExistente.NumeroMensajesNuevos;
}
}
ChatsDTO chatRecibido = new ChatsDTO
{
Consecutivo = evt.ChatRecibido.Consecutivo,
ChatsEstado = evt.ChatRecibido.ChatsEstado,
ChatsMensajesEnvia = evt.ChatRecibido.ChatsMensajesEnvia,
ChatsMensajesRecibe = evt.ChatRecibido.ChatsMensajesRecibe,
CodigoChatRecibe = evt.ChatRecibido.CodigoChatRecibe,
CodigoEstado = evt.ChatRecibido.CodigoEstado,
CodigoPersonaNoOwner = evt.ChatRecibido.CodigoPersonaNoOwner,
CodigoPersonaOwner = evt.ChatRecibido.CodigoPersonaOwner,
Creacion = evt.ChatRecibido.Creacion,
EstadoChat = evt.ChatRecibido.EstadoChat,
PersonasNoOwner = evt.ChatRecibido.PersonasNoOwner,
PersonasOwner = evt.ChatRecibido.PersonasOwner,
UltimoMensaje = evt.ChatRecibido.UltimoMensaje
};
chatRecibido.UltimoMensaje.MensajeParaMostrar = chatRecibido.PersonasOwner.Nombres + ": " + chatRecibido.UltimoMensaje.Mensaje;
// Si este CodigoPersonaOwner es igual al consecutivo de App.Persona significa que ese mensaje es generado por mi
bool esMensajeGeneradoPorMi = chatRecibido.CodigoPersonaOwner == App.Persona.Consecutivo;
// Si recibo un mensaje de la persona con la que estoy hablando
bool esMensajeConElQueConverso = CodigoChatConElQueConverso.HasValue && CodigoChatConElQueConverso.Value == chatRecibido.Consecutivo;
// Si el mensaje no es generado por mi no lo marco como nuevo
chatRecibido.EsNuevoMensaje = !esMensajeGeneradoPorMi && !esMensajeConElQueConverso;
if (esMensajeGeneradoPorMi)
{
chatRecibido.UltimoMensaje.UltimoMensajeEsMio = true;
}
else
{
// Aqui entra cuando el mensaje no es mio, entonces hay que intercambiar las entidades
// Para que el chat sea tratado como es y se vea los mensajes con el nombre de quien hablo y eso
var personaNoOwnerTemporal = chatRecibido.PersonasNoOwner;
chatRecibido.PersonasNoOwner = chatRecibido.PersonasOwner;
chatRecibido.PersonasOwner = personaNoOwnerTemporal;
var codigoPersonaNoOwnerTemporal = chatRecibido.CodigoPersonaNoOwner;
chatRecibido.CodigoPersonaNoOwner = chatRecibido.CodigoPersonaOwner;
chatRecibido.CodigoPersonaOwner = codigoPersonaNoOwnerTemporal;
var codigoChatRecibidoTemporal = chatRecibido.CodigoChatRecibe;
chatRecibido.CodigoChatRecibe = chatRecibido.Consecutivo;
chatRecibido.Consecutivo = codigoChatRecibidoTemporal;
}
chatRecibido.NumeroMensajesNuevos = numeroMensajesNuevos + 1;
if (_chats == null)
{
_chats = new ObservableRangeCollection <ChatsDTO>(new List <ChatsDTO> {
chatRecibido
});
}
else
{
_chats.Add(chatRecibido);
}
Device.BeginInvokeOnMainThread(() => RaisePropertyChanged(nameof(Chats)));
// Si el mensaje no es generado por mi (sea porque viene de otro cel o de la web)
// Si no estoy en la pantalla de conversacion
// Si el mensaje no es de la persona con la que estoy hablando
// Entonces emito sonido y subo notificacion
bool emiteSonido = !esMensajeGeneradoPorMi && (!App.EstoyEnPantallaConversacion || !esMensajeConElQueConverso);
// Si el mensaje es mio y estoy en pantalla de chat escribiendo no suena
if (emiteSonido)
{
App.InteractuarValorBadgeChat(1);
if (!App.AppIsInBackGround)
{
//Set or Get the state of the Effect sounds.
_audioManager.EffectsOn = true;
//Set the volume level of the Effects from 0 to 1.
_audioManager.EffectsVolume = esMensajeConElQueConverso ? 0.2f : 0.4f;
try
{
//await _audioManager.PlaySound("notificationSound.mp3");
await _audioManager.PlayNotificationDefaultSound();
}
catch (Exception)
{
}
}
}
}
}
};
PerfilPageModel.OnPersonaBorrada += async(obj, evt) =>
{
if (_chats != null && _chats.Count > 0)
{
using (await _lockeable.LockAsync())
{
ChatsDTO conversacionParaBorrar = _chats.Where(x => x.CodigoPersonaNoOwner == evt.CodigoPersonaBorrada).FirstOrDefault();
if (conversacionParaBorrar != null)
{
_chats.Remove(conversacionParaBorrar);
Device.BeginInvokeOnMainThread(() => RaisePropertyChanged(nameof(Chats)));
}
}
}
};
ConnectionChanged += async(sender, args) =>
{
if (args.IsConnect && NecesitaRefrescar)
{
try
{
await CargarConversaciones(0, 100, true, true);
NecesitaRefrescar = false;
}
catch (Exception)
{
}
}
if (!args.IsConnect)
{
NecesitaRefrescar = true;
}
};
}