modify：添加SoftbusService封装softbus的调用处理

softbus-jdk/SoftbusSession.c

@@ -1023,6 +1023,18 @@ JNIEXPORT jint JNICALL Java_com_jg_softbus_naservice_SessionService_removeSessio
     (*env)->ReleaseStringUTFChars(env, pkgName, pkgNameStr);
     (*env)->ReleaseStringUTFChars(env, sessionName, sessionNameStr);
     return ret;
+}
+JNIEXPORT jstring JNICALL Java_com_jg_softbus_naservice_SessionService_getPeerDeviceId
+  (JNIEnv *env, jobject obj, jint sessionId) {
+        // 保存Java虚拟机的引用
+    (*env)->GetJavaVM(env, &jvm);
+    char *networkId = "default";
+    int ret = GetPeerDeviceId(sessionId, networkId, NETWORK_ID_BUF_LEN);
+    if(networkId != NULL){
+      jstring networkIdStr = (*env)->NewStringUTF(env, networkId); 
+      return networkIdStr;
+    }
+    return NULL;
   }
 
 /*
@@ -1034,8 +1046,8 @@ JNIEXPORT jstring JNICALL Java_com_jg_softbus_naservice_SessionService_getPeerSe
   (JNIEnv *env, jobject obj, jint sessionId) {
     // 保存Java虚拟机的引用
     (*env)->GetJavaVM(env, &jvm);
-    char *sessionName;
-    int ret = GetPeerSessionName(sessionId, sessionName, 256);
+    char *sessionName = "default";
+    int ret = GetPeerSessionName(sessionId, sessionName, 255);
     if(sessionName != NULL){
       jstring sessionNameStr = (*env)->NewStringUTF(env, sessionName); 
       return sessionNameStr;

softbus-jdk/com_jg_softbus_naservice_SessionService.h

@@ -89,6 +89,14 @@ JNIEXPORT jint JNICALL Java_com_jg_softbus_naservice_SessionService_removeSessio
 
 /*
  * Class:     com_jg_softbus_naservice_SessionService
+ * Method:    getPeerDeviceId
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jg_softbus_naservice_SessionService_getPeerDeviceId
+  (JNIEnv *, jobject, jint);
+  
+/*
+ * Class:     com_jg_softbus_naservice_SessionService
  * Method:    getPeerSessionName
  * Signature: (I)Ljava/lang/String;
  */

softbus-sdk/src/main/java/com/jg/softbus/model/SessionInfo.java

