smgp.java

电信小灵通短信网关通讯协议SMGP的JAVA语言API开发包源代码

package com.ut.smgp.api;

import com.ut.smgp.api.logic.*;
import com.ut.smgp.api.structure.*;
import com.ut.smgp.api.configure.*;
import com.ut.smgp.api.thread.*;

import java.util.*;
import java.io.*;

import java.net.Socket;
public class SMGP {
  private initStruct init=new initStruct();   //收发或接收初始化数据
  private initStruct initSend=new initStruct();   //发送初始化数据
  private socketStruct con=new socketStruct();  //接收或收发端口
  private socketStruct conSend=new socketStruct();  //发送端口
  private smgpLogic smgp=new smgpLogic();
  private  activeTestThread active=null;   //0:接收或收发activeTest;  1:发送activeTest
  private  activeTestThread activeSend=null;
  private  deliverThread deliver=null;
  private deliverVector deliverQueue=new deliverVector();
  private String deliverLock="0";//记录当前接收端口的状态，0－网络正常，其余网络错误
  //private Vector msgQueue=new Vector();  //消息接收队列
  //private Vector reportQueue=new Vector();  //状态报告接收队列
  public SMGP() {
  }
  /********************************************************
   * 设置通讯连接
   *
   */
  public void setSocket(socketStruct socket)
  {
    this.con=socket;
  }

  /**********************************************************
   * 系统运行参数初始化
   * @param fileName 配置文件的位置
   * @return int  0 初始化正确； 其余 初始化失败代码
   */
  public int initSMGPAPI()
  {
    return initSMGPAPI("../config/smgpc.ini");
  }
  public int initSMGPAPI(String initFile)
  {
    init=smgp.initApi(initFile);
    if(init==null)
    {
        init=new initStruct();
        return 1;
    }
    initSend.init(init); //初始化发送初始结构
    initSend.setLoginMode(0);
    return 0;
  }

  /*********************************************************************
   *
   * 根据用户的配置登录系统
   *
   * activeMode :  1:send  2:receive
   *
   */
  private int login(int activeMode)
  {
    int result=0;



  /*  try{
     if(deliver!=null) deliver.join();
     if(activeSend!=null) activeSend.join();
     if(active!=null) active.join();
    }catch(InterruptedException e){System.out.println("SMGP.login:"+e);}*/

    if(init.getServiceMode()==1)
    {//收发公用收发类型接口
      init.setLoginMode(2); //设置收发登录模式
      try{
       con.socket = new Socket(init.getServerIp(), init.getServerPort());
       con.socket.setSoTimeout(init.getRequestTimeOut());
      }catch(Exception e)
      {System.out.println(e);
        return configure.ERROR_CONNECT_FAILED;
      }
       result=smgp.login(init,con);
      if(result==0)
      {//登录成功
        //建立active_test进程
        if(active!=null) active.setCtl(1);//中止进程
        try{
           if(active!=null) active.join();
        }catch(InterruptedException e){System.out.println("SMGP.login:"+e);}
        active = new activeTestThread(con, init,deliverQueue,2);
        active.start();
        //{//建立接收信息的进程
        if(deliver!=null) deliver.setCtl(1);//中止进程
        try{
           if(deliver!=null) deliver.join();
        }catch(InterruptedException e){System.out.println("SMGP.login:"+e);}
         deliver=new deliverThread(active,init,deliverQueue,deliverLock);
         deliver.start();
       }
    }
    else
    {// =2 或其它为“收发分别用独立的接收接口和发送接口”
      if(activeMode==1)
      {//建立发送端口
        initSend.setLoginMode(0); //设置发送登录模式
        try{
          conSend.socket = new Socket(initSend.getServerIp(), initSend.getServerPort());
          conSend.socket.setSoTimeout(initSend.getRequestTimeOut());
        }catch(Exception e)
        {
          System.out.println(e);
          return configure.ERROR_CONNECT_FAILED;
        }
        result=smgp.login(initSend,conSend);
        if(result==0)
        {//登录成功
          //建立active_test进程
          if(activeSend!=null) activeSend.setCtl(1);//中止进程
          try{
            if(activeSend!=null) activeSend.join();
          }catch(InterruptedException e){System.out.println("SMGP.login:"+e);}
          activeSend = new activeTestThread(conSend, initSend,deliverQueue,0);
          activeSend.start();
         }
      }
      else if(activeMode==2)
      {//建立接收端口
        init.setLoginMode(1); //设置接收登录模式
        try{
          con.socket = new Socket(init.getServerIp(), init.getServerPort());
          con.socket.setSoTimeout(init.getRequestTimeOut());
       }catch(Exception e)
       {
         System.out.println(e);
         return configure.ERROR_CONNECT_FAILED;
       }
       result=smgp.login(init,con);
       if(result==0)
       {//登录成功
         //建立active_test进程
         if(active!=null) active.setCtl(1);//中止进程
         try{
            if(active!=null) active.join();
         }catch(InterruptedException e){System.out.println("SMGP.login:"+e);}
         active = new activeTestThread(con, init,deliverQueue,1);
         active.start();
         //{//建立接收信息的进程
         if(deliver!=null) deliver.setCtl(1);//中止进程
         try{
            if(deliver!=null) deliver.join();
         }catch(InterruptedException e){System.out.println("SMGP.login:"+e);}
          deliver=new deliverThread(active,init,deliverQueue,deliverLock);
          deliver.start();
        }
       }
    }

    return result;
  }

