odevice.cpp

Go to the documentation of this file.

/*
                             This file is part of the Opie Project
             =.              (C) 2002-2005 The Opie Team <opie-devel@handhelds.org>
            .=l.
           .>+-=
 _;:,     .>    :=|.         This program is free software; you can
.> <`_,   >  .   <=          redistribute it and/or  modify it under
:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
.="- .-=="i,     .._         License as published by the Free Software
 - .   .-<_>     .<>         Foundation; version 2 of the License.
     ._= =}       :
    .%`+i>       _;_.
    .i_,=:_.      -<s.       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
..}^=.=       =       ;      Library General Public License for more
++=   -.     .`     .:       details.
 :     =  ...= . :.=-
 -.   .:....=;==+<;          You should have received a copy of the GNU
  -_. . .   )=.  =           Library General Public License along with
    --        :-=`           this library; see the file COPYING.LIB.
                             If not, write to the Free Software Foundation,
                             Inc., 59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.

*/


#include "odevice_beagle.h"
#include "odevice_ipaq.h"
#include "odevice_mypal.h"
#include "odevice_jornada.h"
#include "odevice_ramses.h"
#include "odevice_simpad.h"
#include "odevice_yopy.h"
#include "odevice_zaurus.h"
#include "odevice_genuineintel.h"

/* QT */
#include <qapplication.h>
#include <qfile.h>
#include <qtextstream.h>
#include <qwindowsystem_qws.h>

/* OPIE */
#include <qpe/config.h>
#include <qpe/sound.h>
#include <qpe/qcopenvelope_qws.h>
#include <qpe/sound.h>

#include <opie2/okeyfilter.h>
#include <opie2/oresource.h>

/* STD */
#include <fcntl.h>
#include <math.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <unistd.h>
#ifndef QT_NO_SOUND
#include <linux/soundcard.h>
#endif

