xsdlr/react-native-jmessage

更新用户信息

zhangmingnjun opened this issue · 3 comments

zhangmingnjun commented

没有提供更新用户信息的方法，麻烦版主添加，谢谢

zhangmingnjun commented

删除回话的方法也不好使，麻烦版主修改，谢谢

cielu commented

@zhangmingnjun 问题解决了没？？要不，弄个群吧

zhangmingnjun commented

@cielu 安卓的解决了，我自己按照官方的api，凑合写上去了。现在在弄ios版。代码很简单，我直接贴上去吧。
package com.xsdlr.rnjmessage;

import android.app.Activity;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.widget.Toast;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.google.gson.Gson;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;
import com.xsdlr.rnjmessage.model.ConversationIDJSONModel;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import javax.annotation.Nullable;
//import cn.jiguang.api.JCoreInterface;
import cn.jpush.im.android.api.JMessageClient;
import cn.jpush.im.android.api.content.ImageContent;
import cn.jpush.im.android.api.content.MessageContent;
import cn.jpush.im.android.api.content.TextContent;
import cn.jpush.im.android.api.enums.ContentType;
import cn.jpush.im.android.api.enums.ConversationType;
import cn.jpush.im.android.api.event.MessageEvent;
import cn.jpush.im.android.api.event.NotificationClickEvent;
import cn.jpush.im.android.api.model.Conversation;
import cn.jpush.im.android.api.model.GroupInfo;
import cn.jpush.im.android.api.model.Message;
import cn.jpush.im.android.api.model.UserInfo;
import cn.jpush.im.api.BasicCallback;
import cn.jpush.im.android.api.callback.GetUserInfoCallback;
import cn.jpush.im.android.api.callback.GetBlacklistCallback;

