1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the tools applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #ifndef LAUNCHER_H

    43 #define LAUNCHER_H

    44 

    45 #include "trkdevice.h"

    46 

    47 #include <QtCore/QObject>

    48 #include <QtCore/QVariant>

    49 #include <QtCore/QSharedPointer>

    50 

    51 namespace trk {

    52 

    53 struct TrkResult;

    54 struct TrkMessage;

    55 struct LauncherPrivate;

    56 

    57 typedef QSharedPointer<TrkDevice> TrkDevicePtr;

    58 

    59 class Launcher : public QObject

    60 {

    61     Q_OBJECT

    62     Q_DISABLE_COPY(Launcher)

    63 public:

    64     typedef void (Launcher::*TrkCallBack)(const TrkResult &);

    65 

    66     enum Actions {

    67         ActionPingOnly = 0x0,

    68         ActionCopy = 0x1,

    69         ActionInstall = 0x2,

    70         ActionCopyInstall = ActionCopy | ActionInstall,

    71         ActionRun = 0x4,

    72         ActionCopyRun = ActionCopy | ActionRun,

    73         ActionInstallRun = ActionInstall | ActionRun,

    74         ActionCopyInstallRun = ActionCopy | ActionInstall | ActionRun

    75     };

    76 

    77     enum State { Disconnected, Connecting, Connected,

    78                  WaitingForTrk, // This occurs only if the initial ping times out after

    79                                 // a reasonable timeout, indicating that Trk is not

    80                                 // running. Note that this will never happen with

    81                                 // Bluetooth as communication immediately starts

    82                                 // after connecting.

    83                  DeviceDescriptionReceived };

    84 

    85     explicit Launcher(trk::Launcher::Actions startupActions = trk::Launcher::ActionPingOnly,

    86                       const TrkDevicePtr &trkDevice = TrkDevicePtr(),

    87                       QObject *parent = 0);

    88     ~Launcher();

    89 

    90     State state() const;

    91 

    92     void addStartupActions(trk::Launcher::Actions startupActions);

    93     void setTrkServerName(const QString &name);

    94     QString trkServerName() const;

    95     void setFileName(const QString &name);

    96     void setCopyFileName(const QString &srcName, const QString &dstName);

    97     void setInstallFileName(const QString &name);

    98     void setCommandLineArgs(const QString &args);

    99     bool startServer(QString *errorMessage);

   100     void setVerbose(int v);    

   101     void setSerialFrame(bool b);

   102     bool serialFrame() const;

   103     // Close device or leave it open

   104     bool closeDevice() const;

   105     void setCloseDevice(bool c);

   106 

   107     TrkDevicePtr trkDevice() const;

   108 

   109     // becomes valid after successful execution of ActionPingOnly

   110     QString deviceDescription(unsigned verbose = 0u) const;

   111 

   112 signals:

   113     void copyingStarted();

   114     void canNotConnect(const QString &errorMessage);

   115     void canNotCreateFile(const QString &filename, const QString &errorMessage);

   116     void canNotWriteFile(const QString &filename, const QString &errorMessage);

   117     void canNotCloseFile(const QString &filename, const QString &errorMessage);

   118     void installingStarted();

   119     void canNotInstall(const QString &packageFilename, const QString &errorMessage);

   120     void installingFinished();

   121     void startingApplication();

   122     void applicationRunning(uint pid);

   123     void canNotRun(const QString &errorMessage);

   124     void finished();

   125     void applicationOutputReceived(const QString &output);

   126     void copyProgress(int percent);

   127     void stateChanged(int);

   128     void stopped(uint pc, uint pid, uint tid, const QString& reason);

   129 

   130 public slots:

   131     void terminate();

   132     void resume(uint pid, uint tid);

   133 

   134 private slots:

   135     void handleResult(const trk::TrkResult &data);

   136     void slotWaitingForTrk();

   137 

   138 private:

   139     // kill process and breakpoints

   140     void cleanUp();

   141     void disconnectTrk();

   142 

   143     void handleRemoteProcessKilled(const TrkResult &result);

   144     void handleConnect(const TrkResult &result);

   145     void handleFileCreation(const TrkResult &result);

   146     void handleCopy(const TrkResult &result);

   147     void continueCopying(uint lastCopiedBlockSize = 0);

   148     void closeRemoteFile(bool failed = false);

   149     void handleFileCopied(const TrkResult &result);

   150     void handleInstallPackageFinished(const TrkResult &result);

   151     void handleCpuType(const TrkResult &result);

   152     void handleCreateProcess(const TrkResult &result);

   153     void handleWaitForFinished(const TrkResult &result);

   154     void handleStop(const TrkResult &result);

   155     void handleSupportMask(const TrkResult &result);

   156     void handleTrkVersion(const TrkResult &result);

   157 

   158     void copyFileToRemote();

   159     void installRemotePackageSilently();

   160     void startInferiorIfNeeded();

   161 

   162     void logMessage(const QString &msg);

   163     void setState(State s);

   164 

   165     LauncherPrivate *d;

   166 };

   167 

   168 } // namespace Trk

   169 

   170 #endif // LAUNCHER_H