public void updateUser(Presence presence) {
   boolean newUser = true;
   Contact removeC = null;
   for (Contact c : contactList) {
     if (c.getRosterEntry().getUser().equals(StringUtils.parseBareAddress(presence.getFrom()))) {
       newUser = false;
       if (!(presence.isAvailable() || presence.isAway())) {
         removeC = c;
       }
       break;
     }
   }
   if (removeC != null) {
     contactList.remove(removeC);
   }
   if (newUser) {
     RosterEntry re = roster.getEntry(StringUtils.parseBareAddress(presence.getFrom()));
     Contact c = new Contact();
     if (re.getName() == null || re.getName().trim().equals("")) c.setName(re.getUser());
     else c.setName(re.getName());
     c.setStatus(presence.getStatus());
     c.setRosterEntry(re);
     contactList.add(c);
   }
 }
  @Override
  public void presenceChanged(Presence presence) {

    log.info("Presence Updated: " + presence.getFrom());

    updated = true;
    presenceChanged.add(presence.getFrom());
  }
        private boolean hasOnlineStateChanged(Presence presence) {
          Presence last = lastPresenceMap.get(presence.getFrom());
          lastPresenceMap.put(presence.getFrom(), presence);

          if (last == null) return false;

          return last.isAvailable() ^ presence.isAvailable();
        }
 @Override
 public void presenceChanged(Presence presence) {
   final User user = getUser(presence.getFrom(), true, false);
   if (user == null) {
     return;
   }
   user.setUserState(new UserState(presence));
   user.setAvatar(service.getAvatarService().getAvatar(user));
   user.setRessource(StringUtils.parseResource(presence.getFrom()));
   service.sendRosterUpdated(user);
 }
  public void presenceChanged(Presence p) {
    String from = p.getFrom();
    if (from != null) {
      p = connection.getRoster().getPresence(p.getFrom());
      from = StringUtils.parseBareAddress(from);
      final Friend friend = api.getFriendById(from);
      if (friend != null) {
        for (final FriendListener l : api.getFriendListeners()) {
          final Presence.Type previousType = typeUsers.get(from);
          if (p.getType() == Presence.Type.available
              && (previousType == null || previousType != Presence.Type.available)) {
            l.onFriendJoin(friend);
          } else if (p.getType() == Presence.Type.unavailable
              && (previousType == null || previousType != Presence.Type.unavailable)) {
            l.onFriendLeave(friend);
          }

          final Presence.Mode previousMode = modeUsers.get(from);
          if (p.getMode() == Presence.Mode.chat
              && (previousMode == null || previousMode != Presence.Mode.chat)) {
            l.onFriendAvailable(friend);
          } else if (p.getMode() == Presence.Mode.away
              && (previousMode == null || previousMode != Presence.Mode.away)) {
            l.onFriendAway(friend);
          } else if (p.getMode() == Presence.Mode.dnd
              && (previousMode == null || previousMode != Presence.Mode.dnd)) {
            l.onFriendBusy(friend);
          }

          if (p.getStatus() != null) {
            try {
              final LolStatus previousStatus = statusUsers.get(from);
              final LolStatus newStatus = new LolStatus(p.getStatus());
              if (previousStatus != null && !newStatus.equals(previousStatus)) {
                l.onFriendStatusChange(friend);
              }
            } catch (JDOMException | IOException e) {
            }
          }
        }

        typeUsers.put(from, p.getType());
        modeUsers.put(from, p.getMode());
        if (p.getStatus() != null) {
          try {
            statusUsers.put(from, new LolStatus(p.getStatus()));
          } catch (JDOMException | IOException e) {
          }
        }
      }
    }
  }
Example #6
0
  private void handleIncomingSubscribe(Presence request) {
    final ContentValues values = new ContentValues();

    values.put(RosterConstants.JID, request.getFrom());
    values.put(RosterConstants.ALIAS, request.getFrom());
    values.put(RosterConstants.GROUP, "");

    values.put(RosterConstants.STATUS_MODE, getStatusInt(request));
    values.put(RosterConstants.STATUS_MESSAGE, request.getStatus());

    Uri uri = contentResolver.insert(RosterProvider.CONTENT_URI, values);
    Log.d(TAG, "handleIncomingSubscribe: faked " + uri);
  }
