ripping.h

Go to the documentation of this file.

/*
    Copyright (C) 2008-2010  Lukas Sommer < SommerLuk at gmail dot com >

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef RIPPING_H
#define RIPPING_H

#include <QPointer>
#include "streamripper_base.h"
#include "propertyvalue.h"

class ripping : public streamripper_base
{

     Q_OBJECT

     Q_PROPERTY(PropertyValue bitrate READ bitrate)

     
     Q_PROPERTY(PropertyValue dataSize READ dataSize)

     Q_PROPERTY(PropertyValue error READ error)

     Q_PROPERTY(bool isRunning READ isRunning)

     Q_PROPERTY(PropertyValue metaInterval READ metaInterval)

     Q_PROPERTY(PropertyValue metaInterval_milliSeconds READ metaInterval_milliSeconds STORED false)

     Q_PROPERTY(PropertyValue relayPort READ relayPort)

     Q_PROPERTY(PropertyValue serverName READ serverName)

     Q_PROPERTY(PropertyValue song READ song)

     Q_PROPERTY(PropertyValue status READ status)

     Q_PROPERTY(PropertyValue streamName READ streamName)

  public:
     // typedefs
     enum statusType {
       idle,
       is_starting,
       is_connecting,
       is_buffering,
       is_skipping,
       is_ripping,
       is_saving };

     // contructor(s) and destructor(s)
     ripping(QObject *parent);
     virtual ~ripping();

     // properties
     virtual PropertyValue bitrate() const;
     virtual PropertyValue dataSize() const;
     bool doesTheUserWantsThatTheStreamIsRipping() const;
     virtual PropertyValue error() const;
     virtual bool isRunning() const;
     virtual PropertyValue metaInterval() const;
     virtual PropertyValue metaInterval_milliSeconds() const;
     virtual PropertyValue relayPort() const;
     virtual PropertyValue serverName() const;
     virtual PropertyValue song() const;
     virtual PropertyValue status() const;
     virtual PropertyValue streamName() const;

     // static functions
     static qint64 default_value_of_bitrate();
     static qint64 default_value_of_dataSize();
     static QString default_value_of_error();
     static bool default_value_of_isRunning();
     static qint64 default_value_of_metaInterval();
     static qint64 default_value_of_relayPort();
     static QString default_value_of_serverName();
     static QString default_value_of_song();
     static statusType default_value_of_status();
     static QString default_value_of_streamName();
     static bool doesTheUserWantsThatTheStreamIsRipping(const statusType theStatus);
     static PropertyValue formatedBitrate(const qint64 theBitrate);
     static PropertyValue formatedDataSize(const qint64 theDataSize);
     static PropertyValue formatedError(const QString & theError);
     static PropertyValue formatedMetaInterval(const qint64 theMetaInterval);
     static PropertyValue formatedMetaInterval_milliSeconds(
       const qint64 theMetaInterval_milliSeconds);
     static PropertyValue formatedRelayPort(const qint64 theRelayPort);
     static PropertyValue formatedServerName(const QString & theServerName);
     static PropertyValue formatedSong(const QString & theSong);
     static PropertyValue formatedStatus(const statusType theStatus);
     static PropertyValue formatedStreamName(const QString & theStreamName);

  signals:
     // properties
     void bitrateChanged(void *index, PropertyValue newBitrate);
     void dataSizeChanged(void *index, PropertyValue newDataSize);
     void errorChanged(void *index, PropertyValue newError);
     void metaIntervalChanged(void *index, PropertyValue newMetaInterval);
     void metaInterval_milliSecondsChanged(void *index,
                                           PropertyValue newMetaInterval_milliSeconds);
     void not_running();
     void relayPortChanged(void *index, PropertyValue newRelayPort);
     void running();
     void serverNameChanged(void *index, PropertyValue newServerName);
     void songChanged(void *index, PropertyValue newSong);
     void statusChanged(void *index, PropertyValue newStatus);
     void streamNameChanged(void *index, PropertyValue newStreamName);

  public slots:
     void shutDown();
     virtual void startStreamripper();

  protected:
     virtual void interpretate_console_output(QStringList & stringList);
     virtual QStringList parameterList() const;
     virtual void resetStreamripperProperties();
     virtual QString serverUri() const = 0;
     virtual void setBitrate(const qint64 newBitrate);
     virtual void setDataSize(const qint64 newDataSize);
     virtual void setError(const QString & newError);
     virtual void setMetaInterval(const qint64 newMetaInterval);
     virtual void setRelayPort(const qint64 newRelayPort);
     virtual void setServerName(const QString & newServerName);
     virtual void setSong(const QString & newSong);
     virtual void setStatus(const statusType newStatus);
     virtual void setStreamName(const QString & newStreamName);
     virtual QString streamripperCommand() const;
     virtual QString workingDirectory() const = 0;

  private:
     // help methods
     void helper_interpretate_metainfo_and_datasize(QString my_line);

     //properties
     PropertyValue internal_bitrate;
     PropertyValue internal_dataSize;
     PropertyValue internal_error;
     bool internal_isRunning;
     PropertyValue internal_metaInterval;
     PropertyValue internal_relayPort;
     PropertyValue internal_serverName;
     PropertyValue internal_song;
     PropertyValue internal_status;
     PropertyValue internal_streamName;

     qint64 lastRecognizedRelayPort;

  private slots:
     void emit_metaInterval_milliSecondsChanged();
     void errorOccured(const QProcess::ProcessError error);
     void refreshRelayPort();
     void streamripperStateChange(const QProcess::ProcessState newState);
 };

Q_DECLARE_METATYPE(ripping::statusType)

#endif