@@ -6,34 +6,41 @@ public class SessionInfo {
     /**
      * sessionId
      */
-    private Integer sessionId;
+    private final Integer sessionId;
     /**
      * sessionName
      */
-    private String sessionName;
-
-    public SessionInfo() {
-    }
+    private final String sessionName;
+    /**
+     * 设备网络id
+     */
+    private final String networkId;
+    /**
+     * session是否打开
+     */
+    private final Boolean isOpen;
 
-    public SessionInfo(Integer sessionId, String sessionName) {
+    public SessionInfo(Integer sessionId, String sessionName, String networkId, Boolean isOpen) {
         this.sessionId = sessionId;
         this.sessionName = sessionName;
+        this.networkId = networkId;
+        this.isOpen = isOpen;
     }
 
     public Integer getSessionId() {
         return sessionId;
     }
 
-    public void setSessionId(Integer sessionId) {
-        this.sessionId = sessionId;
-    }
-
     public String getSessionName() {
         return sessionName;
     }
 
-    public void setSessionName(String sessionName) {
-        this.sessionName = sessionName;
+    public String getNetworkId() {
+        return networkId;
+    }
+
+    public boolean isOpen() {
+        return isOpen;
     }
 
     @Override
@@ -41,12 +48,13 @@ public class SessionInfo {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         SessionInfo that = (SessionInfo) o;
-        return Objects.equals(sessionId, that.sessionId) && Objects.equals(sessionName, that.sessionName);
+        return Objects.equals(sessionId, that.sessionId) && Objects.equals(sessionName, that.sessionName)
+                && Objects.equals(networkId, that.networkId);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(sessionId, sessionName);
+        return Objects.hash(sessionId, sessionName, networkId);
     }
 
     @Override
@@ -54,6 +62,7 @@ public class SessionInfo {
         return "SessionInfo{" +
                 "sessionId=" + sessionId +
                 ", sessionName='" + sessionName + '\'' +
+                ", networkId='" + networkId + '\'' +
                 '}';
     }
 }

softbus-sdk/src/main/java/com/jg/softbus/naservice/SessionService.java

@@ -45,6 +45,7 @@ public class SessionService implements ISessionListener, Closeable {
     public SessionService(String pkgName, String sessionName) {
         this(pkgName, sessionName, UUID.randomUUID().toString().replaceAll("-",""));
     }
+
     public SessionService(String pkgName, String sessionName, String groupId) {
         this.pkgName = pkgName;
         this.sessionName = sessionName;
@@ -201,7 +202,7 @@ public class SessionService implements ISessionListener, Closeable {
      * 关闭会话
      * @param sessionId
      */
-    private native void closeSession(int sessionId);
+    public native void closeSession(int sessionId);
 
     /**
      * 删除会话服务
@@ -215,11 +216,19 @@ public class SessionService implements ISessionListener, Closeable {
     public int onSessionOpened(int sessionId, int result) {
         if(result == 0) {
            String sessionName = getPeerSessionName(sessionId);
-           connSessions.addSession(new SessionInfo(sessionId, sessionName));
+           String networkId = getPeerDeviceId(sessionId);
+           connSessions.addSession(new SessionInfo(sessionId, sessionName, networkId, true));
         }
         return 0;
     }
 
+    /**
+     * 获取设备id
+     * @param sessionId
+     * @return
+     */
+    private native String getPeerDeviceId(int sessionId);
+
     public String getSessionName() {
         return sessionName;
     }

softbus-sdk/src/main/java/com/jg/softbus/service/ISoftbusService.java

@@ -2,20 +2,112 @@ package com.jg.softbus.service;
 
 import com.jg.softbus.discovery.PublishInfo;
 import com.jg.softbus.discovery.SubscribeInfo;
+import com.jg.softbus.discovery.callback.IDiscoveryCallback;
+import com.jg.softbus.discovery.callback.IPublishCallback;
+import com.jg.softbus.manager.SessionManager;
+import com.jg.softbus.model.SessionInfo;
+import com.jg.softbus.session.SessionAttribute;
+import com.jg.softbus.session.StreamData;
+import com.jg.softbus.session.StreamFrameInfo;
+import com.jg.softbus.session.callback.IFileReceiveListener;
+import com.jg.softbus.session.callback.IFileSendListener;
+
+import java.io.IOException;
+import java.util.List;
 
 public interface ISoftbusService {
     /**
      * 启动服务
-     * @param pkgName
-     * @param sessionName
-     * @param publishInfo
-     * @param subscribeInfo
+     * 基于旧有API启动服务
+     * @return
+     */
+    boolean start() throws Exception;
+
+    /**
+     * 启动服务
+     * 基于新的API启动服务
+     * @return
+     * @throws Exception
+     */
+    boolean startNew() throws Exception;
+
+    /**
+     * 获取session管理器
+     * @return
+     */
+    SessionManager getSessionManager();
+    /**
+     * 发送消息到所有在线终端
+     * @param message
+     * @return
+     * @throws Exception
+     */
+    boolean sendMsg(String message) throws Exception;
+
+    /**
+     * 发送数据到指定session
+     * @param data
+     * @param session
+     * @return
+     * @throws Exception
+     */
+    boolean sendMsg(byte[] data, SessionInfo session) throws Exception;
+    /**
+     * 发送消息到指定终端
+     * @param message
+     * @param sessionId
+     * @return
+     * @throws Exception
+     */
+    boolean sendMsg(String message, int sessionId) throws Exception;
+
+    /**
+     * 发送数据到指定session
+     * @param data
+     * @param session
+     * @param attr
+     * @return
+     * @throws Exception
+     */
+    boolean sendMsg(byte[] data, SessionInfo session, SessionAttribute attr) throws Exception;
+
+    /**
+     * 发送流到指定session
+     * @param sessionId
+     * @param data
+     * @param ext
+     * @param param
+     * @return
+     */
+    boolean sendStream(int sessionId, StreamData data, StreamData ext, StreamFrameInfo param) throws Exception;
+
+    /**
+     * 设置文件发送监听器
+     * @param fileSendListener
+     * @throws Exception
+     */
+    void setFileSendListener(IFileSendListener fileSendListener) throws Exception;
+    /**
+     * 发送文件到指定session
+     * @param sessionId
+     * @param sFileList
+     * @param dFileList
+     * @param fileCnt
+     * @return
+     */
+    boolean sendFile(int sessionId, String[] sFileList, String[] dFileList, int fileCnt) throws Exception;
+
+    /**
+     * 设置文件接收监听器
+     * @param fileReceiveListener
+     * @param directory
      * @return
+     * @throws Exception
      */
-    boolean start(PublishInfo publishInfo, SubscribeInfo subscribeInfo);
+    void setFileReceiveListener(IFileReceiveListener fileReceiveListener, String directory) throws Exception;
     /**
      * 停止服务
      * @return
      */
-    boolean stopService();
+    boolean stopService() throws IOException;
 }

softbus-sdk/src/main/java/com/jg/softbus/service/SoftbusService.java

@@ -1,29 +1,249 @@
 package com.jg.softbus.service;
 
-import com.jg.softbus.discovery.PublishInfo;
-import com.jg.softbus.discovery.SubscribeInfo;
+import com.jg.softbus.manager.SessionManager;
+import com.jg.softbus.model.SessionInfo;
+import com.jg.softbus.naservice.LNNService;
+import com.jg.softbus.naservice.PublishService;
+import com.jg.softbus.naservice.SessionService;
+import com.jg.softbus.naservice.SubscribeService;
+import com.jg.softbus.session.SessionAttribute;
+import com.jg.softbus.session.StreamAttr;
+import com.jg.softbus.session.StreamData;
+import com.jg.softbus.session.StreamFrameInfo;
+import com.jg.softbus.session.callback.IFileReceiveListener;
+import com.jg.softbus.session.callback.IFileSendListener;
+import com.jg.softbus.session.enums.LinkType;
+import com.jg.softbus.session.enums.SessionType;
+import com.jg.softbus.session.enums.StreamType;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public class SoftbusService implements ISoftbusService {
     /**
-     * 服务包名
+     * 启动参数
+     */
+    private final SoftbusServiceStartParam startParam;
+
+    /**
+     * session服务
+     */
+    private SessionService sessionService;
+    /**
+     * 发布服务
+     */
+    private PublishService publishService;
+    /**
+     * 订阅服务
      */
-    private final String pkgName;
+    private SubscribeService subscribeService;
     /**
-     * session名称
+     * 组网服务
      */
-    private final String sessionName;
+    private LNNService lnnService;
+    /**
+     * 启动标识
+     */
+    private AtomicBoolean started = new AtomicBoolean(false);
 
-    public SoftbusService(String pkgName, String sessionName) {
-         this.pkgName = pkgName;
-         this.sessionName = sessionName;
+    public SoftbusService(SoftbusServiceStartParam startParam) {
+         this.startParam = startParam;
     }
     @Override
-    public boolean start(PublishInfo publishInfo, SubscribeInfo subscribeInfo) {
+    public boolean start() throws Exception {
+        if (started.compareAndSet(false, true)) {
+            startSessionServer();
+            publishService = new PublishService(startParam.getPkgName());
+            if(Objects.nonNull(startParam.getPublishCallback())) {
+                publishService.publishService(startParam.getPublishInfo(), startParam.getPublishCallback());
+            } else {
+                publishService.publishService(startParam.getPublishInfo());
+            }
+            subscribeService = new SubscribeService(startParam.getPkgName());
+            if(Objects.nonNull(startParam.getDiscoveryCallback())) {
+                subscribeService.discoveryStart(startParam.getSubscribeInfo(), startParam.getDiscoveryCallback());
+            } else {
+                subscribeService.discoveryStart(startParam.getSubscribeInfo());
+            }
+
+        }
+        return started.get();
+    }
+
+    @Override
+    public boolean startNew() throws Exception {
+        if (started.compareAndSet(false, true)) {
+            startSessionServer();
+            publishService = new PublishService(startParam.getPkgName());
+            if(Objects.nonNull(startParam.getPublishCb())) {
+                publishService.publishLNN(startParam.getPublishInfo(), startParam.getPublishCb());
+            } else {
+                publishService.publishLNN(startParam.getPublishInfo());
+            }
+            subscribeService = new SubscribeService(startParam.getPkgName());
+            if(Objects.nonNull(startParam.getRefreshCallback())) {
+                subscribeService.refreshLNN(startParam.getSubscribeInfo(), startParam.getRefreshCallback());
+            } else {
+                subscribeService.refreshLNN(startParam.getSubscribeInfo());
+            }
+        }
+        return started.get();
+    }
+
+    @Override
+    public SessionManager getSessionManager() {
+        if(sessionService.getSessionManager()!=null) {
+            return sessionService.getSessionManager();
+        }
+        return null;
+    }
+
+    @Override
+    public boolean sendMsg(String message) throws Exception {
+        if(message == null || message.isEmpty()) {
+            throw new Exception("message cannot be null, invalid param.");
+        }
+        if(started.get()) {
+            byte[] data = message.getBytes(StandardCharsets.UTF_8);
+            if(sessionService.getSessionManager()!=null && sessionService.getSessionManager().getSessions() != null
+            && !sessionService.getSessionManager().getSessions().isEmpty()) {
+                boolean rs = true;
+                for (SessionInfo session: sessionService.getSessionManager().getSessions()){
+                    rs = sessionService.sendMessage(session.getSessionId(), message, message.length()) == 0;
+                }
+                return rs;
+            }
+        }
         return false;
     }
 
+    /**
+     * 发送消息
+     * @param data
+     * @param session
+     * @return
+     * @throws Exception
+     */
     @Override
-    public boolean stopService() {
+    public boolean sendMsg(byte[] data, SessionInfo session) throws Exception {
+        return sendMsg(data, session, defaultSessionAttr());
+    }
+
+    private SessionAttribute defaultSessionAttr() {
+        SessionAttribute attr = new SessionAttribute();
+        attr.setDataType(SessionType.TYPE_BYTES.valueOf());
+        attr.setLinkType(new LinkType[]{LinkType.LINK_TYPE_WIFI_WLAN_2G});
+        attr.setLinkTypeNum(attr.getLinkType().length);
+        attr.setAttr(new StreamAttr(StreamType.RAW_STREAM.valueOf()));
+        return attr;
+    }
+
+    /**
+     * 开启session
+     * @param session
+     * @param attr
+     * @throws Exception
+     */
+    private void openSession(SessionInfo session, SessionAttribute attr) throws Exception {
+        sessionService.openSession(session.getSessionId(), session.getNetworkId(), attr);
+        try {
+            TimeUnit.MILLISECONDS.sleep(300);
+        } catch (InterruptedException ignored) {
+
+        }
+    }
+
+    /**
+     * 关闭session
+     */
+    private void closeSession(int sessionId) {
+        sessionService.closeSession(sessionId);
+        try {
+            TimeUnit.MILLISECONDS.sleep(300);
+        } catch (InterruptedException ignored) {
+
+        }
+    }
+
+    @Override
+    public boolean sendMsg(byte[] data, SessionInfo session, SessionAttribute attr) throws Exception {
+        boolean rs = true;
+        if(!session.isOpen()) {
+            openSession(session, attr);
+        }
+        int ret = sessionService.sendBytes(session.getSessionId(), data, data.length);
+        rs = ret == 0;
+        if (!rs) {
+            System.out.println("message send failed.");
+            throw new Exception(String.format("the message send to %s failed!", session.getNetworkId()));
+        }
+        return rs;
+    }
+
+    @Override
+    public boolean sendStream(int sessionId, StreamData data, StreamData ext, StreamFrameInfo param) throws Exception {
+        if(Objects.nonNull(getSessionManager()) && Objects.nonNull(getSessionManager().getSession(sessionId))) {
+            return sessionService.sendStream(sessionId, data, ext, param) == 0;
+        }
+        throw new Exception("SessionId is valid.");
+    }
+
+    @Override
+    public void setFileSendListener(IFileSendListener fileSendListener) throws Exception {
+        sessionService.setFileSendListener(fileSendListener);
+    }
+
+    @Override
+    public boolean sendFile(int sessionId, String[] sFileList, String[] dFileList, int fileCnt) throws Exception {
+        if(Objects.nonNull(getSessionManager()) && Objects.nonNull(getSessionManager().getSession(sessionId))) {
+            return sessionService.sendFile(sessionId, sFileList, dFileList, fileCnt) == 0;
+        }
+        throw new Exception("SessionId is valid.");
+    }
+
+    @Override
+    public void setFileReceiveListener(IFileReceiveListener fileReceiveListener, String directory) throws Exception {
+        sessionService.setFileReceiveListener(fileReceiveListener, directory);
+    }
+
+    @Override
+    public boolean sendMsg(String message, int sessionId) throws Exception {
+        if(message == null || message.isEmpty()) {
+            throw new Exception("message cannot be null, invalid param.");
+        }
+        if(sessionService.getSessionManager()!=null && sessionService.getSessionManager().getSessions() != null
+                && !sessionService.getSessionManager().getSessions().isEmpty()) {
+           SessionInfo session = sessionService.getSessionManager().getSession(sessionId);
+           if(Objects.isNull(session)) {
+               return false;
+           }
+           return sendMsg(message.getBytes(StandardCharsets.UTF_8), session);
+        }
         return false;
     }
+
+    private void startSessionServer() throws Exception {
+        sessionService = new SessionService(startParam.getPkgName(), startParam.getSessionName());
+        sessionService.createSessionServer();
+    }
+
+    @Override
+    public boolean stopService() throws IOException {
+        if (started.compareAndSet(true, false)) {
+            //停止处理有关业务逻辑
+            if(Objects.nonNull(subscribeService)) {
+                subscribeService.close();
+            }
+            if(Objects.nonNull(publishService)) {
+                publishService.close();
+            }
+            if(Objects.nonNull(sessionService)) {
+                sessionService.close();
+            }
+        }
+        return true;
+    }
 }

softbus-sdk/src/main/java/com/jg/softbus/service/SoftbusServiceStartParam.java

@@ -0,0 +1,104 @@
+package com.jg.softbus.service;
+
+import com.jg.softbus.discovery.PublishInfo;
+import com.jg.softbus.discovery.SubscribeInfo;
+import com.jg.softbus.discovery.callback.IDiscoveryCallback;
+import com.jg.softbus.discovery.callback.IPublishCallback;
+import com.jg.softbus.discovery.callback.IPublishCb;
+import com.jg.softbus.discovery.callback.IRefreshCallback;
+import com.jg.softbus.session.callback.ISessionListener;
+
+/**
+ * 构建softbus服务启动参数
+ */
+public class SoftbusServiceStartParam {
+    /**
+     * 服务包名
+     */
+    private final String pkgName;
+    /**
+     * 发布的session服务的名称
+     */
+    private final String sessionName;
+    /**
+     * 发布内容
+     */
+    private final PublishInfo publishInfo;
+    /**
+     * 订阅内容
+     */
+    private final SubscribeInfo subscribeInfo;
+
+    public SoftbusServiceStartParam(String pkgName, String sessionName, PublishInfo publishInfo, SubscribeInfo subscribeInfo) {
+        this.pkgName = pkgName;
+        this.sessionName = sessionName;
+        this.publishInfo = publishInfo;
+        this.subscribeInfo = subscribeInfo;
+    }
+
+
+    /**
+     * 发布回调接口
+     */
+    private IPublishCallback publishCallback;
+    /**
+     * 发布回调接口(发布新接口使用)
+     */
+    private IPublishCb publishCb;
+    /**
+     * 订阅回调接口
+     */
+    private IDiscoveryCallback discoveryCallback;
+    /**
+     * 订阅回调（订阅新接口使用）
+     */
+    private IRefreshCallback refreshCallback;
+
+    public String getPkgName() {
+        return pkgName;
+    }
+
+    public String getSessionName() {
+        return sessionName;
+    }
+
+    public PublishInfo getPublishInfo() {
+        return publishInfo;
+    }
+
+    public SubscribeInfo getSubscribeInfo() {
+        return subscribeInfo;
+    }
+
+    public IPublishCallback getPublishCallback() {
+        return publishCallback;
+    }
+
+    public void setPublishCallback(IPublishCallback publishCallback) {
+        this.publishCallback = publishCallback;
+    }
+
+    public IDiscoveryCallback getDiscoveryCallback() {
+        return discoveryCallback;
+    }
+
+    public void setDiscoveryCallback(IDiscoveryCallback discoveryCallback) {
+        this.discoveryCallback = discoveryCallback;
+    }
+
+    public IPublishCb getPublishCb() {
+        return publishCb;
+    }
+
+    public void setPublishCb(IPublishCb publishCb) {
+        this.publishCb = publishCb;
+    }
+
+    public IRefreshCallback getRefreshCallback() {
+        return refreshCallback;
+    }
+
+    public void setRefreshCallback(IRefreshCallback refreshCallback) {
+        this.refreshCallback = refreshCallback;
+    }
+}

softbus-sdk/src/main/java/com/jg/softbus/session/enums/SessionType.java

@@ -22,7 +22,7 @@ public enum SessionType {
         this.value = value;
     }
 
-    public Integer valueOf(){
+    public int valueOf(){
         return this.value;
     }
 

softbus-sdk/src/main/java/com/jg/softbus/session/enums/StreamType.java

@@ -24,7 +24,7 @@ public enum StreamType {
         this.value = value;
     }
 
-    public Integer valueOf() {
+    public int valueOf() {
         return this.value;
     }