How to use

AVSession

in

cn.leancloud.session

@Override
public void onWebSocketOpen() {
 LOGGER.d("web socket opened, send session open.");
 if (AVSession.Status.Closed == session.getCurrentStatus()) {
  session.reopen();
 }
}

public boolean queryConversationsDirectly(final String clientId, final String queryString, int requestId) {
 AVSession session = AVSessionManager.getInstance().getOrCreateSession(clientId);
 session.queryConversations(JSON.parseObject(queryString, Map.class), requestId);
 return true;
}

public AVSession getOrCreateSession(String peerId) {
 try {
  // 据说这行有NPE，所以不得不catch起来避免app崩溃
  boolean newAdded = !peerIdEnabledSessions.containsKey(peerId);
  AVSession session = null;
  if (newAdded) {
   session = new AVSession(peerId, new AVDefaultSessionListener());
   AVConnectionManager.getInstance().subscribeConnectionListener(peerId, session.getWebSocketListener());
   peerIdEnabledSessions.put(peerId, session);
  } else {
   session = peerIdEnabledSessions.get(peerId);
  }
  return session;
 } catch (Exception e) {
  LOGGER.w("failed to create Session instance.", e);
  return null;
 }
}

void reopen() {
 String rtmSessionToken = AVSessionCacheHelper.IMSessionTokenCache.getIMSessionToken(getSelfPeerId());
 if (!StringUtil.isEmpty(rtmSessionToken)) {
  openWithSessionToken(rtmSessionToken);
 } else {
  int requestId = WindTalker.getNextIMRequestId();
  openWithSignature(requestId, true, false);
 }
}

public void removeSession(String peerId) {
 AVSession session = peerIdEnabledSessions.remove(peerId);
 if (session != null && session.getWebSocketListener() != null) {
  AVConnectionManager.getInstance().unsubscribeConnectionListener(session.getSelfPeerId());
 }
}

