kitchensync

dbusclient.cpp

00001 /*
00002     This file is part of KDE.
00003 
00004     Copyright (c) 2006 Cornelius Schumacher <schumacher@kde.org>
00005 
00006     This program is free software; you can redistribute it and/or modify
00007     it under the terms of the GNU General Public License as published by
00008     the Free Software Foundation; either version 2 of the License, or
00009     (at your option) any later version.
00010 
00011     This program is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00014     GNU General Public License for more details.
00015 
00016     You should have received a copy of the GNU General Public License
00017     along with this program; if not, write to the Free Software
00018     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00019     USA.
00020 */
00021 
00022 #include "dbusclient.h"
00023 
00024 #include <libqopensync/environment.h>
00025 #include <libqopensync/group.h>
00026 
00027 #include <dbus/qdbuserror.h>
00028 #include <dbus/qdbusconnection.h>
00029 #include <dbus/qdbusmessage.h>
00030 #include <dbus/qdbusproxy.h>
00031 
00032 #include <tqapplication.h>
00033 #include <tqtimer.h>
00034 
00035 #include <iostream>
00036 
00037 OpenSyncService::OpenSyncService()
00038   : mConnection( 0 )
00039 {
00040 }
00041 
00042 void OpenSyncService::setConnection( TQDBusConnection *connection )
00043 {
00044   mConnection = connection;
00045   mConnection->registerObject( "/ABC", this );
00046 }
00047 
00048 bool OpenSyncService::handleMethodCall( const TQDBusMessage &message )
00049 {
00050   tqDebug( "OpenSyncService::handleMethodCall()" );
00051 
00052   tqDebug( "  Interface: %s", message.interface().latin1() );
00053   tqDebug( "  Path: %s", message.path().latin1() );
00054   tqDebug( "  Member: %s", message.member().latin1() );
00055   tqDebug( "  Sender: %s", message.sender().latin1() );
00056 
00057   if ( message.interface() != "org.opensync.SyncEngine" ) return false;
00058 
00059   TQDBusMessage reply;
00060 
00061   TQString function = message.member();
00062   if ( function == "hello" ) {
00063     reply = hello( message );
00064   } else if ( function == "randomNumber" ) {
00065     reply = randomNumber( message );
00066   } else if ( function == "listGroups" ) {
00067     reply = listGroups( message );
00068   } else if ( function == "listPlugins" ) {
00069     reply = listPlugins( message );
00070   } else if ( function == "showGroup" ) {
00071     reply = showGroup( message );
00072   } else if ( function == "showMember" ) {
00073     reply = showMember( message );
00074   } else {
00075     return false;
00076   }
00077 
00078   mConnection->send( reply );
00079 
00080   return true;
00081 }
00082 
00083 TQDBusMessage OpenSyncService::showMember( const TQDBusMessage &message )
00084 {
00085   if ( message.count() != 2 ) {
00086     return error( message, "arg_count",
00087       TQString("Wrong number of arguments. Expected 2, got %1.")
00088       .arg( message.count() ) );
00089   }
00090 
00091   TQString groupName = message[ 0 ].toString();
00092   if ( groupName.isEmpty() ) {
00093     return error( message, "missing_arg", "Missing argument: group name." );
00094   }
00095 
00096   bool ok;
00097   int memberId = message[ 1 ].toInt( &ok );
00098   if ( !ok ) {
00099     return error( message, "missing_arg", "Missing argument: member id." );
00100   }
00101 
00102   TQDBusMessage reply;
00103 
00104   QSync::Environment env;
00105   QSync::Result result = env.initialize();
00106   if ( result.isError() ) {
00107     return error( message, result.name(), result.message() ); 
00108   } else {
00109     reply = TQDBusMessage::methodReply( message );
00110 
00111     QSync::Group group = env.groupByName( groupName );
00112     if ( !group.isValid() ) {
00113       return error( message, "group_name", TQString("Unknown group '%1'.")
00114         .arg( groupName ) );
00115     }
00116 
00117     QSync::Member member = group.memberById( memberId );
00118     if ( !member.isValid() ) {
00119       return error( message, "member_id",
00120         TQString("Unknown member id '%1' in group '%2'.").arg( groupName )
00121           .arg( memberId ) );
00122     }
00123 
00124     reply.append( memberId );
00125     reply.append( member.pluginName() );
00126       
00127     env.finalize();
00128   }
00129 
00130   return reply;
00131 }
00132 
00133 
00134 TQDBusMessage OpenSyncService::showGroup( const TQDBusMessage &message )
00135 {
00136   if ( message.count() != 1 ) {
00137     return error( message, "arg_count",
00138       TQString("Wrong number of arguments. Expected 1, got %1")
00139       .arg( message.count() ) );
00140   }
00141 
00142   TQString groupName = message[ 0 ].toString();
00143   if ( groupName.isEmpty() ) {
00144     return error( message, "missing_arg", "Missing argument group name." );
00145   }
00146 
00147   TQDBusMessage reply;
00148 
00149   QSync::Environment env;
00150   QSync::Result result = env.initialize();
00151   if ( result.isError() ) {
00152     return error( message, result.name(), result.message() ); 
00153   } else {
00154     reply = TQDBusMessage::methodReply( message );
00155 
00156     QSync::Group group = env.groupByName( groupName );
00157     if ( !group.isValid() ) {
00158       return error( message, "group_name", TQString("Unknown group '%1'")
00159         .arg( groupName ) );
00160     }
00161 
00162     QSync::Group::Iterator it( &group );
00163     for( it = group.begin(); it != group.end(); ++it ) {
00164       QSync::Member member = *it;
00165       reply.append( TQVariant( member.id() ) );
00166     }
00167   
00168     env.finalize();
00169   }
00170 
00171   return reply;
00172 }
00173 
00174 TQDBusMessage OpenSyncService::error( const TQDBusMessage &message,
00175   const TQString &errorCode,
00176   const TQString &errorMessage )
00177 {
00178   TQDBusError error( "org.opensync." + errorCode, errorMessage );
00179   return TQDBusMessage::methodError( message, error );
00180 }
00181 
00182 TQDBusMessage OpenSyncService::listPlugins( const TQDBusMessage &message )
00183 {
00184   TQDBusMessage reply;
00185 
00186   QSync::Environment env;
00187   QSync::Result result = env.initialize();
00188   if ( result.isError() ) {
00189     TQDBusError error( result.name(), result.message() ); 
00190     reply = TQDBusMessage::methodError( message, error );
00191   } else {
00192     reply = TQDBusMessage::methodReply( message );
00193 
00194     QSync::Environment::PluginIterator it( env.pluginBegin() );
00195     for ( ; it != env.pluginEnd(); ++it ) {
00196       reply.append( TQVariant( (*it).name() ) );
00197     }
00198   
00199     env.finalize();
00200   }
00201 
00202   return reply;
00203 }
00204 
00205 TQDBusMessage OpenSyncService::listGroups( const TQDBusMessage &message )
00206 {
00207   TQDBusMessage reply;
00208 
00209   QSync::Environment env;
00210   QSync::Result result = env.initialize();
00211   if ( result.isError() ) {
00212     TQDBusError error( result.name(), result.message() ); 
00213     reply = TQDBusMessage::methodError( message, error );
00214   } else {
00215     reply = TQDBusMessage::methodReply( message );
00216 
00217     QSync::Environment::GroupIterator it( env.groupBegin() );
00218     for ( ; it != env.groupEnd(); ++it ) {
00219       reply.append( TQVariant( (*it).name() ) );
00220     }
00221   
00222     env.finalize();
00223   }
00224 
00225   return reply;
00226 }
00227 
00228 TQDBusMessage OpenSyncService::hello( const TQDBusMessage &message )
00229 {
00230   TQDBusMessage reply = TQDBusMessage::methodReply( message );
00231 
00232 // TQDBusError error;
00233 // reply = TQDBusMessage::methodError( message, error );
00234 
00235   reply.append( TQVariant( TQString( "Hello!" ) ) );
00236   
00237   return reply;
00238 }
00239 
00240 TQDBusMessage OpenSyncService::randomNumber( const TQDBusMessage &message )
00241 {
00242   TQDBusMessage reply = TQDBusMessage::methodReply( message );
00243 
00244   int number = rand();
00245 
00246   reply.append( TQVariant( number ) );
00247   
00248   return reply;
00249 }
00250 
00251 int main( int argc, char *argv[] )
00252 {
00253   TQApplication app(argc, argv);
00254 
00255   std::cout << "Hello" << std::endl;
00256 
00257   TQDBusConnection connection = TQDBusConnection::addConnection(
00258     TQDBusConnection::SessionBus );
00259 
00260   if ( !connection.isConnected() ) {
00261     tqFatal("Cannot connect to session bus");
00262   }
00263 
00264   connection.requestName( "org.opensync.SyncEngine",
00265     TQDBusConnection::NoReplace );
00266 
00267   OpenSyncService service;
00268   service.setConnection( &connection );
00269 
00270   return app.exec();
00271 }
00272 
00273 //#include "dbusclient.moc"