/**

  • Created by xsdlr on 2016/12/14.
    */
    public class JMessageModule extends ReactContextBaseJavaModule {

    static boolean isDebug;
    public static final int NOTI_MODE_NO_NOTIFICATION = 0;
    public static final int NOTI_MODE_DEFAULT = 1;
    public static final int NOTI_MODE_NO_SOUND = 2;
    public static final int NOTI_MODE_NO_VIBRATE = 3;
    public static final int NOTI_MODE_SILENCE = 4;

    public JMessageModule(ReactApplicationContext reactContext) {
    super(reactContext);
    }

    @OverRide
    public String getName() {
    return "JMessageModule";
    }

    @nullable
    @OverRide
    public Map<String, Object> getConstants() {
    final Map<String, Object> constants = new HashMap<>();
    constants.put("AppKey", getMetaData("JPUSH_APPKEY"));
    constants.put("MasterSecret", getMetaData("JPUSH_MASTER_SECRET"));
    return constants;
    }
    /**

    • 初始化方法
      /
      @ReactMethod
      public void setupJMessage() {
      JMessageClient.init(this.getReactApplicationContext());
      JMessageClient.registerEventReceiver(this);
      //JCoreInterface.setDebugMode(JMessageModule.isDebug);
      }
      /      *
    • 获得注册id
    • @param promise
      /
      @ReactMethod
      public void getRegistrationID(final Promise promise) {
      Activity context = getCurrentActivity();
      if (context == null) {
      promise.reject(JMessageException.ACTIVITY_NOT_EXIST.getCode(), JMessageException.ACTIVITY_NOT_EXIST);
      return;
      }
      String id = "getRegistrationID";//JCoreInterface.getRegistrationID(context);
      promise.resolve(id);
      }
      /      *
    • 用户是否登录
    • @param promise
      /
      @ReactMethod
      public void isLoggedIn(final Promise promise) {
      UserInfo info = JMessageClient.getMyInfo();
      System.out.println(info);
      boolean isLoggedIn = info != null && info.getUserID() != 0;
      promise.resolve(isLoggedIn);
      }
      /      *
    • 登录
    • @param username 用户名
    • @param password 密码
    • @param promise
      /
      @ReactMethod
      public void login(String username, String password, final Promise promise) {
      final JMessageModule _this = this;
      final ReactApplicationContext reactContext = this.getReactApplicationContext();
      final String userName = username;
      JMessageClient.login(username, password, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String loginDesc) {
      //Toast.makeText(reactContext, loginDesc+"=="+responseCode, Toast.LENGTH_SHORT).show();
      if (responseCode == 0) {
      _this.myInfo(userName,promise);
      } else {
      promise.reject(String.valueOf(responseCode), loginDesc);
      }
      }
      });
      }
      /      *
    • 注册
    • @param username 用户名
    • @param password 密码
    • @param promise
      /
      @ReactMethod
      public void register(String username, String password, final Promise promise) {
      JMessageClient.register(username, password, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String loginDesc) {
      if (responseCode == 0) {
      promise.resolve(String.valueOf(responseCode));
      } else {
      promise.reject(String.valueOf(responseCode), loginDesc);
      }
      }
      });
      }
      /      *
    • 注销
      /
      @ReactMethod
      public void logout(final Promise promise) {
      JMessageClient.logout();
      promise.resolve(null);
      }
      /      *
    • 获得用户信息
    • @param promise
      /
      @ReactMethod
      public void myInfo(String username,final Promise promise) {
      JMessageClient.getUserInfo(username, new GetUserInfoCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc, UserInfo info) {
      if (responseCode == 0) {
      WritableMap result = Arguments.createMap();
      result.putString("username", info.getUserName());
      result.putString("nickname", info.getNickname());
      result.putString("avatar", info.getAvatar());
      result.putInt("gender", messagePropsToInt(Utils.defaultValue(info.getGender(), UserInfo.Gender.unknown)));
      result.putString("genderDesc", messagePropsToString(Utils.defaultValue(info.getGender(), UserInfo.Gender.unknown)));
      result.putDouble("birthday", info.getBirthday());
      result.putString("region", info.getRegion());
      result.putString("signature", info.getSignature());
      result.putString("noteName", info.getNotename());
      result.putString("noteText", info.getNoteText());
      promise.resolve(result);
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 修改用户基本信息（昵称）
    • nickname
    • birthday
    • signature
    • gender
    • region
    • @param promise
      /
      @ReactMethod
      public void updateNickname(String nickname, final Promise promise) {
      final JMessageModule _this = this;
      UserInfo myInfo = JMessageClient.getMyInfo();
      myInfo.setNickname(nickname);
      JMessageClient.updateMyInfo(UserInfo.Field.nickname, myInfo, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc) {
      if (responseCode == 0) {
      promise.resolve(String.valueOf(responseCode));
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 修改用户密码
    • @param promise
      /
      @ReactMethod
      public void updateUserPassword(String oldPassword, String newPassword, final Promise promise) {
      final JMessageModule _this = this;
      JMessageClient.updateUserPassword(oldPassword, newPassword, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc) {
      if (responseCode == 0) {
      promise.resolve(String.valueOf(responseCode));
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 修改用户头像
    • @param promise
      /
      @ReactMethod
      public void updateUserAvatar(String image, final Promise promise) {
      File imageFile = new File(image);
      final JMessageModule _this = this;
      JMessageClient.updateUserAvatar(imageFile, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc) {
      if (responseCode == 0) {
      promise.resolve(String.valueOf(responseCode));
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 发送单聊消息
    • @param username 用户名
    • @param type 消息类型
    • @param data 数据
    • @param promise
      /
      @ReactMethod
      public void sendSingleMessage(String appkey, String username, String type, ReadableMap data, final Promise promise) {
      Conversation conversation = Utils.isEmpty(appkey)
      ? Conversation.createSingleConversation(username)
      : Conversation.createSingleConversation(username, appkey);
      sendMessage(conversation, type, data, promise);
      }
      /      *
    • 发送群聊消息
    • @param groupId 群号
    • @param type 消息类型
    • @param data 数据
    • @param promise
      /
      @ReactMethod
      public void sendGroupMessage(String groupId, String type, ReadableMap data, final Promise promise) {
      long gid;
      try {
      gid = Long.valueOf(groupId);
      } catch (NumberFormatException e) {
      JMessageException ex = JMessageException.ILLEGAL_ARGUMENT_EXCEPTION;
      promise.reject(ex.getCode(), ex.getMessage());
      return;
      }
      Conversation conversation = Conversation.createGroupConversation(gid);
      sendMessage(conversation, type, data, promise);
      }
      /      *
    • 根据会话发送消息
    • @param cid
    • @param type
    • @param data
    • @param promise
      /
      @ReactMethod
      public void sendMessageByCID(String cid, String type, ReadableMap data, final Promise promise) {
      try {
      Conversation conversation = getConversation(cid);
      sendMessage(conversation, type, data, promise);
      } catch (JMessageException e) {
      promise.reject(e.getCode(), e.getMessage());
      }
      }
      /      *
    • 获取会话列表
    • @param promise
      /
      @ReactMethod
      public void allConversations(final Promise promise) {
      List conversations = JMessageClient.getConversationList();
      WritableArray result = Arguments.createArray();
      for (Conversation conversation: conversations) {
      WritableMap conversationMap = transformToWritableMap(conversation);
      result.pushMap(conversationMap);
      }
      promise.resolve(result);
      }
      /      *
    • 获得历史消息
    • @param cid 会话id
    • @param offset 从最新开始的偏移
    • @param limit 数量
    • @param promise
      /
      @ReactMethod
      public void historyMessages(String cid, Integer offset, Integer limit, final Promise promise) {
      Integer _limit = limit <= 0 ? Integer.MAX_VALUE : limit;
      try {
      Conversation conversation = getConversation(cid);
      WritableArray result = Arguments.createArray();
      for (Message message: conversation.getMessagesFromNewest(offset, _limit)) {
      result.pushMap(transformToWritableMap(message));
      }
      promise.resolve(result);
      } catch (JMessageException e) {
      promise.reject(e.getCode(), e.getMessage());
      }
      }
      /      *
    • 清除未读记录数
    • @param cid 会话id
    • @param promise
      /
      @ReactMethod
      public void clearUnreadCount(String cid, final Promise promise) {
      try {
      Conversation conversation = getConversation(cid);
      int unreadCount = conversation.getUnReadMsgCnt();
      if (conversation.resetUnreadCount()) {
      promise.resolve(unreadCount);
      } else {
      promise.reject("", "");
      }
      } catch (JMessageException e) {
      promise.reject(e.getCode(), e.getMessage());
      }
      }
      /      *
    • 删除会话
    • @param cid 会话id
    • @param promise
      /
      @ReactMethod
      public void removeConversation(String cid, final Promise promise) {
      try {
      Conversation conversation = getConversation(cid);
      final ReactApplicationContext reactContext = this.getReactApplicationContext();
      //Toast.makeText(reactContext, conversation.getType()+"", Toast.LENGTH_SHORT).show();
      switch (conversation.getType()) {
      case single:
      UserInfo userInfo = (UserInfo)conversation.getTargetInfo();
      JMessageClient.deleteSingleConversation(userInfo.getUserName());
      break;
      case group:
      GroupInfo groupInfo = (GroupInfo)conversation.getTargetInfo();
      JMessageClient.deleteGroupConversation(groupInfo.getGroupID());
      break;
      }
      promise.resolve(null);
      } catch (JMessageException e) {
      promise.reject(e.getCode(), e.getMessage());
      }
      }
      /      *
    • 加入黑名单
    • @param promise
      /
      @ReactMethod
      public void addUsersToBlacklist(String username, final Promise promise) {
      final JMessageModule _this = this;
      List usernames = new ArrayList();
      usernames.add(username);
      JMessageClient.addUsersToBlacklist(usernames, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc) {
      if (responseCode == 0) {
      promise.resolve(String.valueOf(responseCode));
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 移除黑名单
    • @param promise
      /
      @ReactMethod
      public void delUsersFromBlacklist(String username, final Promise promise) {
      final JMessageModule _this = this;
      List usernames = new ArrayList();
      usernames.add(username);
      JMessageClient.delUsersFromBlacklist(usernames, new BasicCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc) {
      if (responseCode == 0) {
      promise.resolve(String.valueOf(responseCode));
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 获取黑名单列表
    • @param promise
      /
      @ReactMethod
      public void getBlacklist(final Promise promise) {
      JMessageClient.getBlacklist(new GetBlacklistCallback() {
      @OverRide
      public void gotResult(int responseCode, String desc,List blackList) {
      if (responseCode == 0) {
      promise.resolve(blackList.toString());
      } else {
      promise.reject(String.valueOf(responseCode), desc);
      }
      }
      });
      }
      /      *
    • 设置通知提醒方式
    • mode - 通知展示类型，包括：
    • NOTI_MODE_NO_NOTIFICATION 0不展示通知
    • NOTI_MODE_DEFAULT 1展示通知，有声音有震动。
    • NOTI_MODE_NO_SOUND 2展示通知，无声音有震动
    • NOTI_MODE_NO_VIBRATE 3展示通知，有声音无震动
    • NOTI_MODE_SILENCE 4展示通知，无声音无震动
      /
      @ReactMethod
      public void setNotificationMode(int mode,final Promise promise) {
      JMessageClient.setNotificationMode(mode);
      }
      /      *
    • 接收消息事件监听
    • @param event
      */
      public void onEvent(MessageEvent event) {
      Message message = event.getMessage();
      this.getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
      .emit("onReceiveMessage", transformToWritableMap(message));
      }

    /**

    • 点击消息事件监听
    • @param event
      */
      public void onEvent(NotificationClickEvent event) {
      Message message = event.getMessage();
      this.getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
      .emit("onOpenMessage", message);
      }

    private WritableMap transformToWritableMap(Message message) {
    WritableMap result = Arguments.createMap();
    if (message == null) return result;

     result.putString("msgId", Utils.defaultValue(message.getId(), "").toString());
 result.putString("serverMessageId", Utils.defaultValue(message.getServerMessageId(), "").toString());

 WritableMap from = Arguments.createMap();
 from.putString("type", message.getFromType());
 from.putString("name", message.getFromUser().getUserName());
 from.putString("nickname", message.getFromUser().getNickname());
 result.putMap("from", from);

 WritableMap target = Arguments.createMap();
 target.putInt("type", messagePropsToInt(message.getTargetType()));
 target.putString("typeDesc", messagePropsToString(message.getTargetType()));
 switch (message.getTargetType()) {
     case single:
         UserInfo userInfo = (UserInfo)message.getTargetInfo();
         target.putString("name", userInfo.getUserName());
         target.putString("nickname", userInfo.getNickname());
         break;
     case group:
         GroupInfo groupInfo = (GroupInfo)message.getTargetInfo();
         target.putString("name", groupInfo.getGroupName());
         target.putString("nickname", groupInfo.getGroupDescription());
         break;
     default:
         break;
 }
 result.putMap("target", target);
 result.putDouble("timestamp", message.getCreateTime());
 result.putInt("contentType", messagePropsToInt(message.getContentType()));
 result.putString("contentTypeDesc", messagePropsToString(message.getContentType()));
 result.putString("content", message.getContent().toJson());
 return result;

    }

    private WritableMap transformToWritableMap(Conversation conversation) {
    WritableMap result = Arguments.createMap();
    File avatar = conversation.getAvatarFile();
    if (avatar != null) {
    String imageBase64 = Utils.base64Encode(avatar, Bitmap.CompressFormat.PNG);
    result.putString("avatar", imageBase64);
    }
    result.putInt("type", messagePropsToInt(conversation.getType()));
    result.putString("typeDesc", messagePropsToString(conversation.getType()));
    result.putString("title", conversation.getTitle());
    //最后通讯的时间
    result.putString("lastTime",conversation.getLatestMessage().getCreateTime()+"");
    result.putString("laseMessage", getLastMessageContent(conversation));
    result.putInt("unreadCount", conversation.getUnReadMsgCnt());

     ConversationIDJSONModel conversationIDJSONModel = new ConversationIDJSONModel();
 conversationIDJSONModel.setAppkey(conversation.getTargetAppKey());
 conversationIDJSONModel.setType(messagePropsToInt(conversation.getType()));

 switch (conversation.getType()) {
     case single:
         UserInfo userInfo = (UserInfo)conversation.getTargetInfo();
         result.putString("username", userInfo.getUserName());
         result.putString("nickname",userInfo.getNickname());
         conversationIDJSONModel.setId(userInfo.getUserName());
         break;
     case group:
         GroupInfo groupInfo = (GroupInfo)conversation.getTargetInfo();
         result.putDouble("groupId", groupInfo.getGroupID());
         result.putString("groupName", groupInfo.getGroupName());
         conversationIDJSONModel.setId(String.valueOf(groupInfo.getGroupID()));
         break;
     default:
         break;
 }
 Gson gson = new Gson();
 result.putString("id", gson.toJson(conversationIDJSONModel));
 return result;

    }

    private String messagePropsToString(UserInfo.Gender gender) {
    if (gender == null) return null;
    switch (gender) {
    case unknown:
    return "Unknown";
    case male:
    return "Male";
    case female:
    return "Female";
    default:
    return null;
    }
    }

    private String messagePropsToString(ConversationType type) {
    if (type == null) return null;
    switch (type) {
    case single:
    return "Single";
    case group:
    return "Group";
    default:
    return null;
    }
    }

    private String messagePropsToString(ContentType type) {
    if (type == null) return null;
    switch (type) {
    case unknown:
    return "Unknown";
    case text:
    return "Text";
    case image:
    return "Image";
    case voice:
    return "Voice";
    case custom:
    return "Custom";
    case eventNotification:
    return "Event";
    case file:
    return "File";
    case location:
    return "Location";
    default:
    return null;
    }
    }

    private Integer messagePropsToInt(UserInfo.Gender gender) {
    if (gender == null) return null;
    switch (gender) {
    case unknown:
    return 0;
    case male:
    return 1;
    case female:
    return 2;
    default:
    return null;
    }
    }

    private Integer messagePropsToInt(ConversationType type) {
    if (type == null) return null;
    switch (type) {
    case single:
    return 1;
    case group:
    return 2;
    default:
    return null;
    }
    }

    private Integer messagePropsToInt(ContentType type) {
    if (type == null) return null;
    switch (type) {
    case unknown:
    return 0;
    case text:
    return 1;
    case image:
    return 2;
    case voice:
    return 3;
    case custom:
    return 4;
    case eventNotification:
    return 5;
    case file:
    return 6;
    case location:
    return 7;
    default:
    return null;
    }
    }

    private String getMetaData(String name) {
    ReactApplicationContext reactContext = getReactApplicationContext();
    try {
    ApplicationInfo appInfo = reactContext.getPackageManager()
    .getApplicationInfo(reactContext.getPackageName(),
    PackageManager.GET_META_DATA);
    return appInfo.metaData.get(name).toString();
    } catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
    }
    return null;
    }

    private String getLastMessageContent(Conversation conversation) {
    Message message = conversation.getLatestMessage();
    if(message == null) return "";
    switch (message.getContentType()) {
    case unknown:
    return "[未知]";
    case text:
    return ((TextContent)message.getContent()).getText();
    case image:
    return "[图片]";
    case voice:
    return "[语音]";
    case custom:
    return "[自定义]";
    case eventNotification:
    return "[事件]";
    case file:
    return "[文件]";
    case location:
    return "[位置]";
    default:
    return "";
    }
    }

    private void sendMessage(Conversation conversation,
    String contentType, ReadableMap data,
    final Promise promise) {
    String type = contentType.toLowerCase();
    MessageContent content;

     if (conversation == null) {
     JMessageException ex = JMessageException.CONVERSATION_INVALID;
     promise.reject(ex.getCode(), ex.getMessage());
     return;
 }
 switch (type) {
     case "text":
         content = new TextContent(data.getString("text"));
         break;
     case "image":
         try {
             File imageFile = new File(data.getString("image"));
             content = new ImageContent(imageFile);
         } catch (FileNotFoundException e) {
             JMessageException ex = JMessageException.MESSAGE_CONTENT_NULL;
             promise.reject(ex.getCode(), ex.getMessage());
             return;
         }
         break;
     default:
         JMessageException ex = JMessageException.MESSAGE_CONTENT_TYPE_NOT_SUPPORT;
         promise.reject(ex.getCode(), ex.getMessage());
         return;
 }
 final Message message = conversation.createSendMessage(content);
 message.setOnSendCompleteCallback(new BasicCallback() {
     @Override
     public void gotResult(int responseCode, String responseDesc) {
         if (responseCode == 0) {
             promise.resolve(transformToWritableMap(message));
         } else {
             promise.reject(String.valueOf(responseCode), responseDesc);
         }
     }
 });
 JMessageClient.sendMessage(message);

    }

    private Conversation getConversation(String cid) throws JMessageException {
    if (Utils.isEmpty(cid)) {
    throw JMessageException.CONVERSATION_ID_EMPTY;
    }
    ConversationIDJSONModel conversationIDJSONModel;
    try {
    Gson gson = new Gson();
    conversationIDJSONModel = gson.fromJson(cid, ConversationIDJSONModel.class);
    } catch (JsonParseException ex) {
    throw JMessageException.CONVERSATION_INVALID;
    }
    String appkey = conversationIDJSONModel.getAppkey();
    String nameOrGID = conversationIDJSONModel.getId();
    Integer type = conversationIDJSONModel.getType();

     if (Utils.isEmpty(nameOrGID) || type == null) {
     throw JMessageException.CONVERSATION_INVALID;
 }
 Conversation conversation = null;
 switch (type) {
     case 1:
         conversation = Utils.isEmpty(appkey)
                 ? Conversation.createSingleConversation(nameOrGID)
                 : Conversation.createSingleConversation(nameOrGID, appkey);
         break;
     case 2:
         conversation = Conversation.createGroupConversation(Long.valueOf(nameOrGID));
         break;
     default:
         break;
 }
 if (conversation == null) {
     throw JMessageException.CONVERSATION_INVALID;
 }
 return conversation;

    }
    }