private String getConversationGeneString() {
 if (StringUtil.isEmpty(conversationGene)) {
  HashMap<String, String> conversationGeneMap = new HashMap<String, String>();
  conversationGeneMap.put(Conversation.INTENT_KEY_CLIENT, session.getSelfPeerId());
  conversationGeneMap.put(Conversation.INTENT_KEY_CONVERSATION, this.conversationId);
  conversationGene = JSON.toJSONString(conversationGeneMap);
 }
 return conversationGene;
}
private AVIMConversation parseConversation(AVIMClient client, Messages.ConvCommand convCommand) {

private void openWithSessionToken(String rtmSessionToken) {
 SessionControlPacket scp = SessionControlPacket.genSessionCommand(
     this.getSelfPeerId(), null, SessionControlPacket.SessionControlOp.OPEN,
     null, this.getLastNotifyTime(), this.getLastPatchTime(), null);
 scp.setSessionToken(rtmSessionToken);
 scp.setReconnectionRequest(true);
 AVConnectionManager.getInstance().sendPacket(scp);
}
private void openWithSignature(final int requestId, final boolean reconnectionFlag,

@Override
public void onWebSocketClose() {
 if (AVSession.Status.Closed != session.getCurrentStatus()) {
  try {
   session.sessionListener.onSessionPaused(session);
     Message m = session.pendingMessages.poll();
     if (!StringUtil.isEmpty(m.cid)) {
      AVConversationHolder conversation = session.getConversationHolder(m.cid, Conversation.CONV_TYPE_NORMAL);
      InternalConfiguration.getOperationTube().onOperationCompleted(session.getSelfPeerId(), conversation.conversationId,
          Integer.parseInt(m.id), Conversation.AVIMOperation.CONVERSATION_SEND_MESSAGE,
          new RuntimeException("Connection Lost"));

/**
 * 处理 v2 版本中 message 的 rcp 消息
 * @param msgId
 * @param conversationId
 * @param timestamp
 */
private void processMessageReceipt(String msgId, String conversationId, int convType, long timestamp) {
 Object messageCache =
     MessageReceiptCache.get(session.getSelfPeerId(), msgId);
 if (messageCache == null) {
  return;
 }
 Message m = (Message) messageCache;
 AVIMMessage msg =
     new AVIMMessage(conversationId, session.getSelfPeerId(), m.timestamp, timestamp);
 msg.setMessageId(m.id);
 msg.setContent(m.msg);
 msg.setMessageStatus(AVIMMessage.AVIMMessageStatus.AVIMMessageStatusReceipt);
 AVConversationHolder conversation = session.getConversationHolder(conversationId, convType);
 conversation.onMessageReceipt(msg);
}

AVSession.Status prevStatus = session.getCurrentStatus();
session.setSessionStatue(AVSession.Status.Opened);
 session.updateRealtimeSessionToken(command.getSt(), Integer.valueOf(command.getStTtl()));
session.updateRealtimeSessionToken(command.getSt(), Integer.valueOf(command.getStTtl()));

private boolean checkSessionStatus(Conversation.AVIMOperation operation, int requestId) {
 if (session.getCurrentStatus() == AVSession.Status.Closed) {
  RuntimeException se = new RuntimeException("Connection Lost");
  InternalConfiguration.getOperationTube().onOperationCompleted(session.getSelfPeerId(), conversationId,
      requestId, operation, se);
  return false;
 } else {
  return true;
 }
}

private void cleanSession(AVSession session) {
 AVSessionCacheHelper.getTagCacheInstance().removeSession(session.getSelfPeerId());
 session.setSessionStatue(AVSession.Status.Closed);
 // 如果session都已不在，缓存消息静静地等到桑田沧海
 session.cleanUp();
 AVSessionManager.getInstance().removeSession(session.getSelfPeerId());
}

/**
 * 处理 v2 版本中 conversation 的 deliveredAt 事件
 * @param conversationId
 * @param timestamp
 */
private void processConversationDeliveredAt(String conversationId, int convType, long timestamp) {
 AVConversationHolder conversation = session.getConversationHolder(conversationId, convType);
 conversation.onConversationDeliveredAtEvent(timestamp);
}

private void processAckCommand(String peerId, Integer requestKey, Messages.AckCommand ackCommand) {
 session.setServerAckReceived(System.currentTimeMillis() / 1000);
 long timestamp = ackCommand.getT();
 final Message m = session.pendingMessages.poll(String.valueOf(requestKey));
 if (ackCommand.hasCode()) {
  // 这里是发送消息异常时的ack
  this.onAckError(requestKey, ackCommand, m);
 } else {
  if (null != m && !StringUtil.isEmpty(m.cid)) {
   AVConversationHolder conversation = session.getConversationHolder(m.cid, Conversation.CONV_TYPE_NORMAL);
   session.conversationOperationCache.poll(requestKey);
   String msgId = ackCommand.getUid();
   conversation.onMessageSent(requestKey, msgId, timestamp);
   if (m.requestReceipt) {
    m.timestamp = timestamp;
    m.id = msgId;
    MessageReceiptCache.add(session.getSelfPeerId(), msgId, m);
   }
  }
 }
}
private void processRcpCommand(String peerId, Messages.RcpCommand rcpCommand) {

 @Override
 public Signature computeSignature() throws SignatureFactory.SignatureException {
  SignatureFactory signatureFactory = AVIMOptions.getGlobalOptions().getSignatureFactory();
  if (null == signatureFactory && !StringUtil.isEmpty(getUserSessionToken())) {
   signatureFactory = new AVUserSignatureFactory(getUserSessionToken());
  }
  if (null != signatureFactory) {
   return signatureFactory.createSignature(getSelfPeerId(), new ArrayList<String>());
  }
  return null;
 }
};

public boolean queryClientStatus(String clientId, final AVIMClientStatusCallback callback) {
 LOGGER.d("queryClientStatus...");
 AVIMClient.AVIMClientStatus status = AVIMClient.AVIMClientStatus.AVIMClientStatusNone;
 AVSession session = AVSessionManager.getInstance().getOrCreateSession(clientId);
 if (AVSession.Status.Opened == session.getCurrentStatus()) {
  status = AVIMClient.AVIMClientStatus.AVIMClientStatusOpened;
 } else {
  status = AVIMClient.AVIMClientStatus.AVIMClientStatusPaused;
 }
 if (null != callback) {
  callback.internalDone(status, null);
 }
 return true;
}

void onHistoryMessageQuery(ArrayList<AVIMMessage> messages, int requestId, long deliveredAt, long readAt) {
 HashMap<String, Object> bundle = new HashMap<>();
 bundle.put(Conversation.callbackHistoryMessages, messages);
 bundle.put(Conversation.callbackDeliveredAt, deliveredAt);
 bundle.put(Conversation.callbackReadAt, readAt);
 InternalConfiguration.getOperationTube().onOperationCompletedEx(session.getSelfPeerId(), conversationId, requestId,
     AVIMOperation.CONVERSATION_MESSAGE_QUERY, bundle);
 session.sendUnreadMessagesAck(messages, conversationId);
}

@Override
public void onSessionOpen(AVSession session, int requestId) {
 // 既然已经成功了，就往缓存里面添加一条记录
 AVSessionCacheHelper.getTagCacheInstance().addSession(session.getSelfPeerId(), session.getTag());
 // 这里需要给AVIMClient那边发一个LocalBoardcastMessage
 if (requestId > CommandPacket.UNSUPPORTED_OPERATION) {
  InternalConfiguration.getOperationTube().onOperationCompleted(session.getSelfPeerId(), null, requestId,
      AVIMOperation.CLIENT_OPEN, null);
 }
}

public void cleanUp() {
 updateRealtimeSessionToken("", 0);
 if (pendingMessages != null) {
  pendingMessages.clear();
 }
 if (conversationOperationCache != null) {
  this.conversationOperationCache.clear();
 }
 this.conversationHolderCache.clear();
 MessageReceiptCache.clean(this.getSelfPeerId());
}

private void onAckError(Integer requestKey, Messages.AckCommand command, Message m) {
 Operation op = session.conversationOperationCache.poll(requestKey);
 if (op.operation == Conversation.AVIMOperation.CLIENT_OPEN.getCode()) {
  session.setSessionStatue(AVSession.Status.Closed);
 }
 Conversation.AVIMOperation operation = Conversation.AVIMOperation.getAVIMOperation(op.operation);
 int code = command.getCode();
 int appCode = (command.hasAppCode() ? command.getAppCode() : 0);
 String reason = command.getReason();
 AVException error = new AVIMException(code, appCode, reason);
 InternalConfiguration.getOperationTube().onOperationCompleted(session.getSelfPeerId(), op.conversationId,
     requestKey, operation, error);
}