chatcore.cpp

用qt4 编写的局域网聊天工具

  buffer.close ();

  data.clear();
  buffer.setBuffer(&data);
  buffer.setData(QByteArray());

  if(pics_ok & 2)
    addParametr("PhotoOk", QByteArray());
  else
  {
    if((pix = m_myInfo->newPhotoImg()))
    {
//       if(pix->height() > 500)
//         pix->scaledToHeight(500).save(&buffer);
//       else
        pix->save(&buffer, "PNG", 100);
      delete pix;
    }
    addParametr("Photo"    , data);
    addParametr("PhotoHash", m_myInfo->photoHash());
  }

  addParametr("Status" , QByteArray().append((char)m_myInfo->status(name_id)));
  addParametr("Version", Globals::VersionStr.toUtf8());
  addParametr("Channel", name_id.toUtf8());
  addParametr("StatusDescription", UserInfo::myInfo()->statusDescription(name_id).toUtf8());

  prepareDatagramWrapper(AbstractChatCore::INFO_ANSWER, uid, QString(""), type);
  sendData(uid);
}
//\*****************************************************************************
void ChatCore::slot_requestFragments(char* fragments, quint32 len, quint32 id, quint64 uid)
{
  char buf[2];

  catUS2str(buf, len);

  qDebug("\n[ChatCore::slot_fragmentsRequest]:len = %lu, ID = %lu, addr = %s", (unsigned long)len, (unsigned long)id, QHostAddress(uid).toString().toLocal8Bit().data());

  clearParametrs();

  addParametr("FragmentsRequest", QByteArray(fragments, len));
  addParametr("FragmentsLen"    , QByteArray(buf      , 2));

  prepareDatagramWrapper(AbstractChatCore::FRAGMENTS_REQUEST, uid, QString(""), Common, id);

  sendData(uid);
}
//\*****************************************************************************
void ChatCore::slot_confirmReceivingFile(quint8 percents, quint16 dtgrmID, quint64 uid)
{
  prepareDatagramWrapper(AbstractChatCore::CONFIRM, uid, QString(""), Common, dtgrmID, percents);
  sendData(uid);
}
//\*****************************************************************************
void ChatCore::slot_acceptReceiving(quint16 dtgrmID, quint64 uid)
{
  qDebug("\n[ChatCore::slot_acceptReceiving] addr = %s", QHostAddress(uid).toString().toLocal8Bit().data());

  prepareDatagramWrapper(AbstractChatCore::ACCEPT, uid, QString(""), Common, dtgrmID, 0);
  sendData(uid);
}
//\*****************************************************************************
void ChatCore::slot_rejectReceiving(quint16 dtgrmID, quint64 uid, int reason)
{
  qDebug("\n[ChatCore::slot_rejectReceiving] addr = %s", QHostAddress(uid).toString().toLocal8Bit().data());

  prepareDatagramWrapper(AbstractChatCore::REJECT, uid, QString(""), Common, dtgrmID, reason);
  sendData(uid);
}
//\*****************************************************************************
void ChatCore::slot_privateChatRequest(const QString & name_id, quint64 uid)
{
  addParametr("Channel", name_id.toUtf8());
  prepareDatagramWrapper(AbstractChatCore::PRIVATE_CHAT_REQUEST, uid, QString(""));
  sendData(uid);
}