Example #7
0
  /**
   * 根据RosterEntry创建一个User
   *
   * @param entry
   * @return
   */
  public User transEntryToUser(RosterEntry entry, Roster roster) {
    User user = new User();
    user.setJID(entry.getUser());
    Presence presence = roster.getPresence(entry.getUser());
    user.setFrom(presence.getFrom());
    user.setStatus(presence.getStatus());
    user.setAvailable(presence.isAvailable());
    user.setType(entry.getType());

    // user.setvCard(userManager.getUserVCard(entry.getUser()));
    if (entry.getName() == null) {
      //			if(user.getvCard()==null)
      //			user.setName(StringUtil.getUserNameByJid(entry.getUser()));
      //			else {
      //				user.setName(user.getvCard().getNickName());
      //			}
      user.setName(StringUtil.getUserNameByJid(entry.getUser()));
    } else {
      user.setName(entry.getName());
    }
    String avatar = UserManager.saveAvatar(entry.getUser(), context);
    user.setAvatar_path(avatar);

    return user;
  }
 private XMPPFriendImpl getFriend(org.jivesoftware.smack.packet.Presence presence) {
   XMPPFriendImpl friend;
   synchronized (friends) {
     friend = friends.get(PresenceUtils.parseBareAddress(presence.getFrom()));
   }
   return friend;
 }
        private void clearCache(Presence presence) {
          String rjid = presence.getFrom();

          if (rjid == null) {
            LOG.error("presence.getFrom() is null");
            return;
          }

          DiscoverInfoWrapper infoWrapper = cache.remove(rjid);

          if (infoWrapper != null) {
            if (infoWrapper.isAvailable()) {
              LOG.debug(
                  "clearing cache entry of contact "
                      + rjid
                      + ": "
                      + infoWrapper.item.getChildElementXML());
            } else {
              LOG.debug(
                  "clearing cache entry of contact "
                      + rjid
                      + " but cache entry is empty (a discovery is "
                      + "still running or the last one failed)");
            }
          }
        }
    private void acceptSubscription(final Presence presence, boolean subscribe) {
      if (!isOnline()) return;

      myFacade.changeSubscription(presence.getFrom(), subscribe);

      if (subscribe) {
        String from = getSimpleId(presence.getFrom());
        LOG.info("Add " + from + " to the roster");

        try {
          getRoster().createEntry(from, from, new String[] {UserModel.DEFAULT_GROUP});
        } catch (XMPPException e) {
          LOG.warn(e);
        }
      }
    }
Example #11
0
  /**
   * Updates user's changed presence
   *
   * @param presence
   */
  public void presenceChanged(Presence presence) {

    String from = presence.getFrom();

    // Log.i(tag, presence.getMode().toString());
    new BuddiesController(context)
        .notifyPresenceChanged(from, presence.getMode(), presence.getStatus());
    return;
  }
 private String getCurrentJabberID(User user, RosterEntry rosterEntry) {
   Presence presence = _getPresence(user);
   String jabberId = null;
   if (presence != null) {
     jabberId = presence.getFrom();
   }
   if (jabberId == null) jabberId = rosterEntry.getUser();
   if (jabberId == null) jabberId = rosterEntry.getName();
   return jabberId;
 }
    @Override
    public void processPacket(Packet packet) {
      final Presence presence = ((Presence) packet);
      if (presence.getType() != Presence.Type.subscribe) return;
      LOG.info("Subscribe request from " + presence.getFrom());

      if (myIgnoreList.isIgnored(presence.getFrom())) {
        LOG.info(presence.getFrom() + " in ignore list");
        return;
      }

      if (isUserInMyContactListAndActive(presence.getFrom()) || Pico.isUnitTest()) {
        acceptSubscription(presence, true);
        return;
      }

      UIUtil.invokeLater(
          () -> acceptSubscription(presence, myUI.shouldAcceptSubscriptionRequest(presence)));
    }