  /********************************************************************
   *
   * 发送单条信息
   *
   */
  public int SMGPSendSingle(submitStruct submit)
  {
     //判断连接是否建立，若没有建立则登录
     int result=0;
     //if(init.getServiceMode()==1&&(con.socket==null||con.socket.isClosed()))
     if(init.getServiceMode()==1&&con.socket==null)
     {
       result=login(0);
       if (result != 0) {
         con.socket = null;
         return result;
       }
     }
     if(initSend.getServiceMode()==2&&conSend.socket==null)
     {
       result=login(1);
       if (result != 0) {
         conSend.socket = null;
         return result;
       }
     }
    if(init.getServiceMode()!=1&&init.getServiceMode()!=2) return 1;

    if(init.getServiceMode()==1)
    {
      con = active.getConnection();
      result=smgp.sendSingle(init,con,submit,deliverQueue,2);
      if(result==configure.ERROR_CONNECT_FAILED)
      {//重新登录
        result=login(0);
        if(result!=0)
         {
           con.socket=null;
           return result;
         }
         active.setSocket(con);
         smgp.sendSingle(init,con,submit,deliverQueue,2); //send again
      }
    }
    else //if(init.getServiceMode()==2)
    {
      conSend = activeSend.getConnection();
      result=smgp.sendSingle(initSend,conSend,submit,deliverQueue,0);
      if(result==configure.ERROR_CONNECT_FAILED)
      {//重新登录
        result=login(1);
        if(result!=0)
        {
          conSend.socket=null;
          return result;
        }
         activeSend.setSocket(conSend);
        result=smgp.sendSingle(initSend,conSend,submit,deliverQueue,0); //send again
      }
    }
    return result;
  }

  /********************************************************************
   *
   * 群发信息
   *
   */
  public int[] SMGPSendMulti(submitStruct[] submit,int timeout)
  {
    //判断连接是否建立，若没有建立则登录
    if(submit==null)
      return null;
    int[] allResult=new int[submit.length];
    int result=0;
    if(init.getServiceMode()==1&&(con.socket==null))
    {
      result=login(0);
      for(int i=0;i<allResult.length;i++)
       allResult[i]=result;
      if (result != 0) {
        con.socket = null;
        return allResult;
      }
    }
    if(initSend.getServiceMode()==2&&(conSend.socket==null))
    {
      result=login(1);
      for(int i=0;i<allResult.length;i++)
       allResult[i]=result;
      if (result != 0) {
        conSend.socket = null;
        return allResult;
      }
    }

   if(init.getServiceMode()!=1&&init.getServiceMode()!=2)
     for(int i=0;i<allResult.length;i++)
       allResult[i]=1;

   if(init.getServiceMode()==1)
   {
     con = active.getConnection();
     allResult=smgp.sendMulti(init,con,submit,deliverQueue,timeout,2);
     if(result==configure.ERROR_CONNECT_FAILED)
     {//重新登录
       result=login(0);
       for(int i=0;i<allResult.length;i++)
       allResult[i]=result;
       if(result!=0)
        {
          con.socket=null;
          return allResult;
        }
        active.setSocket(con);
        smgp.sendMulti(init,con,submit,deliverQueue,timeout,2); //send again
     }
   }
   else //if(init.getServiceMode()==2)
   {
     conSend = activeSend.getConnection();
     allResult=smgp.sendMulti(initSend,conSend,submit,deliverQueue,timeout,0);
     if(result==configure.ERROR_CONNECT_FAILED)
     {//重新登录
       result=login(1);
       for(int i=0;i<allResult.length;i++)
       allResult[i]=result;
       if(result!=0)
       {
         conSend.socket=null;
         return allResult;
       }
        activeSend.setSocket(conSend);
       allResult=smgp.sendMulti(initSend,conSend,submit,deliverQueue,timeout,0); //send again
     }
   }
   return allResult;
  }

  /*****************************************************************************
   *
   * 获取接收队列的短消息
   *
   */

