C++ QSimCommand类代码示例

void DemoSimApplication::toneMenu( const QSimTerminalResponse& resp )
{
    QSimCommand cmd;

    if ( resp.result() == QSimTerminalResponse::Success ) {
        // Item selected.
        cmd.setType( QSimCommand::PlayTone );
        cmd.setDestinationDevice( QSimCommand::Earpiece );
        cmd.setTone( (QSimCommand::Tone)( resp.menuItem() ) );
        if ( cmd.tone() == QSimCommand::ToneDial )
            cmd.setDuration( 5000 );
        else if ( cmd.tone() == QSimCommand::ToneGeneralBeep ||
                  cmd.tone() == QSimCommand::TonePositiveBeep ||
                  cmd.tone() == QSimCommand::ToneNegativeBeep )
            cmd.setDuration( 1000 );
        else
            cmd.setDuration( 3000 );
        command( cmd, this, SLOT(sendToneMenu()) );
    } else if ( resp.result() == QSimTerminalResponse::BackwardMove ) {
        // Request to move backward.
        mainMenu();
    } else {
        // Unknown response - just go back to the main menu.
        mainMenu();
    }
}

void DemoSimApplication::sendBrowserMenu()
{
    QSimCommand cmd;
    QSimMenuItem item;
    QList<QSimMenuItem> items;

    cmd.setType( QSimCommand::SelectItem );
    cmd.setTitle( "Web Browser" );

    item.setIdentifier( 1 );
    item.setLabel( "Qt Extended" );
    items += item;

    item.setIdentifier( 2 );
    item.setLabel( "Google (normal)" );
    items += item;

    item.setIdentifier( 3 );
    item.setLabel( "Google (if browser not in use)" );
    items += item;

    item.setIdentifier( 4 );
    item.setLabel( "Google (clear history)" );
    items += item;

    item.setIdentifier( 5 );
    item.setLabel( "Default Home Page" );
    items += item;

    cmd.setMenuItems( items );

    command( cmd, this, SLOT(browserMenu(QSimTerminalResponse)) );
}

void DemoSimApplication::sendSportsMenu()
{
    QSimCommand cmd;
    QSimMenuItem item;
    QList<QSimMenuItem> items;

    cmd.setType( QSimCommand::SelectItem );
    cmd.setTitle( "Sports" );

    item.setIdentifier( SportsMenu_Chess );
    item.setLabel( "Chess" );
    items += item;

    item.setIdentifier( SportsMenu_Painting );
    item.setLabel( "Finger Painting" );
    items += item;

    item.setIdentifier( SportsMenu_Snakes );
    item.setLabel( "Snakes and Ladders" );
    items += item;

    item.setIdentifier( SportsMenu_Main );
    item.setLabel( "Return to main menu" );
    items += item;

    cmd.setMenuItems( items );

    command( cmd, this, SLOT(sportsMenu(QSimTerminalResponse)) );
}

void DemoSimApplication::sendIconSEMenu()
{
    QSimCommand cmd;
    QSimMenuItem item;
    QList<QSimMenuItem> items;

    cmd.setType( QSimCommand::SelectItem );
    cmd.setTitle( "Icons SE" );

    item.setIdentifier( 1 );
    item.setLabel( "Basic Icon" );
    item.setIconId( 1 );
    item.setIconSelfExplanatory( true );
    items += item;

    item.setIdentifier( 2 );
    item.setLabel( "Color Icon" );
    item.setIconId( 2 );
    item.setIconSelfExplanatory( true );
    items += item;

    item.setIdentifier( 3 );
    item.setLabel( "Bad Icon" );
    item.setIconId( 70 );
    item.setIconSelfExplanatory( true );
    items += item;

    cmd.setMenuItems( items );

    command( cmd, this, SLOT(iconSEMenu(QSimTerminalResponse)) );
}

bool SimApp::listViewPreferred(const QSimCommand& cmd)
{
    if (!cmd.softKeysPreferred())
        return true;
    // reserve one key for back button
    if ((QSoftMenuBar::keys().count() - 1) >= cmd.menuItems().count())
        return false;
    else
        return true;
}

void DemoSimApplication::sendToneMenu()
{
    QSimCommand cmd;
    QSimMenuItem item;
    QList<QSimMenuItem> items;

    cmd.setType( QSimCommand::SelectItem );
    cmd.setTitle( "Tones" );

    item.setIdentifier( (uint)QSimCommand::ToneDial );
    item.setLabel( "Dial" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneBusy );
    item.setLabel( "Busy" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneCongestion );
    item.setLabel( "Congestion" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneRadioAck );
    item.setLabel( "Radio Ack" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneDropped );
    item.setLabel( "Dropped" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneError );
    item.setLabel( "Error" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneCallWaiting );
    item.setLabel( "Call Waiting" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneGeneralBeep );
    item.setLabel( "General Beep" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::TonePositiveBeep );
    item.setLabel( "Positive Beep" );
    items += item;

    item.setIdentifier( (uint)QSimCommand::ToneNegativeBeep );
    item.setLabel( "Negative Beep" );
    items += item;

    cmd.setMenuItems( items );

    command( cmd, this, SLOT(toneMenu(QSimTerminalResponse)) );
}

void DemoSimApplication::getInputLoop( const QSimTerminalResponse& resp )
{
    QSimCommand cmd;
    if ( resp.result() == QSimTerminalResponse::HelpInformationRequested ) {
        // Display help for the game.
        cmd.setType( QSimCommand::DisplayText );
        cmd.setDestinationDevice( QSimCommand::Display );
        cmd.setText("Enter code of the company." );
        command( cmd, this, SLOT(mainMenu()) );
    } else {
        mainMenu();
    }
}

void DemoSimApplication::mainMenu()
{
    QSimCommand cmd;
    QSimMenuItem item;
    QList<QSimMenuItem> items;

    cmd.setType( QSimCommand::SetupMenu );

    item.setIdentifier( MainMenu_News );
    item.setLabel( "News" );
    items += item;

    item.setIdentifier( MainMenu_Sports );
    item.setLabel( "Sports" );
    items += item;

    item.setIdentifier( MainMenu_Time );
    item.setLabel( "Time" );
    items += item;

    item.setIdentifier( MainMenu_SticksGame );
    item.setLabel( "Sticks Game" );
    items += item;

    item.setIdentifier( MainMenu_Tones );
    item.setLabel( "Tones" );
    items += item;

    item.setIdentifier( MainMenu_Icons );
    item.setLabel( "Icons (not self-explanatory)" );
    items += item;

    item.setIdentifier( MainMenu_IconsSE );
    item.setLabel( "Icons (self-explanatory)" );
    items += item;

    item.setIdentifier( MainMenu_Finance );
    item.setLabel( "Finance" );
    items += item;

    item.setIdentifier( MainMenu_Browser );
    item.setLabel( "Web Browser" );
    items += item;

    cmd.setMenuItems( items );

    command( cmd, 0, 0 );
}

void tst_QSimToolkit::testEncodeSendDTMF()
{
    QFETCH( QByteArray, data );
    QFETCH( QByteArray, resp );
    QFETCH( int, resptype );
    QFETCH( QString, text );
    QFETCH( QString, number );
    QFETCH( int, iconId );
    QFETCH( bool, iconSelfExplanatory );
    QFETCH( QByteArray, textAttribute );
    QFETCH( QString, html );
    QFETCH( int, options );

    // Output a dummy line to give some indication of which test we are currently running.
    qDebug() << "";

    // Check that the command PDU can be parsed correctly.
    QSimCommand decoded = QSimCommand::fromPdu(data);
    QVERIFY( decoded.type() == QSimCommand::SendDTMF );
    QVERIFY( decoded.destinationDevice() == QSimCommand::Network );
    QCOMPARE( decoded.text(), text );
    QCOMPARE( decoded.number(), number );
    QCOMPARE( (int)decoded.iconId(), iconId );
    QCOMPARE( decoded.iconSelfExplanatory(), iconSelfExplanatory );
    QCOMPARE( decoded.textAttribute(), textAttribute );
    if ( !textAttribute.isEmpty() )
        QCOMPARE( decoded.textHtml(), html );

    // Check that the original command PDU can be reconstructed correctly.
    QByteArray encoded = decoded.toPdu( (QSimCommand::ToPduOptions)options );
    QCOMPARE( encoded, data );

    // Check that the terminal response PDU can be parsed correctly.
    QSimTerminalResponse decodedResp = QSimTerminalResponse::fromPdu(resp);
    QVERIFY( data.contains( decodedResp.commandPdu() ) );
    if ( resptype < 0x0100 ) {
        QVERIFY( decodedResp.result() == (QSimTerminalResponse::Result)resptype );
        QVERIFY( decodedResp.causeData().isEmpty() );
        QVERIFY( decodedResp.cause() == QSimTerminalResponse::NoSpecificCause );
    } else {
        QVERIFY( decodedResp.result() == (QSimTerminalResponse::Result)(resptype >> 8) );
        QVERIFY( decodedResp.causeData().size() == 1 );
        QVERIFY( decodedResp.cause() == (QSimTerminalResponse::Cause)(resptype & 0xFF) );
    }

    // Check that the original terminal response PDU can be reconstructed correctly.
    QCOMPARE( decodedResp.toPdu(), resp );
}

void SimApp::cmdSetupEventList(const QSimCommand &cmd)
{
    QByteArray events = cmd.extensionField(0x99);
    int newEvents = 0;
    foreach ( char ev, events )
        newEvents |= (1 << (int)(ev & 0xFF));
    changeEventList( newEvents );
}

// Shows info to user when, e.g. SMS is sent.
void SimApp::showNotification(const QSimCommand &cmd)
{
    if (!cmd.text().isEmpty() || !cmd.suppressUserFeedback()) {
        if (notification) {
            notification->setCommand(cmd);
            stack->setCurrentWidget(notification);
            emit viewChanged(notification);
        } else {
            if ( cmd.iconId() > 0 )
                createIconReader();
            notification = new SimText(cmd, iconReader, stack);
            stack->addWidget(notification);
            stack->setCurrentWidget(notification);
            emit viewChanged(notification);
        }
    }
}

void SimApp::cmdIdleModeText(const QSimCommand &cmd)
{
    idleModeText = cmd;
    if ( cmd.iconId() != 0 ) {
        createIconReader();
        if ( iconReader->haveIcon( cmd.iconId() ) ) {
            // Icon already cached from last time.
            idleModeImage = iconReader->icon( cmd.iconId() );
        } else {
            // Request that the icon be fetched from the sim.
            iconReader->requestIcon( cmd.iconId() );
            idleModeImage = QImage();
        }
    } else {
        idleModeImage = QImage();
    }
    updateValueSpace();
}

void SimApp::cmdTone(const QSimCommand & cmd )
{
    if ( cmd.iconId() > 0 )
        createIconReader();
    SimTone *tone = new SimTone(cmd, iconReader, stack);
    connect(tone, SIGNAL(sendResponse(QSimTerminalResponse)),
            this, SLOT(sendResponse(QSimTerminalResponse)) );
    setView(tone);
}

void SimApp::cmdDisplayText(const QSimCommand &cmd)
{
#ifndef QTOPIA_TEST
    // DisplayText with low priority came while screen is busy
    if ( !this->isVisible()
            && !(HomeScreenControl::instance()->homeScreen()->windowState() & Qt::WindowActive)
            && !cmd.highPriority() ) {
        QSimTerminalResponse resp;
        resp.setCommand(cmd);
        resp.setCause(QSimTerminalResponse::ScreenIsBusy);
        resp.setResult(QSimTerminalResponse::MEUnableToProcess);
        sendResponse( resp );
        return;
    }
#endif
    if ( cmd.iconId() > 0 )
        createIconReader();

    hasSustainedDisplayText = cmd.immediateResponse();

    if (view && qobject_cast<SimText*>(view)) {
        SimText *text = (SimText *)view;
        if (cmd.highPriority() || !text->hasHighPriority()) {
            if (cmd.iconId())
                text->setCommand(cmd, iconReader);
            else
                text->setCommand(cmd);
            stack->setCurrentWidget(text);
        } else {
            // send screen busy response
            QSimTerminalResponse resp;
            resp.setCommand(cmd);
            resp.setCause(QSimTerminalResponse::ScreenIsBusy);
            resp.setResult(QSimTerminalResponse::MEUnableToProcess);
            sendResponse( resp );
        }
    } else {
        SimText *text = new SimText(cmd, iconReader, stack);
        connect(text, SIGNAL(sendResponse(QSimTerminalResponse)),
                this, SLOT(sendResponse(QSimTerminalResponse)) );
        connect(text, SIGNAL(hideApp()), this, SLOT(hideApp()));
        setView(text);
    }
}

void SimApp::cmdInKey(const QSimCommand &cmd)
{
    if ( cmd.iconId() > 0 )
        createIconReader();

    SimInKey *inKey = new SimInKey(cmd, iconReader, stack);
    connect(inKey, SIGNAL(sendResponse(QSimTerminalResponse)),
            this, SLOT(sendResponse(QSimTerminalResponse)) );
    setView(inKey);
}