namespace Opie {
namespace Core {

static const char* PATH_PROC_CPUINFO = "/proc/cpuinfo";


/* STATIC and common implementation */
/* EXPORT */ ODistribution distributions[] = {
    { System_Familiar,        "FamiliarLinux",   "/etc/familiar-version" },
    { System_OpenZaurus,      "OpenZaurus",      "/etc/oz_version" },
    { System_OpenEmbedded,    "OpenEmbedded",    "/etc/oe-version" },
    { System_Unknown,         "Linux",           "/etc/issue" },
};


/* EXPORT */ bool isQWS(){
    return qApp ? ( qApp->type() == QApplication::GuiServer ) : false;
}

/* EXPORT */ QCString makeChannel ( const char *str ){
    if ( str && !::strchr ( str, '/' ))
        return QCString ( "QPE/Application/" ) + str;
    else
        return str;
}



/* Now the default implementation of ODevice */

struct default_button default_buttons [] =  {
    { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
    "devicebuttons/z_calendar",
    "datebook", "nextView()",
    "today", "raise()" },
    { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
    "devicebuttons/z_contact",
    "addressbook", "raise()",
    "addressbook", "beamBusinessCard()" },
    { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
    "devicebuttons/z_home",
    "QPE/Launcher", "home()",
    "buttonsettings", "raise()" },
    { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
    "devicebuttons/z_menu",
    "QPE/TaskBar", "toggleMenu()",
    "QPE/TaskBar", "toggleStartMenu()" },
    { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
    "devicebuttons/z_mail",
    "opiemail", "raise()",
    "opiemail", "newMail()" },
};

ODevice *ODevice::inst()
{
    static ODevice *dev = 0;
    QString cpu_info;

    if ( !dev )
    {
        QFile f( PATH_PROC_CPUINFO );
        if ( f.open( IO_ReadOnly ) )
        {
            QTextStream s( &f );
            while ( !s.atEnd() )
            {
                QString line;
                line = s.readLine();
                if ( line.startsWith( "Hardware" ) )
                {
                    qDebug( "ODevice() - found '%s'", (const char*) line );
                    cpu_info = line;
                    if ( line.contains( "sharp", false ) ) dev = new Internal::Zaurus();
                    else if ( line.contains( "ipaq", false ) ) dev = new Internal::iPAQ();
                    else if ( line.contains( "mypal", false ) ) dev = new Internal::MyPal();
                    else if ( line.contains( "simpad", false ) ) dev = new Internal::SIMpad();
                    else if ( line.contains( "jornada", false ) ) dev = new Internal::Jornada();
                    else if ( line.contains( "ramses", false ) ) dev = new Internal::Ramses();
                    else if ( line.contains( "Tradesquare.NL", false ) ) dev = new Internal::Beagle();
                    else qWarning( "ODevice() - unknown hardware - using default." );
                    break;
                } else if ( line.startsWith( "vendor_id" ) ) {
                    qDebug( "ODevice() - found '%s'", (const char*) line );
                    cpu_info = line;
                    if( line.contains( "genuineintel", false ) ) {
                      dev = new Internal::GenuineIntel();
                      break;
                    }
                }
            }
        }
        else
        {
            qWarning( "ODevice() - can't open '%s' - unknown hardware - using default.", PATH_PROC_CPUINFO );
        }
        if ( !dev ) dev = new ODevice();
        dev->init(cpu_info);
    }
    return dev;
}

ODevice::ODevice()
{
    d = new ODeviceData;

    d->m_modelstr = "Unknown";
    d->m_model = Model_Unknown;
    d->m_vendorstr = "Unknown";
    d->m_vendor = Vendor_Unknown;
    d->m_systemstr = "Unknown";
    d->m_system = System_Unknown;
    d->m_sysverstr = "0.0";
    d->m_rotation = Rot0;
    d->m_direction = CW;
    d->m_qteDriver = "Transformed";

    d->m_holdtime = 1000; // 1000ms
    d->m_buttons = 0;
    d->m_cpu_frequencies = new QStrList;


    /* mixer */
    d->m_sound = d->m_vol   = d->m_mixer = -1;

    /* System QCopChannel created */
    d->m_initializedButtonQcop = false;

    // New distribution detection code first checks for legacy distributions,
    // identified by /etc/familiar-version or /etc/oz_version.
    // Then check for OpenEmbedded and lastly, read /etc/issue

    for ( unsigned int i = 0; i < sizeof(distributions)/sizeof(ODistribution); ++i )
    {
        if ( QFile::exists( distributions[i].sysvfile ) )
        {
            d->m_systemstr = distributions[i].sysstr;
            d->m_system = distributions[i].system;
            d->m_sysverstr = "<Unknown>";
            QFile f( distributions[i].sysvfile );
            if ( f.open( IO_ReadOnly ) )
            {
                QTextStream ts( &f );
                d->m_sysverstr = ts.readLine().replace( QRegExp( "\\\\." ), "" );
            }
            break;
        }
    }
}

void ODevice::systemMessage( const QCString &msg, const QByteArray & )
{
    if ( msg == "deviceButtonMappingChanged()" ) {
        reloadButtonMapping();
    }
}

void ODevice::init(const QString&)
{
}

void ODevice::initButtons()
{
    if ( d->m_buttons )
        return;

    qDebug ( "init Buttons" );
    d->m_buttons = new QValueList <ODeviceButton>;
    for ( uint i = 0; i < ( sizeof( default_buttons ) / sizeof( default_button )); i++ ) {
        default_button *db = default_buttons + i;
        ODeviceButton b;
        b. setKeycode ( db->code );
        b. setUserText ( QObject::tr ( "Button", db->utext ));
        b. setPixmap ( OResource::loadPixmap ( db->pix ));
        b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( db->fpressedservice ), db->fpressedaction ));
        b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( db->fheldservice ), db->fheldaction ));
        d->m_buttons->append ( b );
    }

    reloadButtonMapping();
}

ODevice::~ODevice()
{
// we leak m_devicebuttons and m_cpu_frequency
// but it's a singleton and it is not so importantant
// -zecke
    delete d;
}

bool ODevice::suspend()
{
    return false; // default implementation == unknown device or qvfb
}

bool ODevice::setDisplayStatus( bool on )
{
    qDebug( "ODevice::setDisplayStatus( %d ) - please override me.", on );
    return false; // don't do anything for unknown models
}

bool ODevice::setDisplayBrightness( int b )
{
    qDebug( "ODevice::setDisplayBrightness( %d ) - please override me.", b );
    return false;
}

int ODevice::displayBrightnessResolution() const
{
    qDebug( "ODevice::displayBrightnessResolution() - please override me." );
    return 16;
}