void ChatCore::processData()
{
  QString chnnl_name = QString().fromUtf8(getParametr("Channel", hdr()->parametrs));
  QString pl_name;

  UserInfo* info = m_chatWgt->findUser(hdr()->src_ip);
  quint64 src_ip = info ? info->ip() : 0;

  qDebug("[ChatCore::processData]: chnnl_name = %s", chnnl_name.toLocal8Bit().data());
  QDateTime dt;
  dt.setTime_t(hdr()->receive_tm);

  Message* msg = new Message(hdr(), src_ip);

  if(!filter()->validateMessage(msg))
  {
    delete msg;
    return;
  }

  delete msg;

  switch(hdr()->type)
  {
     case AbstractChatCore::SINGLE_MESSAGE :
     {
       SingleMessage* smsg = new SingleMessage(hdr(), src_ip);
       smsg->setIsIncoming(true);
       smsg->setNew();

       m_smhModel->addMessage(smsg);
       emit singleMessageIn(smsg, !getParametr("Important", hdr()->parametrs).isNull());
       break;
     }

     case AbstractChatCore::FILE:
       break;

     case AbstractChatCore::PRIVATE_CHAT_REQUEST:
       qDebug("[ChatCore::processData]: PRIVATE_CHAT_REQUEST chnnl_name = %s", chnnl_name.toLocal8Bit().data());
       privateChatRequest(chnnl_name, hdr()->src_ip);
       break;

     case AbstractChatCore::PLUGIN_DATA:
       pl_name = QString().fromUtf8(getParametr("PluginId", hdr()->parametrs));

       foreach(QObject* obj, m_chatWgt->m_allPlugins)
       {
         QChatWidgetPlugin* plug = qobject_cast<QChatWidgetPlugin*>(obj);
         QMap<QString, QByteArray> pars;

         if(plug)
           if(plug->name() == pl_name)
             plug->processData(getAllParametrs(hdr()->parametrs));
       }
       break;

     case AbstractChatCore::LOGIN_ACCEPTED:
       m_uid = hdr()->dest_ip;
       UserInfo::myInfo()->setNickname(hdr()->name);
       UserInfo::myInfo()->setUid(m_uid);

       if(m_loggedIn)
       {
         foreach(ChannelWgt* ch, m_chatWgt->channels())
           ch->sendStatusAnswer(0);
       }
       else
       {
         m_loggedIn = true;
         foreach(ChannelWgt* ch, m_chatWgt->channels())
         {
           ch->initChannel();
           ch->sendStatusAnswer(0);
         }
         emit loginFinished(0, hdr()->msg);
      }

     case AbstractChatCore::LOGIN_REJECTED:
       emit loginFinished(2, hdr()->msg);

     default:
     {
       emit chatDataReceived(hdr());
       newHdr();
       clearParametrs();
     }
  }
}
//\*****************************************************************************
void ChatCore::slot_processData(char* data, quint16 dataSize)
{
  setInputBuffer(data, dataSize);

  free(data);

  if(fillHeader())
    processData();
}
//\*****************************************************************************
void ChatCore::slot_processLargeData(LargeDatagram* dtgrm)
{
  Q_ASSERT(NULL != dtgrm);

  if(dtgrm->fillHeader(hdr()))
    processData();

  prepareDatagramWrapper(AbstractChatCore::FINISHED, dtgrm->destUid(), "", Common, dtgrm->id());

  sendData(dtgrm->destUid());
}
//\*****************************************************************************
void ChatCore::startThreads()
{
  qDebug("[ChatCore::startThreads]: begin");
  connect(this       , SIGNAL(wantSendFile(char*, quint16, const QString &, quint64, quint32)),
          m_sender   , SLOT  (addFileTask (char*, quint16, const QString &, quint64, quint32)));

  connect(this       , SIGNAL(wantSendLargeData(char*, quint16, char*, quint32, quint64, quint32)),
          m_sender   , SLOT  (addTask          (char*, quint16, char*, quint32, quint64, quint32)));

  m_sender  ->setPort(m_settings->intOption("OutputPort"));
  m_tcpReceiver->start();
  m_udpReceiver->start();
  m_sender     ->start();
  start();
  moveToThread(this);

//   sleep(1);

  initMode(Serverless, 1);

  qDebug("[ChatCore::startThreads]: end");
}
//\*****************************************************************************
void ChatCore::stopThreads()
{
  m_receiver->exit();
  m_sender->exit();
  exit();
}
//\*****************************************************************************
void ChatCore::slot_openSocketError(quint16 port)
{
  Globals::addError(QString("Couldn't open UDP socket on port %1 ").arg(port));
  qWarning("Couldn't open UDP socket on port %d\n", port);
}
//\*****************************************************************************
void ChatCore::slot_bindInputPort(int port)
{
  QChatSettings::settings()->setOption("InputPort", port);
  emit wantChangeInputPort(port);
}
//\*****************************************************************************
void ChatCore::slot_setNl(const QString & title, const QString & artist, const QString & album)
{
#if defined(Q_OS_LINUX)
  if(!title.isEmpty() || !artist.isEmpty() || !album.isEmpty())
  {
    m_nlTitle  = title;
    m_nlArtist = artist;
    m_nlAlbum  = album;

    m_nowListening = m_settings->strOption("NLFormat");
    m_nowListening.replace("%a", artist).replace("%b", album).replace("%t", title);

    m_nlIsNew = true;
  }
  else
    m_nowListening = "";

  m_settings->setNowListening(m_nowListening);

  if(m_settings->nlMode() & 2)
  {
    m_myInfo->setStatusDescription(m_chatWgt->currentChannelName(), m_nowListening);
    // FIXME incorrect works if other channel set its status in myInfo
    slot_statusAnswer(m_chatWgt->currentChannelName(), QChatSettings::settings()->broadcast().toIPv4Address(), Common, 0);
  }

#endif
}
//\*****************************************************************************
quint32 ChatCore::initSendingFile(quint64 uid, const QString & filename, QObject* ftw)
{
  clearParametrs();
  prepareDatagramWrapper(AbstractChatCore::FILE, uid);

  quint32 id = m_sender->getValidID();

  if(id)
  {
    qDebug("[ChatCore::sendFile]:str = %s", filename.right(filename.size() - 1 - filename.lastIndexOf("/")).toLocal8Bit().data());

    emit wantSendFile(header(), headerSize(), filename, uid, id);
    setNULLdataAndHeader();

    connect(m_receiver, SIGNAL(percentsConfirmed(quint8, quint16, quint64)),
            ftw       , SLOT  (slot_setProgress (quint8, quint16, quint64)));
    connect(m_receiver, SIGNAL(receivingRejected       (quint16)),
            ftw       , SLOT  (slot_rejectedByReceiver (quint16)));
    connect(m_receiver, SIGNAL(receivingCancelled      (quint16)),
            ftw       , SLOT  (slot_cancelledByReceiver(quint16)));
    connect(m_receiver, SIGNAL(receivingCancelled      (quint16)),
            m_sender  , SLOT  (slot_cancelTask         (quint16)));
    connect(m_sender  , SIGNAL(sendingCancelled        (quint16)),
            ftw       , SLOT  (slot_cannotSend         (quint16)));
    connect(m_sender  , SIGNAL(sendingFinished         (quint16)),
            ftw       , SLOT  (slot_sendingTimeout     (quint16)));
    connect(ftw       , SIGNAL(rejected            (quint16, quint64, int)),
            this      , SLOT  (slot_rejectReceiving(quint16, quint64, int)));// slot_rejectReceiving, but here it working such 'cancel Sending' :)
    connect(ftw       , SIGNAL(cancel         (quint16)),
            m_sender  , SLOT  (slot_cancelTask(quint16)));
  }

  return id;
}
//\*****************************************************************************
void ChatCore::initReceivingFile(QObject* obj)
{
  connect(m_receiver, SIGNAL(percentsRemain      (quint8, quint16, quint64)),
          obj       , SLOT  (slot_setProgress    (quint8, quint16, quint64)));

  connect(obj       , SIGNAL(accepted            (QString, quint16, quint64)),
          m_receiver, SLOT  (slot_acceptDatagram (QString, quint16, quint64)));

  connect(obj       , SIGNAL(rejected            (quint16, quint64, int)),
          m_receiver, SLOT  (slot_rejectDatagram (quint16, quint64)));

  connect(m_receiver, SIGNAL(readyReceive          (quint16, quint64)),
          this      , SLOT  (slot_acceptReceiving  (quint16, quint64)));

  connect(m_receiver, SIGNAL(sendingCancelled      (quint16, quint64)),
          obj       , SLOT  (slot_cancelledBySender(quint16, quint64)));

  connect(obj       , SIGNAL(rejected            (quint16, quint64, int)),
          this      , SLOT  (slot_rejectReceiving(quint16, quint64, int)));

  connect(m_receiver, SIGNAL(percentsRemain           (quint8, quint16, quint64)),
          this      , SLOT  (slot_confirmReceivingFile(quint8, quint16, quint64)));

  connect(m_receiver, SIGNAL(receivingTimeout     (quint16, quint64)),
          obj       , SLOT  (slot_receivingTimeout(quint16, quint64)));
}
//\*****************************************************************************
void ChatCore::slot_loadProfile(const QString & name)
{
  UserProfile* profile = m_profiles[name];
  QByteArray   data;
  QImage       pix;

  if(profile)
  {
    qDebug("[ChatCore::loadProfile]: %s", name.toLocal8Bit().data());

    m_currentProfile = profile;

    m_myInfo   = profile->info();
    m_settings = profile->prefs();

    m_myInfo->setCompName(QHostInfo::localHostName());

    UserInfo::setMyInfo(m_myInfo);
    QChatSettings::setSettings(m_settings);
  }

  else
  {
    m_myInfo   = new UserInfo;
    m_settings = new QChatSettings;
    profile    = new UserProfile(name, m_settings, m_myInfo);

    m_currentProfile = profile;

    UserInfo::setMyInfo(m_myInfo);
    QChatSettings::setSettings(m_settings);

    m_profiles.insert(name, profile);

    m_myInfo->setNickname(name);
  }

  QChatSettings::setProfileName(name);

  emit profileLoaded(name);
}
//\*****************************************************************************
QStringList ChatCore::profiles() const
{
  QStringList profiles;
  QMapIterator<QString, UserProfile*> i(m_profiles);

  while (i.hasNext())
  {
    i.next();
    profiles << i.key();
  }

  return profiles;
}
//\*****************************************************************************
const QString & ChatCore::currentProfile() const
{
  return m_currentProfile->name();
}
//\*****************************************************************************
void ChatCore::slot_renameProfile(const QString & old_name, const QString & new_name)
{