示例#1
0
  /**
   * @param actionID
   * @param channel
   * @return
   */
  public boolean kHangUp(String actionID, String channel) {
    boolean back = false;
    String cause = "16";

    String callParam =
        ("Action: kHangup"
            + CRLF
            + "ActionID: "
            + actionID
            + CRLF
            + "Channel: "
            + channel
            + CRLF
            + "Cause: "
            + cause
            + CRLF
            + CRLF);

    this.changeInfo(callParam);

    HangupAction hangupAct = new HangupAction();

    hangupAct.setActionId(actionID);
    hangupAct.setChannel(channel);

    try {
      managerConnection.sendAction(hangupAct, sendCB);
    } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
      Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
    }

    return back;
  }
示例#2
0
  // register a conference room for user. return true if success.
  public static boolean verifyMeetMeRoom(
      String roomNumber, String witness, ManagerConnection managerConnection) throws Exception {
    boolean validRoom = false;
    OriginateAction originateAction;
    ManagerResponse originateResponse;

    // le thanh hai
    System.out.println("");

    originateAction = new OriginateAction();
    originateAction.setChannel("SIP/" + witness);
    originateAction.setContext("conferences");
    originateAction.setExten(roomNumber);
    originateAction.setPriority(new Integer(1));
    originateAction.setTimeout(new Long(30000));

    // //send the originate action and wait for a maximum of 30 seconds for
    // Asterisk
    // to send a reply
    originateResponse = managerConnection.sendAction(originateAction, 30000);

    // print out whether the originate succeeded or not
    System.out.println(originateResponse.getResponse());
    if (originateResponse.getResponse().equals("Success")) validRoom = true;

    return validRoom;
  }