bool ODevice::setDisplayContrast( int p )
{
    qDebug( "ODevice::setDisplayContrast( %d ) - please override me.", p );
    return false;
}

int ODevice::displayContrastResolution() const
{
    qDebug( "ODevice::displayBrightnessResolution() - please override me." );
    return 0;
}

QString ODevice::vendorString() const
{
    return d->m_vendorstr;
}

OVendor ODevice::vendor() const
{
    return d->m_vendor;
}

QString ODevice::modelString() const
{
    return d->m_modelstr;
}

OModel ODevice::model() const
{
    return d->m_model;
}

QString ODevice::systemString() const
{
    return d->m_systemstr;
}

OSystem ODevice::system() const
{
    return d->m_system;
}

QString ODevice::systemVersionString() const
{
    return d->m_sysverstr;
}

Transformation ODevice::rotation() const
{
    return d->m_rotation;
}

ODirection ODevice::direction() const
{
    return d->m_direction;
}

QString ODevice::qteDriver() const
{
    return d->m_qteDriver;
}

void ODevice::playAlarmSound()
{
#ifndef QT_NO_SOUND
    static Sound snd ( "alarm" );

    if ( snd. isFinished())
        snd. play();
#endif
}

void ODevice::playKeySound()
{
#ifndef QT_NO_SOUND
    static Sound snd ( "keysound" );

    if ( snd. isFinished())
        snd. play();
#endif
}

void ODevice::playTouchSound()
{
#ifndef QT_NO_SOUND
    static Sound snd ( "touchsound" );

    if ( snd. isFinished())
        snd. play();
#endif
}

QValueList <OLed> ODevice::ledList() const
{
    return QValueList <OLed>();
}

QValueList <OLedState> ODevice::ledStateList ( OLed /*which*/ ) const
{
    return QValueList <OLedState>();
}

OLedState ODevice::ledState ( OLed /*which*/ ) const
{
    return Led_Off;
}

bool ODevice::setLedState ( OLed which, OLedState st )
{
        Q_UNUSED( which )
        Q_UNUSED( st    )
    return false;
}

bool ODevice::hasLightSensor() const
{
    return false;
}

int ODevice::readLightSensor()
{
    return -1;
}

int ODevice::lightSensorResolution() const
{
    return 0;
}

bool ODevice::hasHingeSensor() const
{
    return false;
}

OHingeStatus ODevice::readHingeSensor()const
{
    return CASE_UNKNOWN;
}

const QStrList &ODevice::allowedCpuFrequencies() const
{
    return *d->m_cpu_frequencies;
}


bool ODevice::setCurrentCpuFrequency(uint index)
{
    if (index >= d->m_cpu_frequencies->count())
        return false;

    char *freq = d->m_cpu_frequencies->at(index);
    qWarning("set freq to %s", freq);

    int fd;

    if ((fd = ::open("/proc/sys/cpu/0/speed", O_WRONLY)) >= 0) {
        char writeCommand[50];
        const int count = sprintf(writeCommand, "%s\n", freq);
        int res = (::write(fd, writeCommand, count) != -1);
        ::close(fd);
        return res;
    }

    return false;
}


const QValueList <ODeviceButton> &ODevice::buttons()
{
    initButtons();

    return *d->m_buttons;
}

uint ODevice::buttonHoldTime() const
{
    return d->m_holdtime;
}

const ODeviceButton *ODevice::buttonForKeycode ( ushort code )
{
    initButtons();

    for ( QValueListConstIterator<ODeviceButton> it = d->m_buttons->begin(); it != d->m_buttons->end(); ++it ) {
        if ( (*it).keycode() == code )
            return &(*it);
    }
    return 0;
}

void ODevice::reloadButtonMapping()
{
    if(!d->m_buttons)
        initButtons();

    if(!d->m_initializedButtonQcop) {
        QCopChannel *chan = new QCopChannel("QPE/System", this, "ODevice button channel");
        connect(chan,SIGNAL(received(const QCString&,const QByteArray&)),
                this,SLOT(systemMessage(const QCString&,const QByteArray&)));
        d->m_initializedButtonQcop = true;
    }

    Config cfg ( "ButtonSettings" );

    for ( uint i = 0; i < d->m_buttons->count(); i++ ) {
        ODeviceButton &b = ( *d->m_buttons ) [i];
        QString group = "Button" + QString::number ( i );

        QCString pch, hch;
        QCString pm, hm;
        QByteArray pdata, hdata;

        if ( cfg. hasGroup ( group )) {
            cfg. setGroup ( group );
            pch = cfg. readEntry ( "PressedActionChannel" ). latin1();
            pm  = cfg. readEntry ( "PressedActionMessage" ). latin1();
            // pdata = decodeBase64 ( buttonFile. readEntry ( "PressedActionArgs" ));

            hch = cfg. readEntry ( "HeldActionChannel" ). latin1();
            hm  = cfg. readEntry ( "HeldActionMessage" ). latin1();
            // hdata = decodeBase64 ( buttonFile. readEntry ( "HeldActionArgs" ));
        }

        b. setPressedAction ( OQCopMessage ( pch, pm, pdata ));
        b. setHeldAction ( OQCopMessage ( hch, hm, hdata ));
    }
}

void ODevice::remapPressedAction ( int button, const OQCopMessage &action )
{
    initButtons();

    QString mb_chan;

    if ( button >= (int) d->m_buttons->count())
        return;

    ODeviceButton &b = ( *d->m_buttons ) [button];
        b. setPressedAction ( action );

    mb_chan=b. pressedAction(). channel();

    Config buttonFile ( "ButtonSettings" );
    buttonFile. setGroup ( "Button" + QString::number ( button ));
    buttonFile. writeEntry ( "PressedActionChannel", (const char*) mb_chan);
    buttonFile. writeEntry ( "PressedActionMessage", (const char*) b. pressedAction(). message());

//  buttonFile. writeEntry ( "PressedActionArgs", encodeBase64 ( b. pressedAction(). data()));

    QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" );
}

void ODevice::remapHeldAction ( int button, const OQCopMessage &action )
{
    initButtons();

    if ( button >= (int) d->m_buttons->count())
        return;

    ODeviceButton &b = ( *d->m_buttons ) [button];
        b. setHeldAction ( action );

    Config buttonFile ( "ButtonSettings" );
    buttonFile. setGroup ( "Button" + QString::number ( button ));
    buttonFile. writeEntry ( "HeldActionChannel", (const char *) b. heldAction(). channel());
    buttonFile. writeEntry ( "HeldActionMessage", (const char *) b. heldAction(). message());

//  buttonFile. writeEntry ( "HeldActionArgs", decodeBase64 ( b. heldAction(). data()));

    QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" );
}

void ODevice::virtual_hook(int, void* ){

}

void ODevice::sendSuspendmsg()
{
    if ( !isQWS() )
        return;

    QCopEnvelope ( "QPE/System", "aboutToSuspend()" );
}

void ODevice::addPreHandler(QWSServer::KeyboardFilter*aFilter)
{
    Opie::Core::OKeyFilter::inst()->addPreHandler(aFilter);
}

void ODevice::remPreHandler(QWSServer::KeyboardFilter*aFilter)
{
    Opie::Core::OKeyFilter::inst()->remPreHandler(aFilter);
}


void ODevice::playingStopped() {
    if ( sender() )
        const_cast<QObject*>(sender())->disconnect( this );

#ifndef QT_NO_SOUND
    if ( d->m_sound >= 0 ) {
        ::ioctl ( d->m_sound, MIXER_WRITE( d->m_mixer ), &d->m_vol );
        ::close ( d->m_sound );
    }
#endif
}


void ODevice::changeMixerForAlarm( int mixer, const char* file, Sound *snd ) {
#ifndef QT_NO_SOUND
    if (( d->m_sound = ::open ( file, O_RDWR )) >= 0 ) {
        if ( ::ioctl ( d->m_sound, MIXER_READ( mixer ), &d->m_vol ) >= 0 ) {
            Config cfg ( "qpe" );
            cfg. setGroup ( "Volume" );

            int volalarm = cfg. readNumEntry ( "AlarmPercent", 50 );
            if ( volalarm < 0 )
                volalarm = 0;
            else if ( volalarm > 100 )
                volalarm = 100;
            volalarm |= ( volalarm << 8 );

            if ( ::ioctl ( d->m_sound, MIXER_WRITE( mixer ), &volalarm ) >= 0 )
                register_qpe_sound_finished(snd, this, SLOT(playingStopped()));
        }
        d->m_mixer = mixer;
    }
#endif
}

}
}

---