Example #14
0
 Occupant(Presence presence) {
   super();
   MUCUser mucUser = (MUCUser) presence.getExtension("x", "http://jabber.org/protocol/muc#user");
   MUCUser.Item item = mucUser.getItem();
   this.jid = item.getJid();
   this.affiliation = item.getAffiliation();
   this.role = item.getRole();
   // Get the nickname from the FROM attribute of the presence
   this.nick = StringUtils.parseResource(presence.getFrom());
 }
Example #15
0
 /**
  * There are two ways we initially learn about new peers. The first is a Lantern peer directly on
  * our roster, which will produce this event. The second is a kaleidoscope advertisement. Those
  * Kaleidoscope advertisements can be from peers on our roster, but they can also be from peers
  * we're not directly connected to. This method captures the first case where peers on our roster
  * are running Lantern.
  *
  * @param event The update presence event.
  */
 @Subscribe
 public void onUpdatePresenceEvent(final UpdatePresenceEvent event) {
   log.debug("Processing presence event");
   final Presence presence = event.getPresence();
   final String from = presence.getFrom();
   if (StringUtils.isBlank(from)) {
     log.warn("Presence with blank from?");
   } else {
     addPeer(LanternUtils.newURI(from), Type.pc);
   }
 }
Example #16
0
  // carefull, this method does also get called by the SmackListener Thread
  @Override
  public void presenceChanged(Presence presence) {
    String bareUserId = StringUtils.parseBareAddress(presence.getFrom());

    Intent intent = new Intent(MainService.ACTION_XMPP_PRESENCE_CHANGED);
    intent.putExtra("userid", bareUserId);
    intent.putExtra("fullid", presence.getFrom());
    intent.putExtra("state", retrieveState(presence.getMode(), presence.isAvailable()));
    intent.putExtra("status", presence.getStatus());
    sContext.sendBroadcast(intent);

    // TODO Make this a general intent action.NOTIFICATION_ADDRESS_AVAILABLE
    // and handle it for example within XmppPresenceStatus
    // if the notification address is/has become available, update the resource status string
    if (sSettings.containsNotifiedAddress(bareUserId) && presence.isAvailable()) {
      intent = new Intent(MainService.ACTION_COMMAND);
      intent.setClass(sContext, MainService.class);
      intent.putExtra("cmd", "batt");
      intent.putExtra("args", "silent");
      MainService.sendToServiceHandler(intent);
    }
  }
 @Override
 public void presenceChanged(final org.jivesoftware.smack.packet.Presence presence) {
   String localJID;
   try {
     localJID = getLocalJid();
   } catch (FriendException e) {
     localJID = null;
   }
   if (!presence.getFrom().equals(localJID)) {
     XMPPFriendImpl friend = getFriend(presence);
     if (friend != null) {
       LOG.debugf("presence from {0} changed to {1}", presence.getFrom(), presence.getType());
       // synchronize to avoid updates or presences from being lost
       // better to replace that with a lock object private to this
       // connection class
       synchronized (friend) {
         if (presence.getType().equals(org.jivesoftware.smack.packet.Presence.Type.available)) {
           if (!friend.getPresences().containsKey(presence.getFrom())) {
             addNewPresence(friend, presence);
           } else {
             updatePresence(friend, presence);
           }
         } else if (presence
             .getType()
             .equals(org.jivesoftware.smack.packet.Presence.Type.unavailable)) {
           PresenceImpl p = (PresenceImpl) friend.getPresence(presence.getFrom());
           if (p != null) {
             p.update(presence);
             friend.removePresense(p);
           }
         }
       }
     } else {
       LOG.debugf("no friend for presence {0}", presence.getFrom());
     }
   }
 }