 public deliverMsg SMGPDeliver(int timeout)
 {
   //判断连接是否建立，若没有建立则登录
     int result=0;
     deliverMsg msg=new deliverMsg();
     if(init.getServiceMode()==1&&this.con.socket==null)
     {
       result=login(0);
       if ( result!= 0)
       {
         msg.setResult(result);
         msg.setDeliver(new deliverStruct[0]);
         return msg;
       }
     }

     if(init.getServiceMode()!=1&&this.con.socket==null)
     {
       result=login(2);
       if ( result!= 0)
       {
         msg.setResult(result);
         msg.setDeliver(new deliverStruct[0]);
         return msg;
       }
     }


     if(con.socket==null)
     {
       result=configure.ERROR_CONNECT_FAILED;
       msg.setResult(result);
        msg.setDeliver(new deliverStruct[0]);
        return msg;
      // return result;
     }

   deliverStruct[] deliverLine;
   synchronized(deliverQueue)
   {//接收数据
       deliverLine = new deliverStruct[deliverQueue.size()];
       for (int i = 0; i < deliverLine.length; i++) {
         deliverLine[i] = new deliverStruct();
         deliverLine[i] = deliverQueue.get(i);
       }
       deliverQueue.clear();
   }
   if(deliverLine.length==0)
   { //没有数据，等待接收
     deliver.setTimeOut(timeout);
     deliver.setCtl(3);//告诉deliver，这是用户唤醒的，不允许再度睡眠,以避免死锁
     deliver.interrupt(); //再次启动
     synchronized(deliverLock)
     {//等待用户设定的时间
       result=Integer.parseInt(deliverLock);//获取接收状态
       deliverLock = "0";
     }
     deliver.setCtl(2);//告诉deliver，网络不通，可以睡觉了
     synchronized(deliverQueue)
     { //再次接收数据
         deliverLine = new deliverStruct[deliverQueue.size()];
         for (int i = 0; i < deliverLine.length; i++) {
           deliverLine[i] = new deliverStruct();
           deliverLine[i] = deliverQueue.get(i);
         }
         deliverQueue.clear();
     }
   }
  /* timeout=1000000000;
   try{
       if (deliverLine.length == 0) {
       deliver.setDeliv(Thread.currentThread());
       if(timeout!=0)
         Thread.sleep(timeout);
       else
         Thread.yield();
     }
    }
    catch(InterruptedException interruptedexception)
     {
        System.err.println("Failed to sleep: " + interruptedexception);
     }*/
   //return result;
   msg.setResult(result);
   msg.setDeliver(deliverLine);
    return msg;

  // return deliverLine;
 }
/* private int getDeliverLock(int i)
 {
   //int i=Integer.parseInt(deliverLock);
   switch(i)
    {
      case 0:
        return 0;
      case configure.ERROR_CONNECT_FAILED:
        return configure.ERROR_CONNECT_FAILED;
      case configure.ERROR_RECEIVE_FAILED:
        return configure.ERROR_RECEIVE_FAILED;
      case configure.ERROR_LOGIN_FAILED:
        return configure.ERROR_LOGIN_FAILED;
   }
   return configure.ERROR_RECEIVE_FAILED;
 }*/
 /********************************************************************************
  *
  * 断开连接
  *
  */
 public int SMGPDisconnect()
 {
   int result=0;
   if(init.getServiceMode()==1)
   {
     smgp.exit(con, init, deliverQueue, 2);
   }
   if(init.getServiceMode()==2)
   {
     smgp.exit(con, init, deliverQueue,1);
     smgp.exit(conSend, initSend, deliverQueue,0);
   }
     if(deliver!=null) deliver.setCtl(1);//中止进程
     if(active!=null) active.setCtl(1);//中止进程
     if(activeSend!=null) activeSend.setCtl(1);//中止进程


     try{
      if(deliver!=null&&deliver.isAlive()) deliver.join();
     }catch(InterruptedException e){System.out.println("SMGP.SMGPDisconnect:"+e);}

     try{
       if (activeSend != null&&activeSend.isAlive())
         activeSend.join();
     }catch(InterruptedException e)
     {System.out.println("SMGP.SMGPDisconnect:"+e);}

      try{
        if(active!=null&&active.isAlive()) active.join();
      }catch(InterruptedException e)
      {System.out.println("SMGP.SMGPDisconnect:"+e);}

      try{
        if(con.socket!=null)
         {
           con.socket.close();
           con.socket=null;
         }
      }catch(IOException e)
      {System.out.println("SMGP.SMGPDisconnect"+e);}

      try{
        if (conSend.socket != null)
          conSend.socket.close();
          conSend.socket=null;
      }catch(IOException e)
      {System.out.println("SMGP.SMGPDisconnect"+e);}

   return result;
 }
 /*********************************************************************************
  *
  * 发送active
  *
  */
 public int SMGPActiveTest()
 {
   if(con.socket!=null)  //测试接收或收发端口
     return smgp.activeTest(con,init,deliverQueue,2);
   else if(conSend.socket!=null)  //测试发送端口
     return smgp.activeTest(conSend,initSend,deliverQueue,0);
   else  //无可用端口，测试失败
     return 1;
 }


  public static void main(String[] args) throws InterruptedException
  {
     SMGP smgp=new SMGP();
     smgp.initSMGPAPI("e:\\smgpc.ini");
  }

}