示例#3
0
  public boolean kSendSMS() {

    String channel = conteudo.getChannel();
    String text = conteudo.getSmsText();
    String destination = conteudo.getNumber();
    String context = conteudo.getContext();
    String tech = conteudo.getTech();
    boolean back = false;
    String smsParam;
    boolean confirmation = conteudo.getConfirmation();

    KSendSMSAction action;
    action = new KSendSMSAction();

    if (!destination.equals("") && !channel.equals("") && !text.equals("")) {

      action.setDevice(channel);
      action.setDestination(destination);
      action.setMessage(text);
      action.setConfirmation(confirmation);

      smsParam =
          ("Action: "
              + action.getAction()
              + CRLF
              + "device: "
              + action.getDevice()
              + CRLF
              + "destination: "
              + action.getDestination()
              + CRLF
              + "Message: "
              + action.getMessage()
              + CRLF
              + "Confirmation: "
              + action.getConfirmation()
              + CRLF
              + CRLF);

      if (ManagerConnectionState.CONNECTED == this.managerConnection.getState()) {
        try {
          managerConnection.sendAction(action, sendCB);
          back = true;
          System.out.println("Sending SMS to " + destination);
          this.changeInfo(smsParam);
        } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
          Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
    } else {
      System.out.println("Existem valores em branco!");
      return back;
    }

    return back;
  }
示例#4
0
  public void kSendUuiMessage() {
    String device = conteudo.getUuiDevice();
    String protocol = conteudo.getUuiProtocol();
    String length = conteudo.getUuiLength();
    String data = conteudo.getUuiData();

    String uuiParam;

    KSendUUIAction action;
    action = new KSendUUIAction();

    if (!device.equals("") && !data.equals("") && !protocol.equals("") && !length.equals("")) {

      action.setData(data);
      action.setDevice(device);
      action.setLength(length);
      action.setProtocol(protocol);

      uuiParam =
          ("Dial(Khomp/"
              + action.getDevice()
              + "/"
              + action.getProtocol()
              + "/"
              + action.getLength()
              + "/"
              + action.getData()
              + ")");

      if (ManagerConnectionState.CONNECTED == this.managerConnection.getState()) {
        try {
          managerConnection.sendAction(action, sendCB);
          System.out.println("Sending UUI message to " + device);
          this.changeInfo(uuiParam);
        } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
          Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
    } else {
      System.out.println("Existem valores em branco!");
    }
  }
示例#5
0
  public void kSendPresentation() {
    String channel = conteudo.getChannel();
    String presentation = conteudo.getPresentation();
    String presentationParam;

    KGSMPresentationAction action;
    action = new KGSMPresentationAction();

    if (!channel.equals("") && !presentation.equals("")) {

      action.setChannel(channel);
      action.setPresentation(presentation);

      presentationParam =
          ("Action: "
              + action.getAction()
              + CRLF
              + "channel: "
              + action.getChannel()
              + CRLF
              + "presentation: "
              + action.getPresentation()
              + CRLF
              + CRLF);

      if (ManagerConnectionState.CONNECTED == this.managerConnection.getState()) {
        try {
          managerConnection.sendAction(action, sendCB);
          System.out.println("Sending Presentation: " + presentation + " to channel: " + channel);
          this.changeInfo(presentationParam);
        } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
          Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
        }
      } else {
        JOptionPane.showMessageDialog(telaPrincipal, "Necessário conectar primeiro!");
      }
    } else {
      System.out.println("Existem valores em branco!");
    }
  }
示例#6
0
  public void kSendUssdMessage() {

    String device = conteudo.getUSSDDevice();
    String message = conteudo.getUSSDMessage();
    String ussdParam;

    KSendUSSDAction action;
    action = new KSendUSSDAction();

    if (!device.equals("") && !message.equals("")) {

      action.setDevice(device);
      action.setMessage(message);

      ussdParam =
          ("Action: "
              + action.getAction()
              + CRLF
              + "device: "
              + action.getDevice()
              + CRLF
              + "message: "
              + action.getMessage()
              + CRLF
              + CRLF);

      if (ManagerConnectionState.CONNECTED == this.managerConnection.getState()) {
        try {
          managerConnection.sendAction(action, sendCB);
          System.out.println("Sending USSD message to " + device);
          this.changeInfo(ussdParam);
        } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
          Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
    } else {
      System.out.println("Existem valores em branco!");
    }
  }
示例#7
0
  public void kSendSimCardSelection() {

    String channel = conteudo.getSimCardChannel();
    int simCard = conteudo.getSimCardSelected();
    String selectionParam;

    KSelectSIMcardAction action;
    action = new KSelectSIMcardAction();

    if (!channel.equals("") && simCard > -1) {

      action.setChannel(channel);
      action.setSIMCard(simCard);

      selectionParam =
          ("Action: "
              + action.getAction()
              + CRLF
              + "channel: "
              + action.getChannel()
              + CRLF
              + "simcard: "
              + action.getSIMCard()
              + CRLF
              + CRLF);

      if (ManagerConnectionState.CONNECTED == this.managerConnection.getState()) {
        try {
          managerConnection.sendAction(action, sendCB);
          System.out.println("Changind SIM card to: SIMcard: " + simCard);
          this.changeInfo(selectionParam);
        } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
          Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
    } else {
      System.out.println("Existem valores em branco!");
    }
  }
示例#8
0
  /**
   * click call function example: call(809, 011862062881234) 809 is my extension number,
   * 011862062881234 is the number that I want to dial. this function will first call your
   * extension(parameter callFrom), then will call the target phone number(parameter callTo) after
   * you pickup the telephone.
   *
   * @param callFrom the Asterisk extension from
   * @param callTo the phone number to call
   */
  public void call(String callFrom, String callTo) {

    OriginateAction originateAction;
    originateAction = new OriginateAction();
    originateAction.setChannel(originationChannel + callFrom + originationChannelSuffix);
    originateAction.setContext(originationContext);
    originateAction.setExten(asteriskExternalCode + callTo);
    originateAction.setCallerId(callFrom);
    originateAction.setPriority(new Integer(1));
    originateAction.setTimeout(new Long(TIMEOUT)); // 30 seconds timeout
    Debug.logInfo(
        "Calling from: "
            + originateAction.getChannel()
            + ", to: "
            + originateAction.getExten()
            + ", asterisk connection state : "
            + managerConnection.getState(),
        MODULE);

    // send the originate action and wait for a maximum of 30 seconds for Asterisk to send a reply
    try {
      // confirm the manager connection still connected, else try to reconnect
      if (managerConnection.getState() != ManagerConnectionState.CONNECTED) {
        managerConnection.login();
      }
      managerConnection.sendAction(originateAction, TIMEOUT);
    } catch (IllegalArgumentException e) {
      Debug.logError(e, "Error outbound calling", MODULE);
    } catch (IllegalStateException e) {
      Debug.logError(e, "Error outbound calling", MODULE);
    } catch (IOException e) {
      Debug.logError(e, "Error outbound calling", MODULE);
    } catch (TimeoutException e) {
      Debug.logError(e, "Error outbound calling", MODULE);
    } catch (AuthenticationFailedException e) {
      Debug.logError(e, "Error outbound calling", MODULE);
    }
  }
示例#9
0
  /** Reloads asterisk config properties. */
  public void reload() {
    // retrieve asterisk manager configuration here
    Properties configProperties = UtilProperties.getProperties("asterisk.properties");
    // asterisk host address
    String host = (String) configProperties.get("asterisk.host");
    // asterisk manager username
    String username = (String) configProperties.get("asterisk.username");
    // asterisk manager password
    String password = (String) configProperties.get("asterisk.password");
    // asterisk dial out prefix, calls between internal extensions are made by dialing the extension
    // number
    // whereas external calls need a prefix before the number you want dial, such as 9
    asteriskExternalCode = (String) configProperties.get("asterisk.outbound.prev");
    // the country code of asterisk server, can be specified to avoid dialing national numbers using
    // the country code
    asteriskCountryCode =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.countryCode", "");
    // the area code of asterisk server, can be specified to avoid dialing local area numbers using
    // the area code
    asteriskAreaCode =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.areaCode", "");
    // the current phone number of the asterisk server (the phone number of the phone line connected
    // to the asterisk server)
    asteriskPhoneNumber =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.phoneNumber", "");
    // the prefix used to dial international phone numbers, usually "011" or "00" ... depends on the
    // origin country
    asteriskInternationalPrefix =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.outbound.foreign", "");
    // the prefix used to dial numbers out of the local area, for example to dial other cities /
    // states
    asteriskAreaPrefix =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.outbound.area", "");
    // if always add area code to dial, even though it was the same area code.
    alwaysDialAreaCode =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.alwaysDialAreaCode", "Y");
    // if always add country code to dial, even though it was the same country code, it used in some
    // voip provider.
    alwaysDialCountryCode =
        UtilProperties.getPropertyValue(
            "asterisk.properties", "asterisk.alwaysDialCountryCode", "Y");
    // Dialplan context to use for outgoing calls, i.e. the dialed number
    originationContext =
        UtilProperties.getPropertyValue(
            "asterisk.properties", "asterisk.originationContext", "from-internal");
    // Channel Technology to use for outgoing calls for the user's channel i.e. SIP/ for chan_sip or
    // Local/ for chan_local
    originationChannel =
        UtilProperties.getPropertyValue(
            "asterisk.properties", "asterisk.originationChannel", "Local/");
    // Channel Technology suffix (useful for ChanLocal - i.e. Local/825@from-internal
    originationChannelSuffix =
        UtilProperties.getPropertyValue(
            "asterisk.properties", "asterisk.originationChannelSuffix", "");
    // Area codes that don't need the long-distance prefix
    String localAreaCodesString =
        UtilProperties.getPropertyValue("asterisk.properties", "asterisk.localAreaCodes", "");
    localAreaCodes = UtilMisc.toListArray(localAreaCodesString.split(","));
    // logs out an existing connection
    if (managerConnection != null) {
      if (managerConnection.getState().equals(ManagerConnectionState.CONNECTED)) {
        managerConnection.logoff();
      }
    }

    ManagerConnectionFactory factory = new ManagerConnectionFactory(host, username, password);

    this.managerConnection = factory.createManagerConnection();
    // connect to Asterisk and log in
    try {
      managerConnection.login();
      managerConnection.addEventListener(
          new ManagerEventListener() {
            public void onManagerEvent(ManagerEvent event) {
              // add a listener to handle incoming and outgoing calls
              // e.getCallerId() is the calling phone number. such as 8605758672106
              // e.getDestination() is the destination of call, include asterisk communication, such
              // as SIP/825-09caf850
              if (event instanceof DialEvent) {
                DialEvent e = (DialEvent) event;
                String destinationNumber = retrieveNumber(e.getDestination());
                Debug.logInfo("Call from:" + e.getCallerId() + ", to:" + destinationNumber, MODULE);
                calls.put(destinationNumber, e.getCallerId());
              }
            }
          });
      managerConnection.sendAction(new StatusAction());
    } catch (IllegalStateException e) {
      Debug.logError(e, "Error reloading asterisk server manager connection", MODULE);
    } catch (IOException e) {
      Debug.logError(e, "Error reloading asterisk server manager connection", MODULE);
    } catch (AuthenticationFailedException e) {
      Debug.logError(e, "Error reloading asterisk server manager connection", MODULE);
    } catch (TimeoutException e) {
      Debug.logError(e, "Error reloading asterisk server manager connection", MODULE);
    }
  }
示例#10
0
 public String sendAction(ManagerAction action) throws Exception {
   ManagerResponse response = managerConnection.sendAction(action, 2000);
   return response.getResponse();
 }
示例#11
0
  public int makeCallAplicacao() {

    String number = conteudo.getNumber();
    String channel = conteudo.getChannel();
    String context = conteudo.getContext();
    String tech = conteudo.getTech();
    int priority = 1;
    int timeOut = 30000;
    int back = 0;
    int actID = this.actionID + 1;

    this.actionID = actID;

    OriginateAction originateAction;
    // SendActionCallback sendCB = this;

    originateAction = new OriginateAction();

    if (!number.equals("") && !channel.equals("") && !context.equals("")) {
      originateAction.setActionId(String.valueOf(actID));

      if (tech.equalsIgnoreCase("Khomp")) {
        originateAction.setChannel(tech + "/" + channel + "/" + number);
      } else {
        originateAction.setChannel(tech + "/" + number);
      }

      originateAction.setContext(context);
      originateAction.setExten(number);
      originateAction.setPriority(priority);
      originateAction.setTimeout(timeOut);
      back = 1;
    } else {
      System.out.println("Existem valores em branco!");
      return back;
    }

    if (ManagerConnectionState.CONNECTED == this.managerConnection.getState()) {
      System.out.println("Calling to " + "Channel:" + channel + ", Extension:" + number);

      try {
        managerConnection.sendAction(originateAction, sendCB);
      } catch (IOException | IllegalArgumentException | IllegalStateException ex) {
        Logger.getLogger(Aplicacao.class.getName()).log(Level.SEVERE, null, ex);
      }
    } else {
      back = -1;
    }

    String callParam =
        ("Action: Originate"
            + CRLF
            + "ActionID: "
            + originateAction.getActionId()
            + CRLF
            + "Channel: "
            + originateAction.getChannel()
            + CRLF
            + "Context: "
            + originateAction.getContext()
            + CRLF
            + "Exten: "
            + originateAction.getExten()
            + CRLF
            + "Priority: "
            + originateAction.getPriority()
            + CRLF
            + CRLF);

    this.changeInfo(callParam);

    // cria e popula objeto call
    Call call = new Call();
    call.setActionID(Integer.toString(actID));
    call.setChannel(channel);
    call.setStatus("Connected");

    //        conteudo.setTabela(call);
    //        telaPrincipal.mostraTabelaChannels();
    return back;
  }