@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;
```
}
}

更新用户信息 #2

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions