import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public void processRequest(Jid from, Collection<SetData> setDatas) throws XMPPException.XMPPErrorException {
	SetBoolData flashControlData = null;
	for (SetData setData : setDatas) {
		if (!(setData instanceof  SetBoolData)) continue;
		if (!setData.getName().equals(Constants.NOTIFICATION_ALARM)) continue;
		flashControlData = (SetBoolData) setData;
		break;
	}

	if (flashControlData == null) {
		return;
	}

	if (flashControlData.getBooleanValue()) {
		setNotifcationAlarm(NotificationAlarm.on);
	} else {
		setNotifcationAlarm(NotificationAlarm.off);
	}
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
public static void rosterRequestNotification(Jid sender) {
    // show notification only if the app is closed
    if (!MangostaApplication.getInstance().isClosed()) {
        new Event(Event.Type.PRESENCE_SUBSCRIPTION_REQUEST, sender).post();
        return;
    }

    Context context = XMPPSessionService.CONTEXT;
    String text = String.format(Locale.getDefault(), context.getString(R.string.roster_subscription_request), sender.toString());

    PendingIntent chatPendingIntent = preparePendingIntent(context, sender.toString());

    Notification.Builder mNotifyBuilder = new Notification.Builder(context)
            .setContentTitle(context.getString(R.string.roster_subscription_request_notification_title))
            .setContentText(text)
            .setSmallIcon(R.mipmap.ic_launcher_empty_back)
            .setContentIntent(chatPendingIntent)
            .setVibrate(new long[]{0, 200, 0, 200})
            .setAutoCancel(true)
            .setOngoing(true);

    NotificationManager mNotificationManager =
            (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
    mNotificationManager.notify(sender.toString(), NotificationsControl.ROSTER_NOTIFICATION, mNotifyBuilder.build());
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
public BlogPostComment sendBlogPostComment(String content, BlogPost blogPost)
        throws SmackException.NotConnectedException, InterruptedException,
        XMPPException.XMPPErrorException, SmackException.NoResponseException {
    Jid jid = XMPPSession.getInstance().getUser().asEntityBareJid();
    String userName = XMPPUtils.fromJIDToUserName(jid.toString());
    Jid pubSubServiceJid = XMPPSession.getInstance().getPubSubService();

    // create stanza
    PublishCommentExtension publishCommentExtension = new PublishCommentExtension(blogPost.getId(), userName, jid, content, new Date());
    PubSub publishCommentPubSub = PubSub.createPubsubPacket(pubSubServiceJid, IQ.Type.set, publishCommentExtension, null);

    // send stanza
    XMPPSession.getInstance().sendStanza(publishCommentPubSub);

    return new BlogPostComment(publishCommentExtension.getId(),
            blogPost.getId(),
            content,
            userName,
            jid.toString(),
            publishCommentExtension.getPublished());
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
private void manageCallFromRosterRequestNotification() {
    Bundle bundle = getIntent().getExtras();
    if (bundle != null) {
        boolean newRosterRequest = bundle.getBoolean(NEW_ROSTER_REQUEST, false);
        if (newRosterRequest) {
            try {
                String sender = bundle.getString(NEW_ROSTER_REQUEST_SENDER);
                Jid jid = JidCreate.from(sender);
                RosterNotifications.cancelRosterRequestNotification(this, sender);
                answerSubscriptionRequest(jid);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
public Presence.Type getStatusFromContact(String name) {
    try {
        HashMap<Jid, Presence.Type> buddies = getContacts();

        for (Map.Entry<Jid, Presence.Type> pair : buddies.entrySet()) {
            if (XMPPUtils.fromJIDToUserName(pair.getKey().toString()).equals(name)) {
                return pair.getValue();
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }

    return Presence.Type.unavailable;
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Test
public void checkXMPPLoggedUserSaved() throws Exception {
    assumeTrue(isUserLoggedIn());

    IdlingResource resource = startTiming(SplashActivity.WAIT_TIME);

    assumeNotNull(XMPPSession.getInstance().getXMPPConnection());
    assumeNotNull(XMPPSession.getInstance().getXMPPConnection().getUser());

    Jid jid = XMPPSession.getInstance().getXMPPConnection().getUser().asBareJid();
    assertTrue(XMPPUtils.isAutenticatedJid(jid));

    String userName = XMPPUtils.fromJIDToUserName(jid.toString());
    assertTrue(XMPPUtils.isAutenticatedUser(userName));

    stopTiming(resource);
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public void joined(EntityFullJid entityFullJid) {
     XmppAddress xa = new XmppAddress(entityFullJid.toString());
     ChatGroup chatGroup = mChatGroupManager.getChatGroup(xa);
     MultiUserChat muc = mChatGroupManager.getMultiUserChat(entityFullJid.asBareJid().toString());

     Occupant occupant = muc.getOccupant(entityFullJid);
     Jid jidSource = (occupant != null) ? occupant.getJid() : null;
     if (jidSource != null)
     xa = new XmppAddress(jidSource.toString());
     else
     xa = new XmppAddress(entityFullJid.toString());

     Contact mucContact = new Contact(xa, xa.getUser(), Imps.Contacts.TYPE_NORMAL);
     chatGroup.notifyMemberJoined(entityFullJid.toString(),mucContact);
    if (occupant != null) {
        chatGroup.notifyMemberRoleUpdate(mucContact, occupant.getRole().name(), occupant.getAffiliation().toString());
    }
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public boolean resourceSupportsOmemo(Jid jid) {

    try {
        if (mConnection == null || getState() != ImConnection.LOGGED_IN)
            return false;

        if (getOmemo().resourceSupportsOmemo(jid)) {

      //      if (getOmemo().getFingerprints(jid.asBareJid(), false).size() == 0) {
           //     getOmemo().getManager().requestDeviceListUpdateFor(jid.asBareJid());
            //    return false;
        //    }

            return true;
        }

    }
    catch (Exception e)
    {
        debug("OMEMO","There was a problem checking the resource",e);
    }

    return false;
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public void entriesDeleted(Collection<Jid> addresses) {

    ContactList cl;
    try {
        cl = mContactListManager.getDefaultContactList();

        for (Jid address : addresses) {
            Contact contact = new Contact(new XmppAddress(address.toString()),address.toString(), Imps.Contacts.TYPE_NORMAL);
            mContactListManager.notifyContactListUpdated(cl, ContactListListener.LIST_CONTACT_REMOVED, contact);
        }


    } catch (ImException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
private void setPresence (Jid from, int presenceType) {

        Presence p = null;
        Contact contact = mContactListManager.getContact(from.asBareJid().toString());
        if (contact == null)
            return;

        p = new Presence(presenceType, "", null, null,
                Presence.CLIENT_TYPE_MOBILE);

        if (from.hasResource())
            p.setResource(from.getResourceOrEmpty().toString());

        if (presenceType == Presence.AVAILABLE)
            p.setLastSeen(new Date());
        else if (contact.getPresence() != null)
            p.setLastSeen(contact.getPresence().getLastSeen());

        contact.setPresence(p);
        Collection<Contact> contactsUpdate = new ArrayList<Contact>();
        contactsUpdate.add(contact);
        mContactListManager.notifyContactsPresenceUpdated(contactsUpdate.toArray(new Contact[contactsUpdate.size()]));



    }
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
private void handleSubscribeRequest (Jid jid) throws ImException, RemoteException {
    ContactList cList = getContactListManager().getDefaultContactList();

    XmppAddress xAddr = new XmppAddress(jid.toString());
    Contact contact = new Contact(xAddr, xAddr.getUser(), Imps.Contacts.TYPE_NORMAL);
    mContactListManager.doAddContactToListAsync(contact, cList, false);

    mContactListManager.getSubscriptionRequestListener().onSubScriptionRequest(contact, mProviderId, mAccountId);

    ChatSession session = findOrCreateSession(jid.toString(), false);

    org.jivesoftware.smack.packet.Message msg = new org.jivesoftware.smack.packet.Message();
    msg.setStanzaId((Math.random()*10000f)+"subscribe");
    msg.setTo(mUserJid);
    msg.setFrom(jid);
    String message = mContext.getString(R.string.subscription_notify_text, contact.getName());
    msg.setBody(message);
    handleMessage(msg, false, false);

}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public ChatSessionManager getChatSessionManager() {
    return new ChatSessionManager() {

        @Override
        public void sendMessageAsync(ChatSession session, Message message) {
            // Echo
            Message rec = new Message(message.getBody());
            rec.setFrom(message.getTo());
            rec.setDateTime(new Date());
            session.onReceiveMessage(rec, true);
        }

        @Override
        public boolean resourceSupportsOmemo(Jid jid) {
            return false;
        }
    };
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public void entriesUpdated(Collection<Jid> addresses) {
    final MessageCenterService service = mService.get();
    final PresenceListener presenceListener = mPresenceListener.get();
    if (service == null || presenceListener == null)
        return;

    // we got an updated roster entry
    // check if it's a subscription "both"
    for (Jid jid : addresses) {
        RosterEntry e = service.getRosterEntry(jid.asBareJid());
        if (e != null && e.canSeeHisPresence()) {
            userSubscribed(service, presenceListener, jid);
        }
    }
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
/**
 * NOTE: on every (re-)connect all entries are added again (loaded),
 * one method call for all contacts.
 */
@Override
public void entriesAdded(Collection<Jid> addresses) {
    if (mRoster == null || !mLoaded)
        return;

    for (Jid jid: addresses) {
        RosterEntry entry = mRoster.getEntry(jid.asBareJid());
        if (entry == null) {
            LOGGER.warning("jid not in roster: "+jid);
            return;
        }

        LOGGER.config("entry: "+entry.toString());
        mHandler.onEntryAdded(clientToModel(entry));
    }
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
/**
 * Sends 'session-initiate' to the peer identified by given <tt>address</tt>
 *
 * @param useBundle <tt>true</tt> if invite IQ should include
 *                  {@link GroupPacketExtension}
 * @param address the XMPP address where 'session-initiate' will be sent.
 * @param contents the list of <tt>ContentPacketExtension</tt> describing
 *                 media offer.
 * @param requestHandler <tt>JingleRequestHandler</tt> that will be used
 *                       to process request related to newly created
 *                       JingleSession.
 * @param startMuted if the first element is <tt>true</tt> the participant
 * will start audio muted. if the second element is <tt>true</tt> the
 * participant will start video muted.
 * {@inheritDoc}
 */
@Override
public boolean initiateSession(boolean                      useBundle,
                               Jid                          address,
                               List<ContentPacketExtension> contents,
                               JingleRequestHandler         requestHandler,
                               boolean[]                    startMuted)
    throws OperationFailedException
{
    logger.info("INVITE PEER: " + address);

    String sid = JingleIQ.generateSID();
    JingleSession session = new JingleSession(sid, address, requestHandler);

    sessions.put(sid, session);

    JingleIQ inviteIQ
        = createInviteIQ(JingleAction.SESSION_INITIATE,
            sid, useBundle, address, contents, startMuted);

    IQ reply = (IQ) getConnection().sendPacketAndGetReply(inviteIQ);

    return wasInviteAccepted(session, reply);
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
/**
 * Convert a collection of Strings to a Set of {@link Jid}'s.
 * <p>
 * If the optional argument <code>exceptions</code> is given, then all {@link XmppStringprepException} thrown while
 * converting will be added to the list. Otherwise, if an XmppStringprepExceptions is thrown, it will be wrapped in
 * a AssertionError Exception and throw.
 * </p>
 * 
 * @param jidStrings
 *            the strings that are going to get converted
 * @param output
 *            the collection where the Jid's will be added to
 * @param exceptions the list of exceptions thrown while converting.
 */
public static void jidsFrom(Collection<? extends CharSequence> jidStrings, Collection<? super Jid> output,
		List<XmppStringprepException> exceptions) {
	for (CharSequence jidString : jidStrings) {
		try {
			Jid jid = JidCreate.from(jidString);
			output.add(jid);
		} catch (XmppStringprepException e) {
			if (exceptions != null) {
				exceptions.add(e);
			} else {
				throw new AssertionError(e);
			}
		}
	}
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public final boolean isParentOf(Jid jid) {
	EntityFullJid fullJid = jid.asEntityFullJidIfPossible();
	if (fullJid != null) {
		return isParentOf(fullJid);
	}
	EntityBareJid bareJid = jid.asEntityBareJidIfPossible();
	if (bareJid != null) {
		return isParentOf(bareJid);
	}
	DomainFullJid domainFullJid = jid.asDomainFullJidIfPossible();
	if (domainFullJid != null) {
		return isParentOf(domainFullJid);
	}

	return isParentOf(jid.asDomainBareJid());
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
/**
 * Get a {@link Jid} from the given parts.
 * <p>
 * Only the domainpart is required.
 * </p>
 *
 * @param localpart a optional localpart.
 * @param domainpart a required domainpart.
 * @param resource a optional resourcepart.
 * @return a JID which consists of the given parts.
 * @throws XmppStringprepException if an error occurs.
 */
public static Jid from(String localpart, String domainpart, String resource) throws XmppStringprepException {
	String jidString = XmppStringUtils.completeJidFrom(localpart, domainpart, resource);
	Jid jid = JID_CACHE.lookup(jidString);
	if (jid != null) {
		return jid;
	}
	if (localpart.length() > 0 && domainpart.length() > 0 && resource.length() > 0) {
		jid = new LocalDomainAndResourcepartJid(localpart, domainpart, resource);
	} else if (localpart.length() > 0 && domainpart.length() > 0 && resource.length() == 0) {
		jid = new LocalAndDomainpartJid(localpart, domainpart);
	} else if (localpart.length() == 0 && domainpart.length() > 0 && resource.length() == 0) {
		jid = new DomainpartJid(domainpart);
	} else if (localpart.length() == 0 && domainpart.length() > 0 && resource.length() > 0) {
		jid = new DomainAndResourcepartJid(domainpart, resource);
	} else {
		throw new IllegalArgumentException("Not a valid combination of localpart, domainpart and resource");
	}
	JID_CACHE.put(jidString, jid);
	return jid;
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
@Override
public void newConnection(XMPPConnection connection) {
	mConnection = connection;
	mRoster = Roster.getInstanceFor(connection);
	mRoster.addRosterListener(this);

	mRoster.addSubscribeListener(new SubscribeListener() {
		@Override
		public SubscribeAnswer processSubscribe(Jid from, Presence subscribeRequest) {
			Set<EntityBareJid> masterJids = mSettings.getMasterJids();
			for (EntityBareJid masterJid : masterJids) {
				if (masterJid.equals(from)) {
					return SubscribeAnswer.Approve;
				}
			}
			return SubscribeAnswer.Deny;
		}
	});
}
 

import org.jxmpp.jid.Jid; //导入依赖的package包/类
public void send(Jid to, String body) {
	switch (mState) {
	case Disconnected:
	case Disconnecting:
		LOG.w("Transport is disconnected, not going to send message to " + to);
		return;
	default:
		break;
	}
	if (!shouldUseXmppConnection()) {
		LOG.w("Connection is not connected and no resumption possible, not going to send message to "
				+ to);
		return;
	}
	Message message = new Message();
	message.setTo(to);
	message.setBody(body);
	try {
		mConnection.sendStanza(message);
	} catch (InterruptedException | NotConnectedException e) {
		LOG.w("send", e);
	}
}