Example #18
0
  /**
   * Returns the RQ-JIDs of all presences of the given (plain) JID which are available.
   *
   * <p>An empty list is returned if no presence for the given JID is online.
   */
  public List<JID> getAvailablePresences(JID from) {

    List<JID> result = new ArrayList<JID>();

    for (Presence presence : getPresences(from)) {
      if (!presence.isAvailable()) continue;

      String rjid = presence.getFrom();
      if (rjid == null) {
        LOG.error("presence.getFrom() is null");
        continue;
      }
      result.add(new JID(rjid));
    }

    return result;
  }
Example #19
0
  /**
   * Returns the RQ-JID of given plain JID supporting the feature of the given name-space if
   * available, otherwise null.
   *
   * <p>If not in the cache then a blocking cache update is performed.
   *
   * @param jid The JID of the user to find a supporting presence for. The JID can be resource
   *     qualified in which case the resource is stripped, before performing the look-up.
   * @blocking This method blocks until the ServiceDiscovery returns.
   * @reentrant This method can be called concurrently.
   * @caching If results are available in the cache, they are used instead of querying the server.
   */
  public JID getSupportingPresence(final JID jid, final String namespace) {
    checkJID(jid);

    for (Presence presence : rosterTracker.getPresences(jid.getBareJID())) {
      if (!presence.isAvailable()) continue;

      String rjid = presence.getFrom();
      if (rjid == null) {
        LOG.error("presence.getFrom() is null");
        continue;
      }

      JID jidToCheck = new JID(rjid);
      Boolean supported = queryFeatureSupport(jidToCheck, namespace);

      if (supported != null && supported) return jidToCheck;
    }

    return null;
  }
Example #20
0
 public void sendFile(String filename) throws XMPPException {
   Presence pre = connection.getRoster().getPresence("*****@*****.**");
   System.out.println(pre);
   if (pre.getType() != Presence.Type.unavailable) {
     if (fileTransferManager == null) {
       initFileTransport();
     }
     FileTransferManager manager = new FileTransferManager(connection);
     // 创建输出的文件传输
     OutgoingFileTransfer transfer = manager.createOutgoingFileTransfer(pre.getFrom());
     // 发送文件
     transfer.sendFile(new File(filename), "图片");
     // while (!transfer.isDone()) {
     // if (transfer.getStatus() == FileTransfer.Status.in_progress) {
     // // 可以调用transfer.getProgress();获得传输的进度
     // System.out.println(transfer.getStatus());
     // System.out.println(transfer.getProgress());
     // System.out.println(transfer.isDone());
     // }
     // }
   }
 }
 @Override
 public void processPacket(Packet packet) {
   if (!(packet instanceof Presence)) return;
   Presence p = (Presence) packet;
   if (p.getType() != Presence.Type.subscribe) return;
   String from = p.getFrom();
   Notification notification =
       new Notification(
           android.R.drawable.stat_notify_more,
           mService.getString(R.string.AcceptContactRequest, from),
           System.currentTimeMillis());
   notification.flags = Notification.FLAG_AUTO_CANCEL;
   Intent intent = new Intent(mService, Subscription.class);
   intent.setData(Contact.makeXmppUri(from));
   notification.setLatestEventInfo(
       mService,
       from,
       mService.getString(R.string.AcceptContactRequestFrom, from),
       PendingIntent.getActivity(mService, 0, intent, PendingIntent.FLAG_ONE_SHOT));
   int id = p.hashCode();
   mService.sendNotification(id, notification);
 }
 private void updatePresence(
     XMPPFriendImpl friend, org.jivesoftware.smack.packet.Presence presence) {
   PresenceImpl currentPresence = (PresenceImpl) friend.getPresences().get(presence.getFrom());
   currentPresence.update(presence);
   friend.updatePresence(currentPresence);
 }
