void QDeclarativeBluetoothService::componentComplete()
{
d->m_componentComplete = true;
if(d->m_needsRegistration)
setRegistered(true);
}
void Client::connect() {
if (sock) {
BufferedSocket::putSocket(sock);
sock = 0;
}
redirectUrl = Util::emptyString;
setAutoReconnect(true);
setReconnDelay(120 + Util::rand(0, 60));
reloadSettings(true);
setRegistered(false);
setMyIdentity(Identity(ClientManager::getInstance()->getMe(), 0));
setHubIdentity(Identity());
setConnectState(STATE_CONNECTING);
try {
sock = BufferedSocket::getSocket(separator, v4only());
sock->addListener(this);
sock->connect(Socket::AddressInfo(address, Socket::AddressInfo::TYPE_URL), port, secure, SETTING(ALLOW_UNTRUSTED_HUBS), true, keyprint /**/);
} catch (const Exception& e) {
setConnectState(STATE_DISCONNECTED);
fire(ClientListener::Failed(), hubUrl, e.getError());
}
updateActivity();
}
void QDeclarativeBluetoothService::componentComplete()
{
d->m_componentComplete = true;
if (!d->m_service->isRegistered())
setRegistered(true);
}
void Client::connect() {
if(socket)
BufferedSocket::putSocket(socket);
setAutoReconnect(true);
setReconnDelay(120 + Util::rand(0, 60));
reloadSettings(true);
setRegistered(false);
setMyIdentity(Identity(ClientManager::getInstance()->getMe(), 0));
setHubIdentity(Identity());
try {
socket = BufferedSocket::getSocket(separator);
socket->addListener(this);
socket->connect(address, port, secure, BOOLSETTING(ALLOW_UNTRUSTED_HUBS), true);
} catch(const Exception& e) {
if(socket) {
BufferedSocket::putSocket(socket);
socket = 0;
}
fire(ClientListener::Failed(), this, e.getError());
}
updateActivity();
state = STATE_CONNECTING;
}
void EventDispatcher::removeEventListenersForListenerID(const EventListener::ListenerID& listenerID)
{
auto listenerItemIter = _listeners.find(listenerID);
if (listenerItemIter != _listeners.end())
{
auto listeners = listenerItemIter->second;
auto fixedPriorityListeners = listeners->getFixedPriorityListeners();
auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();
auto removeAllListenersInVector = [&](std::vector<EventListener*>* listenerVector){
if (listenerVector == nullptr)
return;
for (auto iter = listenerVector->begin(); iter != listenerVector->end();)
{
auto l = *iter;
l->setRegistered(false);
if (l->getSceneGraphPriority() != nullptr)
{
dissociateNodeAndEventListener(l->getSceneGraphPriority(), l);
}
if (_inDispatch == 0)
{
iter = listenerVector->erase(iter);
CC_SAFE_RELEASE(l);
}
else
{
++iter;
}
}
};
removeAllListenersInVector(sceneGraphPriorityListeners);
removeAllListenersInVector(fixedPriorityListeners);
if (!_inDispatch)
{
listeners->clear();
delete listeners;
_listeners.erase(listenerItemIter);
_priorityDirtyFlagMap.erase(listenerID);
}
}
for (auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end();)
{
if ((*iter)->getListenerID() == listenerID)
{
(*iter)->release();
iter = _toAddedListeners.erase(iter);
}
else
{
++iter;
}
}
}
void QDeclarativeBluetoothService::setServicePort(qint32 port)
{
if(d->m_port != port){
d->m_port = port;
if(isRegistered())
setRegistered(true);
emit detailsChanged();
}
}
void MainWindow::whenPhoneStatusReceived(const QString &phone, bool registered, bool invited)
{
if (phone == ui->phoneNumber->text()) {
QString registeredText = registered ? tr("Registered") : tr("Not registered");
QString invitedText = invited ? tr("invited") : tr("not invited");
ui->phoneStatus->setText(QString(QLatin1String("%1, %2")).arg(registeredText).arg(invitedText));
setRegistered(registered);
} else {
qDebug() << "Warning: Received status for different phone number" << phone << registered << invited;
}
}
void
SocketWrapper::closeSocket()
{
if (INVALID_SOCKET == sock) {
HAGGLE_ERR("Cannot close non-open socket\n");
return;
}
if (isRegistered()) {
kernel->unregisterWatchable(sock);
}
CLOSE_SOCKET(sock);
sock = INVALID_SOCKET;
setRegistered(false);
}
void NmdcHub::connect() {
setRegistered(false);
reconnect = true;
supportFlags = 0;
lastMyInfo.clear();
if(socket->isConnected()) {
disconnect();
}
state = STATE_LOCK;
if(getPort() == 0) {
setPort(411);
}
socket->connect(getAddress(), getPort());
}
bool
SocketWrapper::registerSocket()
{
if (sock == INVALID_SOCKET) {
HAGGLE_ERR("Cannot register invalid socket\n");
return false;
}
if (isRegistered()) {
HAGGLE_ERR("Socket already registered\n");
return false;
}
if (0 >= kernel->registerWatchable(sock, manager)) {
HAGGLE_ERR("Could not register socket with kernel\n");
return false;
}
setRegistered(true);
return true;
}
void ClientStatus::checkSDKPropertiesForUpdates()
{
HashDigest truePropertiesHash = getPropertiesHash();
HashDigest storedPropertiesHash;
auto parameter_it = parameters_.find(ClientParameterT::PROPERTIES_HASH);
if (parameter_it != parameters_.end()) {
storedPropertiesHash = boost::any_cast<HashDigest>(parameter_it->second->getValue());
}
if (truePropertiesHash != storedPropertiesHash) {
setRegistered(false);
auto it = parameters_.find(ClientParameterT::PROPERTIES_HASH);
if (it != parameters_.end()) {
it->second->setValue(truePropertiesHash);
}
isSDKPropertiesForUpdated_ = true;
KAA_LOG_INFO("SDK properties were updated");
} else {
KAA_LOG_INFO("SDK properties are up to date");
}
}
void Client::connect() {
if(sock)
BufferedSocket::putSocket(sock);
setAutoReconnect(true);
setReconnDelay(SETTING(RECONNECT_DELAY));
reloadSettings(true);
setRegistered(false);
setMyIdentity(Identity(ClientManager::getInstance()->getMe(), 0));
setHubIdentity(Identity());
state = STATE_CONNECTING;
try {
sock = BufferedSocket::getSocket(separator);
sock->addListener(this);
sock->connect(address, port, secure, BOOLSETTING(ALLOW_UNTRUSTED_HUBS), true);
} catch(const Exception& e) {
shutdown();
/// @todo at this point, this hub instance is completely useless
fire(ClientListener::Failed(), this, e.getError());
}
updateActivity();
}
void NmdcHub::onLine(const string& aLine) throw() {
lastActivity = GET_TICK();
if(aLine.length() == 0)
return;
if(aLine[0] != '$') {
// Check if we're being banned...
if(state != STATE_CONNECTED) {
if(Util::findSubString(aLine, "banned") != string::npos) {
reconnect = false;
}
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::Message(), this, Util::validateMessage(fromNmdc(aLine), true));
return;
}
string cmd;
string param;
string::size_type x;
if( (x = aLine.find(' ')) == string::npos) {
cmd = aLine;
} else {
cmd = aLine.substr(0, x);
param = aLine.substr(x+1);
}
if(cmd == "$Search") {
if(state != STATE_CONNECTED) {
return;
}
string::size_type i = 0;
string::size_type j = param.find(' ', i);
if(j == string::npos || i == j)
return;
string seeker = fromNmdc(param.substr(i, j-i));
// Filter own searches
if(SETTING(CONNECTION_TYPE) == SettingsManager::CONNECTION_ACTIVE) {
if(seeker == (getLocalIp() + ":" + Util::toString(SETTING(IN_PORT)))) {
return;
}
} else {
// Hub:seeker
if(Util::stricmp(seeker.c_str() + 4, getNick().c_str()) == 0) {
return;
}
}
i = j + 1;
{
Lock l(cs);
u_int32_t tick = GET_TICK();
seekers.push_back(make_pair(seeker, tick));
// First, check if it's a flooder
FloodIter fi;
for(fi = flooders.begin(); fi != flooders.end(); ++fi) {
if(fi->first == seeker) {
return;
}
}
int count = 0;
for(fi = seekers.begin(); fi != seekers.end(); ++fi) {
if(fi->first == seeker)
count++;
if(count > 7) {
if(seeker.compare(0, 4, "Hub:") == 0)
Speaker<NmdcHubListener>::fire(NmdcHubListener::SearchFlood(), this, seeker.substr(4));
else
Speaker<NmdcHubListener>::fire(NmdcHubListener::SearchFlood(), this, seeker + STRING(NICK_UNKNOWN));
flooders.push_back(make_pair(seeker, tick));
return;
}
}
}
int a;
if(param[i] == 'F') {
a = SearchManager::SIZE_DONTCARE;
} else if(param[i+2] == 'F') {
a = SearchManager::SIZE_ATLEAST;
} else {
a = SearchManager::SIZE_ATMOST;
}
i += 4;
j = param.find('?', i);
if(j == string::npos || i == j)
return;
string size = param.substr(i, j-i);
i = j + 1;
j = param.find('?', i);
if(j == string::npos || i == j)
return;
int type = Util::toInt(param.substr(i, j-i)) - 1;
i = j + 1;
param = param.substr(i);
if(param.size() > 0) {
Speaker<NmdcHubListener>::fire(NmdcHubListener::Search(), this, seeker, a, Util::toInt64(size), type, fromNmdc(param));
if(seeker.compare(0, 4, "Hub:") == 0) {
User::Ptr u;
{
Lock l(cs);
User::NickIter ni = users.find(seeker.substr(4));
if(ni != users.end() && !ni->second->isSet(User::PASSIVE)) {
u = ni->second;
u->setFlag(User::PASSIVE);
}
}
if(u) {
updated(u);
}
}
}
} else if(cmd == "$MyINFO") {
string::size_type i, j;
i = 5;
j = param.find(' ', i);
if( (j == string::npos) || (j == i) )
return;
string nick = fromNmdc(param.substr(i, j-i));
i = j + 1;
User::Ptr u;
dcassert(nick.size() > 0);
{
Lock l(cs);
User::NickIter ni = users.find(nick);
if(ni == users.end()) {
u = users[nick] = ClientManager::getInstance()->getUser(nick, this);
} else {
u = ni->second;
}
}
j = param.find('$', i);
if(j == string::npos)
return;
string tmpDesc = Util::validateMessage(fromNmdc(param.substr(i, j-i)), true);
// Look for a tag...
if(tmpDesc.size() > 0 && tmpDesc[tmpDesc.size()-1] == '>') {
x = tmpDesc.rfind('<');
if(x != string::npos) {
// Hm, we have something...
u->setTag(tmpDesc.substr(x));
tmpDesc.erase(x);
} else {
u->setTag(Util::emptyString);
}
} else {
u->setTag(Util::emptyString);
}
u->setDescription(tmpDesc);
i = j + 3;
j = param.find('$', i);
if(j == string::npos)
return;
u->setConnection(fromNmdc(param.substr(i, j-i-1)));
i = j + 1;
j = param.find('$', i);
if(j == string::npos)
return;
u->setEmail(Util::validateMessage(fromNmdc(param.substr(i, j-i)), true));
i = j + 1;
j = param.find('$', i);
if(j == string::npos)
return;
u->setBytesShared(param.substr(i, j-i));
Speaker<NmdcHubListener>::fire(NmdcHubListener::MyInfo(), this, u);
} else if(cmd == "$Quit") {
if(!param.empty()) {
User::Ptr u;
{
Lock l(cs);
User::NickIter i = users.find(fromNmdc(param));
if(i == users.end()) {
dcdebug("C::onLine Quitting user %s not found\n", param.c_str());
return;
}
u = i->second;
users.erase(i);
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::Quit(), this, u);
ClientManager::getInstance()->putUserOffline(u, true);
}
} else if(cmd == "$ConnectToMe") {
if(state != STATE_CONNECTED) {
return;
}
string::size_type i = param.find(' ');
string::size_type j;
if( (i == string::npos) || ((i + 1) >= param.size()) ) {
return;
}
i++;
j = param.find(':', i);
if(j == string::npos) {
return;
}
string server = fromNmdc(param.substr(i, j-i));
if(j+1 >= param.size()) {
return;
}
string port = param.substr(j+1);
ConnectionManager::getInstance()->connect(server, (short)Util::toInt(port), getNick());
Speaker<NmdcHubListener>::fire(NmdcHubListener::ConnectToMe(), this, server, (short)Util::toInt(port));
} else if(cmd == "$RevConnectToMe") {
if(state != STATE_CONNECTED) {
return;
}
User::Ptr u;
bool up = false;
{
Lock l(cs);
string::size_type j = param.find(' ');
if(j == string::npos) {
return;
}
User::NickIter i = users.find(fromNmdc(param.substr(0, j)));
if(i == users.end()) {
return;
}
u = i->second;
if(!u->isSet(User::PASSIVE)) {
u->setFlag(User::PASSIVE);
up = true;
}
}
if(u) {
if(SETTING(CONNECTION_TYPE) == SettingsManager::CONNECTION_ACTIVE) {
connectToMe(u);
Speaker<NmdcHubListener>::fire(NmdcHubListener::RevConnectToMe(), this, u);
} else {
// Notify the user that we're passive too...
if(up)
revConnectToMe(u);
}
if(up)
updated(u);
}
} else if(cmd == "$SR") {
SearchManager::getInstance()->onSearchResult(aLine);
} else if(cmd == "$HubName") {
name = fromNmdc(param);
Speaker<NmdcHubListener>::fire(NmdcHubListener::HubName(), this);
} else if(cmd == "$Supports") {
StringTokenizer<string> st(param, ' ');
StringList& sl = st.getTokens();
for(StringIter i = sl.begin(); i != sl.end(); ++i) {
if(*i == "UserCommand") {
supportFlags |= SUPPORTS_USERCOMMAND;
} else if(*i == "NoGetINFO") {
supportFlags |= SUPPORTS_NOGETINFO;
} else if(*i == "UserIP2") {
supportFlags |= SUPPORTS_USERIP2;
}
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::Supports(), this, sl);
} else if(cmd == "$UserCommand") {
string::size_type i = 0;
string::size_type j = param.find(' ');
if(j == string::npos)
return;
int type = Util::toInt(param.substr(0, j));
i = j+1;
if(type == UserCommand::TYPE_SEPARATOR || type == UserCommand::TYPE_CLEAR) {
int ctx = Util::toInt(param.substr(i));
Speaker<NmdcHubListener>::fire(NmdcHubListener::UserCommand(), this, type, ctx, Util::emptyString, Util::emptyString);
} else if(type == UserCommand::TYPE_RAW || type == UserCommand::TYPE_RAW_ONCE) {
j = param.find(' ', i);
if(j == string::npos)
return;
int ctx = Util::toInt(param.substr(i));
i = j+1;
j = param.find('$');
if(j == string::npos)
return;
string name = fromNmdc(param.substr(i, j-i));
i = j+1;
string command = fromNmdc(param.substr(i, param.length() - i));
Speaker<NmdcHubListener>::fire(NmdcHubListener::UserCommand(), this, type, ctx, Util::validateMessage(name, true, false), Util::validateMessage(command, true, false));
}
} else if(cmd == "$Lock") {
if(state != STATE_LOCK) {
return;
}
state = STATE_HELLO;
if(!param.empty()) {
string::size_type j = param.find(" Pk=");
string lock, pk;
if( j != string::npos ) {
lock = param.substr(0, j);
pk = param.substr(j + 4);
} else {
// Workaround for faulty linux hubs...
j = param.find(" ");
if(j != string::npos)
lock = param.substr(0, j);
else
lock = param;
}
if(CryptoManager::getInstance()->isExtended(lock)) {
StringList feat;
feat.push_back("UserCommand");
feat.push_back("NoGetINFO");
feat.push_back("NoHello");
feat.push_back("UserIP2");
feat.push_back("TTHSearch");
if(BOOLSETTING(COMPRESS_TRANSFERS))
feat.push_back("GetZBlock");
supports(feat);
}
key(CryptoManager::getInstance()->makeKey(lock));
validateNick(getNick());
Speaker<NmdcHubListener>::fire(NmdcHubListener::CLock(), this, lock, pk);
}
} else if(cmd == "$Hello") {
if(!param.empty()) {
string nick = fromNmdc(param);
User::Ptr u = ClientManager::getInstance()->getUser(nick, this);
{
Lock l(cs);
users[nick] = u;
}
if(getNick() == nick) {
setMe(u);
u->setFlag(User::DCPLUSPLUS);
if(SETTING(CONNECTION_TYPE) != SettingsManager::CONNECTION_ACTIVE)
u->setFlag(User::PASSIVE);
else
u->unsetFlag(User::PASSIVE);
}
if(state == STATE_HELLO) {
state = STATE_CONNECTED;
updateCounts(false);
version();
getNickList();
myInfo();
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::Hello(), this, u);
}
} else if(cmd == "$ForceMove") {
disconnect();
Speaker<NmdcHubListener>::fire(NmdcHubListener::Redirect(), this, param);
} else if(cmd == "$HubIsFull") {
Speaker<NmdcHubListener>::fire(NmdcHubListener::HubFull(), this);
} else if(cmd == "$ValidateDenide") { // Mind the spelling...
disconnect();
Speaker<NmdcHubListener>::fire(NmdcHubListener::ValidateDenied(), this);
} else if(cmd == "$UserIP") {
if(!param.empty()) {
User::List v;
StringTokenizer<string> t(fromNmdc(param), "$$");
StringList& l = t.getTokens();
for(StringIter it = l.begin(); it != l.end(); ++it) {
string::size_type j = 0;
if((j = it->find(' ')) == string::npos)
continue;
if((j+1) == it->length())
continue;
v.push_back(ClientManager::getInstance()->getUser(it->substr(0, j), this));
v.back()->setIp(it->substr(j+1));
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::UserIp(), this, v);
}
} else if(cmd == "$NickList") {
if(!param.empty()) {
User::List v;
StringTokenizer<string> t(fromNmdc(param), "$$");
StringList& sl = t.getTokens();
for(StringIter it = sl.begin(); it != sl.end(); ++it) {
v.push_back(ClientManager::getInstance()->getUser(*it, this));
}
{
Lock l(cs);
for(User::Iter it2 = v.begin(); it2 != v.end(); ++it2) {
users[(*it2)->getNick()] = *it2;
}
}
if(!(getSupportFlags() & SUPPORTS_NOGETINFO)) {
string tmp;
// Let's assume 10 characters per nick...
tmp.reserve(v.size() * (11 + 10 + getNick().length()));
for(User::List::const_iterator i = v.begin(); i != v.end(); ++i) {
tmp += "$GetINFO ";
tmp += (*i)->getNick();
tmp += ' ';
tmp += getNick();
tmp += '|';
}
if(!tmp.empty()) {
send(tmp);
}
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::NickList(), this, v);
}
} else if(cmd == "$OpList") {
if(!param.empty()) {
User::List v;
StringTokenizer<string> t(fromNmdc(param), "$$");
StringList& sl = t.getTokens();
for(StringIter it = sl.begin(); it != sl.end(); ++it) {
v.push_back(ClientManager::getInstance()->getUser(*it, this));
v.back()->setFlag(User::OP);
}
{
Lock l(cs);
for(User::Iter it2 = v.begin(); it2 != v.end(); ++it2) {
users[(*it2)->getNick()] = *it2;
}
}
Speaker<NmdcHubListener>::fire(NmdcHubListener::OpList(), this, v);
updateCounts(false);
// Special...to avoid op's complaining that their count is not correctly
// updated when they log in (they'll be counted as registered first...)
myInfo();
}
} else if(cmd == "$To:") {
string::size_type i = param.find("From:");
if(i != string::npos) {
i+=6;
string::size_type j = param.find("$");
if(j != string::npos) {
string from = fromNmdc(param.substr(i, j - 1 - i));
if(from.size() > 0 && param.size() > (j + 1)) {
Speaker<NmdcHubListener>::fire(NmdcHubListener::PrivateMessage(), this, ClientManager::getInstance()->getUser(from, this, false), Util::validateMessage(fromNmdc(param.substr(j + 1)), true));
}
}
}
} else if(cmd == "$GetPass") {
setRegistered(true);
Speaker<NmdcHubListener>::fire(NmdcHubListener::GetPassword(), this);
} else if(cmd == "$BadPass") {
Speaker<NmdcHubListener>::fire(NmdcHubListener::BadPassword(), this);
} else if(cmd == "$LogedIn") {
Speaker<NmdcHubListener>::fire(NmdcHubListener::LoggedIn(), this);
} else {
dcassert(cmd[0] == '$');
dcdebug("NmdcHub::onLine Unknown command %s\n", aLine.c_str());
}
}
void EventDispatcher::removeEventListener(EventListener* listener)
{
if (listener == nullptr)
return;
bool isFound = false;
auto removeListenerInVector = [&](std::vector<EventListener*>* listeners){
if (listeners == nullptr)
return;
for (auto iter = listeners->begin(); iter != listeners->end(); ++iter)
{
auto l = *iter;
if (l == listener)
{
CC_SAFE_RETAIN(l);
l->setRegistered(false);
if (l->getAssociatedNode() != nullptr)
{
dissociateNodeAndEventListener(l->getAssociatedNode(), l);
l->setAssociatedNode(nullptr); // nullptr out the node pointer so we don't have any dangling pointers to destroyed nodes.
}
if (_inDispatch == 0)
{
iter = listeners->erase(iter);
releaseListener(l);
}
else
{
_toRemovedListeners.push_back(l);
}
isFound = true;
break;
}
}
};
for (auto iter = _listenerMap.begin(); iter != _listenerMap.end();)
{
auto listeners = iter->second;
auto fixedPriorityListeners = listeners->getFixedPriorityListeners();
auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();
removeListenerInVector(sceneGraphPriorityListeners);
if (isFound)
{
// fixed #4160: Dirty flag need to be updated after listeners were removed.
setDirty(listener->getListenerID(), DirtyFlag::SCENE_GRAPH_PRIORITY);
}
else
{
removeListenerInVector(fixedPriorityListeners);
if (isFound)
{
setDirty(listener->getListenerID(), DirtyFlag::FIXED_PRIORITY);
}
}
#if CC_NODE_DEBUG_VERIFY_EVENT_LISTENERS
CCASSERT(_inDispatch != 0 ||
!sceneGraphPriorityListeners ||
std::count(sceneGraphPriorityListeners->begin(), sceneGraphPriorityListeners->end(), listener) == 0,
"Listener should be in no lists after this is done if we're not currently in dispatch mode.");
CCASSERT(_inDispatch != 0 ||
!fixedPriorityListeners ||
std::count(fixedPriorityListeners->begin(), fixedPriorityListeners->end(), listener) == 0,
"Listener should be in no lists after this is done if we're not currently in dispatch mode.");
#endif
if (iter->second->empty())
{
_priorityDirtyFlagMap.erase(listener->getListenerID());
auto list = iter->second;
iter = _listenerMap.erase(iter);
CC_SAFE_DELETE(list);
}
else
{
++iter;
}
if (isFound)
break;
}
if (isFound)
{
releaseListener(listener);
}
else
{
for(auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end(); ++iter)
{
if (*iter == listener)
{
listener->setRegistered(false);
releaseListener(listener);
_toAddedListeners.erase(iter);
break;
}
}
}
}
void EventDispatcher::removeEventListenersForListenerID(const EventListener::ListenerID& listenerID)
{
auto listenerItemIter = _listenerMap.find(listenerID);
if (listenerItemIter != _listenerMap.end())
{
auto listeners = listenerItemIter->second;
auto fixedPriorityListeners = listeners->getFixedPriorityListeners();
auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();
auto removeAllListenersInVector = [&](std::vector<EventListener*>* listenerVector){
if (listenerVector == nullptr)
return;
for (auto iter = listenerVector->begin(); iter != listenerVector->end();)
{
auto l = *iter;
l->setRegistered(false);
if (l->getAssociatedNode() != nullptr)
{
dissociateNodeAndEventListener(l->getAssociatedNode(), l);
l->setAssociatedNode(nullptr); // nullptr out the node pointer so we don't have any dangling pointers to destroyed nodes.
}
if (_inDispatch == 0)
{
iter = listenerVector->erase(iter);
releaseListener(l);
}
else
{
++iter;
}
}
};
removeAllListenersInVector(sceneGraphPriorityListeners);
removeAllListenersInVector(fixedPriorityListeners);
// Remove the dirty flag according the 'listenerID'.
// No need to check whether the dispatcher is dispatching event.
_priorityDirtyFlagMap.erase(listenerID);
if (!_inDispatch)
{
listeners->clear();
delete listeners;
_listenerMap.erase(listenerItemIter);
}
}
for (auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end();)
{
if ((*iter)->getListenerID() == listenerID)
{
(*iter)->setRegistered(false);
releaseListener(*iter);
iter = _toAddedListeners.erase(iter);
}
else
{
++iter;
}
}
}
void MainWindow::setAppState(MainWindow::AppState newState)
{
m_appState = newState;
ui->confirmationCode->setEnabled(m_appState == AppStateCodeSent);
ui->setStatusOnline->setVisible(m_appState >= AppStateSignedIn);
ui->setStatusOffline->setVisible(m_appState >= AppStateSignedIn);
ui->phoneNumber->setEnabled(m_appState < AppStateCodeSent);
if (m_appState > AppStateSignedIn) {
ui->signButton->setText(tr("Log out"));
ui->signButton->setToolTip(tr("Destroy current auth session."));
} else {
setRegistered(m_registered);
}
switch (m_appState) {
case AppStateDisconnected:
ui->connectionState->setText(tr("Disconnected"));
// Fall throught
case AppStateNone:
ui->connectButton->setVisible(true);
ui->restoreSession->setVisible(true);
ui->phoneNumber->setEnabled(true);
ui->requestCode->setVisible(false);
ui->signButton->setVisible(false);
break;
case AppStateConnected:
ui->connectionState->setText(tr("Connected..."));
break;
case AppStateCodeRequired:
ui->connectionState->setText(tr("Auth required"));
ui->connectButton->setVisible(false);
ui->restoreSession->setVisible(false);
ui->requestCode->setVisible(true);
ui->signButton->setVisible(true);
break;
case AppStateCodeSent:
ui->connectionState->setText(tr("Code sent..."));
ui->confirmationCode->setFocus();
break;
case AppStateSignedIn:
ui->connectionState->setText(tr("Signed in..."));
ui->requestCode->setVisible(false);
ui->signButton->setVisible(true); // Logout button
ui->phoneNumber->setEnabled(false);
break;
case AppStateReady:
ui->connectionState->setText(tr("Ready"));
ui->requestCode->setVisible(false);
ui->signButton->setVisible(true); // Logout button
ui->phoneNumber->setEnabled(false);
break;
case AppStateLoggedOut:
ui->connectionState->setText(tr("Logged out"));
break;
default:
break;
}
}
void EventDispatcher::removeEventListener(EventListener* listener)
{
if (listener == nullptr)
return;
bool isFound = false;
auto removeListenerInVector = [&](std::vector<EventListener*>* listeners){
if (listeners == nullptr)
return;
for (auto iter = listeners->begin(); iter != listeners->end(); ++iter)
{
auto l = *iter;
if (l == listener)
{
CC_SAFE_RETAIN(l);
l->setRegistered(false);
if (l->getSceneGraphPriority() != nullptr)
{
dissociateNodeAndEventListener(l->getSceneGraphPriority(), l);
}
if (_inDispatch == 0)
{
listeners->erase(iter);
CC_SAFE_RELEASE(l);
}
isFound = true;
break;
}
}
};
for (auto iter = _listeners.begin(); iter != _listeners.end();)
{
auto listeners = iter->second;
auto fixedPriorityListeners = listeners->getFixedPriorityListeners();
auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();
removeListenerInVector(sceneGraphPriorityListeners);
if (!isFound)
{
removeListenerInVector(fixedPriorityListeners);
}
if (iter->second->empty())
{
_priorityDirtyFlagMap.erase(listener->getListenerID());
auto list = iter->second;
iter = _listeners.erase(iter);
CC_SAFE_DELETE(list);
}
else
{
++iter;
}
if (isFound)
break;
}
if (isFound)
{
CC_SAFE_RELEASE(listener);
}
else
{
for(auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end(); ++iter)
{
if (*iter == listener)
{
listener->release();
_toAddedListeners.erase(iter);
break;
}
}
}
}
void Feed::setAll(const char* allch) {
if (strlen(allch) <= 0) {
allch = "";
}
String all = allch;
int indexof = all.find(",");
if (indexof > -1) {
setUsername(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setEncrypt(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setUnsuccessful(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setReplaceWhiteSpaces(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setReplaceSpecialCharacters(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setCredits(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setEmail(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setHandle(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setTouch(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setSeconds(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setRegistered(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setNoteSeconds(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
setLoaded(true);
if ((getUsername().length() <= 0)||(getEncrypt().length() <= 0)) {
setUsername("");
setEncrypt("");
setLoaded(false);
}
} else {
setLoaded(false);
setUsername("");
setEncrypt("");
setUnsuccessful("");
setReplaceWhiteSpaces("");
setReplaceSpecialCharacters("");
setCredits("");
setEmail("");
setHandle("");
setTouch("false");
setRegistered("0");
setNoteLoaded(false);
setNoteSeconds("");
}
}