Example #23
0
  /**
   * Handles presence stanzas
   *
   * @param presence
   */
  private void handlePresence(Presence presence) {
    // unavailable is sent when user leaves the room
    if (!presence.isAvailable()) {
      return;
    }

    String from = presence.getFrom();
    JitsiMeetConference conference = getConferenceForMucJid(from);

    if (conference == null) {
      if (logger.isDebugEnabled()) {
        logger.debug("Room not found for JID: " + from);
      }
      return;
    }

    ChatRoomMemberRole role = conference.getRoleForMucJid(from);

    if (role != null && role.compareTo(ChatRoomMemberRole.MODERATOR) < 0) {
      StartMutedPacketExtension ext =
          (StartMutedPacketExtension)
              presence.getExtension(
                  StartMutedPacketExtension.ELEMENT_NAME, StartMutedPacketExtension.NAMESPACE);

      if (ext != null) {
        boolean[] startMuted = {ext.getAudioMuted(), ext.getVideoMuted()};

        conference.setStartMuted(startMuted);
      }
    }

    Participant participant = conference.findParticipantForRoomJid(from);
    ColibriConference colibriConference = conference.getColibriConference();

    if (participant != null && colibriConference != null) {
      // Check if this conference is valid
      String conferenceId = colibriConference.getConferenceId();
      if (StringUtils.isNullOrEmpty(conferenceId)) {
        logger.error("Unable to send DisplayNameChanged event" + " - no conference id");
        return;
      }

      // Check for changes to the display name
      String oldDisplayName = participant.getDisplayName();
      String newDisplayName = null;
      for (PacketExtension pe : presence.getExtensions()) {
        if (pe instanceof Nick) {
          newDisplayName = ((Nick) pe).getName();
          break;
        }
      }

      if (!Objects.equals(oldDisplayName, newDisplayName)) {
        participant.setDisplayName(newDisplayName);

        EventAdmin eventAdmin = FocusBundleActivator.getEventAdmin();
        if (eventAdmin != null) {
          // Prevent NPE when adding to event hashtable
          if (newDisplayName == null) {
            newDisplayName = "";
          }
          eventAdmin.sendEvent(
              EventFactory.endpointDisplayNameChanged(
                  conferenceId, participant.getEndpointId(), newDisplayName));
        }
      }
    }
  }
  /*
   * Handle a single smack packet, discarding anything but Message.
   * @param packet The smack packet.
   * (non-Javadoc)
   * @see org.jivesoftware.smack.PacketListener#processPacket(org.jivesoftware.smack.packet.Packet)
   */
  @Override
  public void processPacket(Packet packet) {

    Log.i("processPacket", packet.toXML());
    if (packet instanceof Presence) {

      double inLat = 0, inLong = 0;
      boolean isMUC = false, isGEO = false;

      Presence presence = (Presence) packet;

      // In a MUC, the "FROM" is the Resource
      String presenceFrom = StringUtils.parseResource(presence.getFrom());
      String presenceTo = StringUtils.parseName(presence.getTo());

      // if presence packet is from yourself, just bail
      if (presenceFrom.equals(presenceTo)) return;

      for (PacketExtension extension : presence.getExtensions()) {
        if (extension instanceof GeoLoc) {
          GeoLoc loc = (GeoLoc) extension;

          inLat = loc.getLat();
          inLong = loc.getLon();

          isGEO = true;

          Log.d("CNL", "ERIK: GEOLOC EXTENSION FOUND, LAT: " + inLat);
        }
        if (extension instanceof MUCUser) {
          // MUCUser muc = (MUCUser) extension;   no need to create this object
          isMUC = true;

          Log.d("CNL", "ERIK: MUC EXTENSION FOUND, presence type=" + presence.getType());
        }
      }

      //  If a MUC available presence packet comes in, add/update database
      if (isMUC == true && presence.getType().toString().equals("available") && isGEO == true) {

        updateDatabase(presenceFrom, inLat, inLong, null);
      }

      // if a MUC Unavailable presence packet comes in, remove user from database
      else if (isMUC == true && presence.getType().toString().equals("unavailable")) {

        if (this.database.delete("user_info", "name='" + presenceFrom + "'", null) > 0) {
          Log.d("CNL", "ERIK: DATABASE UPDATED, USER " + presenceFrom + " DELETED");
        } else Log.d("CNL", "ERIK: DATABASE SEARCHED, USER " + presenceFrom + " NOT FOUND");
      }
    }

    if (packet instanceof IQ) {
      IQ iq = (IQ) packet;
      Log.d("CNL", "ERIK: IQ PACKET RECEIVED: " + iq.getExtensions());
    }

    if (packet instanceof Message) {
      Message msg = (Message) packet;
      String text = msg.getBody();

      if (text == null || text.trim().length() == 0) {
        Log.d("CNL", "ERIK: MESSAGE PACKET LACKS A MESSAGE!!!");
        return;
      }

      // Extract name
      String messageFrom = StringUtils.parseResource(msg.getFrom());

      // Extract lat and lon from message
      double inLat = getLat(msg);
      double inLon = getLon(msg);
      Boolean isEmergency = null;
      if (text.startsWith(this.context.getString(R.string.emergency_message))) {
        isEmergency = Boolean.TRUE;
      } else if (text.startsWith(this.context.getString(R.string.cancel_message))) {
        isEmergency = Boolean.FALSE;
      }

      Log.i("CNL", "recovered name=[" + messageFrom + "], lat/lon=" + inLat + "," + inLon);

      updateDatabase(messageFrom, inLat, inLon, isEmergency);

      String bareFrom = XMPPUtils.getBareJid(msg.getFrom());
      String msgFrom = StringUtils.parseResource(msg.getFrom());
      String bareTo = XMPPUtils.getBareJid(msg.getTo());
      String msgTo = StringUtils.parseName(msg.getTo());

      if (msg.getType().toString().equals("groupchat")) {
        Log.d(
            "CNL",
            "ERIK: MUC MESSAGE PACKET RECEIVED, CONTAINS EXTENSIONS: " + msg.getExtensions());
        if (msgFrom.equals(msgTo)) return;

        // Picture receiving code here.............................!!!!!!!!!!

        for (PacketExtension extension : msg.getExtensions()) {
          if (extension instanceof DataPacketExtension) {
            DataPacketExtension data = (DataPacketExtension) extension;

            byte[] imageBytes = data.getDecodedData();
            String imagePath = Environment.getExternalStorageDirectory() + "/mmmc/";

            // String imageName = text;
            File f = new File(imagePath, text);
            OutputStream out = null;

            try {
              out = new BufferedOutputStream(new FileOutputStream(f));
              out.write(imageBytes);
            } catch (IOException ioe) {
              ioe.printStackTrace();
            } finally {
              if (out != null) {
                try {
                  out.close();
                } catch (IOException e) {
                  e.printStackTrace();
                }
              }
            }

            // Log.d("CNL", "ERIK: MUC EXTENSION FOUND");
            ContentValues values = new ContentValues();
            values.put("ts", System.currentTimeMillis());
            values.put("jid", bareFrom);

            // don't put who it's from, put the resource it came from (user in a MUC)
            values.put("src", msgFrom);

            values.put("dst", msg.getTo());
            values.put("via", bareTo);
            values.put("msg", "Picture received: " + text.trim());
            this.database.insert("msg", "_id", values);

            Log.d("CNL", "ERIK: DATA EXTENSION FOUND, IMAGE SAVED");
            return;
          }
        }

        // Log.d("CNL", "ERIK: MUC EXTENSION FOUND");

        // Insert new message into database
        ContentValues values = new ContentValues();
        values.put("ts", System.currentTimeMillis());
        values.put("jid", bareFrom);

        // don't put who it's from, put the resource it came from (user in a MUC)
        values.put("src", msgFrom);

        values.put("dst", msg.getTo());
        values.put("via", bareTo);
        values.put("msg", text.trim());
        this.database.insert("msg", "_id", values);
      } else Log.d("CNL", "ERIK: NON-MUC MESSAGE PACKET RECEIVED: " + bareFrom);

      Builder builder = new Uri.Builder();
      builder.scheme("content");
      builder.authority("jabber-chat-db");
      builder.appendPath(bareTo);
      builder.appendPath(bareFrom);
      this.context.getContentResolver().notifyChange(builder.build(), null);
      setNotification(bareFrom, bareTo);
    }
  }
  /**
   * Sends a file transfer request to the given <tt>toContact</tt>.
   *
   * @return the transfer object
   * @param toContact the contact that should receive the file
   * @param file file to send
   * @param gw special gateway to be used for receiver if its jid misses the domain part
   */
  FileTransfer sendFile(Contact toContact, File file, String gw)
      throws IllegalStateException, IllegalArgumentException, OperationNotSupportedException {
    OutgoingFileTransferJabberImpl outgoingTransfer = null;

    try {
      assertConnected();

      if (file.length() > getMaximumFileLength())
        throw new IllegalArgumentException("File length exceeds the allowed one for this protocol");

      String fullJid = null;
      // Find the jid of the contact which support file transfer
      // and is with highest priority if more than one found
      // if we have equals priorities
      // choose the one that is more available
      OperationSetMultiUserChat mucOpSet =
          jabberProvider.getOperationSet(OperationSetMultiUserChat.class);
      if (mucOpSet != null && mucOpSet.isPrivateMessagingContact(toContact.getAddress())) {
        fullJid = toContact.getAddress();
      } else {
        Iterator<Presence> iter =
            jabberProvider.getConnection().getRoster().getPresences(toContact.getAddress());
        int bestPriority = -1;

        PresenceStatus jabberStatus = null;

        while (iter.hasNext()) {
          Presence presence = iter.next();

          if (jabberProvider.isFeatureListSupported(
              presence.getFrom(),
              new String[] {
                "http://jabber.org/protocol/si",
                "http://jabber.org/protocol/si/profile/file-transfer"
              })) {

            int priority =
                (presence.getPriority() == Integer.MIN_VALUE) ? 0 : presence.getPriority();

            if (priority > bestPriority) {
              bestPriority = priority;
              fullJid = presence.getFrom();
              jabberStatus =
                  OperationSetPersistentPresenceJabberImpl.jabberStatusToPresenceStatus(
                      presence, jabberProvider);
            } else if (priority == bestPriority && jabberStatus != null) {
              PresenceStatus tempStatus =
                  OperationSetPersistentPresenceJabberImpl.jabberStatusToPresenceStatus(
                      presence, jabberProvider);
              if (tempStatus.compareTo(jabberStatus) > 0) {
                fullJid = presence.getFrom();
                jabberStatus = tempStatus;
              }
            }
          }
        }
      }

      // First we check if file transfer is at all supported for this
      // contact.
      if (fullJid == null) {
        throw new OperationNotSupportedException(
            "Contact client or server does not support file transfers.");
      }

      if (gw != null && !fullJid.contains("@") && !fullJid.endsWith(gw)) {
        fullJid = fullJid + "@" + gw;
      }

      OutgoingFileTransfer transfer = manager.createOutgoingFileTransfer(fullJid);

      outgoingTransfer =
          new OutgoingFileTransferJabberImpl(toContact, file, transfer, jabberProvider);

      // Notify all interested listeners that a file transfer has been
      // created.
      FileTransferCreatedEvent event = new FileTransferCreatedEvent(outgoingTransfer, new Date());

      fireFileTransferCreated(event);

      // Send the file through the Jabber file transfer.
      transfer.sendFile(file, "Sending file");

      // Start the status and progress thread.
      new FileTransferProgressThread(transfer, outgoingTransfer).start();
    } catch (XMPPException e) {
      logger.error("Failed to send file.", e);
    }

    return outgoingTransfer;
  }
Example #26
0
 /**
  * Returns the users full jid (ex. [email protected]/spark).
  *
  * @return the users Full JID.
  */
 public String getJID() {
   presence = PresenceManager.getPresence(getParticipantJID());
   return presence.getFrom();
 }