opensync-plugin-0.4x/src/environment.cc

   1 //
   2 // \file        environment.cc
   3 //              Container / environment class for the sync module.
   4 //
   5
   6 /*
   7     Copyright (C) 2006-2010, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include <opensync/opensync.h>
  23 #include <opensync/opensync-data.h>
  24 #include <opensync/opensync-format.h>
  25 #include <opensync/opensync-plugin.h>
  26 #include <opensync/opensync-helper.h>
  27 #include <opensync/opensync-version.h>
  28
  29 #include "environment.h"
  30 #include "trace.h"
  31 #include <glib.h>
  32 #include <string>
  33 #include <fstream>
  34 #include <sstream>
  35 #include <iomanip>
  36 #include <string.h>
  37 #include <unistd.h>
  38
  39
  40 //////////////////////////////////////////////////////////////////////////////
  41 // DatabaseSyncState
  42
  43 DatabaseSyncState::DatabaseSyncState(OSyncPluginInfo *info, const char *description)
  44         : m_dbId(0),
  45         m_Sync(false),
  46         m_Desc(description)
  47 {
  48 }
  49
  50 DatabaseSyncState::~DatabaseSyncState()
  51 {
  52 }
  53
  54 //
  55 // Map2Uid
  56 //
  57 /// Converts record ID to string, since opensync 0.4x keeps the
  58 /// same UID as we give it.
  59 ///
  60 std::string DatabaseSyncState::Map2Uid(uint32_t recordId) const
  61 {
  62         std::ostringstream oss;
  63         oss << std::dec << recordId;
  64         return oss.str();
  65 }
  66
  67
  68
  69 //////////////////////////////////////////////////////////////////////////////
  70 // BarryEnvironment Public API
  71
  72 BarryEnvironment::BarryEnvironment(OSyncPluginInfo *info):
  73         info(info),
  74         m_pin(-1),
  75         m_DebugMode(false),
  76         m_password(""),
  77         m_IConverter("UTF-8"),
  78         m_pCon(0),
  79         m_pDesktop(0),
  80         m_CalendarSync(info, "calendar"),
  81         m_ContactsSync(info, "contacts"),
  82         m_JournalSync(info, "note"),
  83         m_TodoSync(info, "todo"),
  84         m_NeedsReconnect(false)
  85 {
  86 }
  87
  88 BarryEnvironment::~BarryEnvironment()
  89 {
  90         delete m_pDesktop;
  91         delete m_pCon;
  92 }
  93
  94 void BarryEnvironment::DoConnect()
  95 {
  96         // Create controller
  97         //
  98         // Override the timeout due to a firmware issue... sometimes
  99         // the firmware will hang during a Reconnect, and fail to
 100         // respond to a Desktop::Open().  To work around this, we
 101         // set the default timeout to 15 seconds so that we find this
 102         // failure early enough to fix it within opensync's 30 second timeout.
 103         // Then if we get such a timeout, we do the Reconnect again and
 104         // hope for the best... this often fixes it.
 105         //
 106         if( !m_ProbeResult.get() )
 107                 throw std::logic_error("Tried to use empty ProbeResult");
 108         m_pCon = new Barry::Controller(*m_ProbeResult, 15000);
 109         m_pDesktop = new Barry::Mode::Desktop(*m_pCon, m_IConverter);
 110         m_pDesktop->Open(m_password.c_str());
 111
 112         // Save the DBIDs and DBNames of the databases we will work with
 113         if( m_CalendarSync.m_Sync ) {
 114                 m_CalendarSync.m_dbName = Barry::Calendar::GetDBName();
 115                 m_CalendarSync.m_dbId = m_pDesktop->GetDBID(Barry::Calendar::GetDBName());
 116         }
 117
 118         if( m_ContactsSync.m_Sync ) {
 119                 m_ContactsSync.m_dbName = Barry::Contact::GetDBName();
 120                 m_ContactsSync.m_dbId = m_pDesktop->GetDBID(Barry::Contact::GetDBName());
 121         }
 122
 123         if( m_JournalSync.m_Sync ) {
 124                 m_JournalSync.m_dbName = Barry::Memo::GetDBName();
 125                 m_JournalSync.m_dbId = m_pDesktop->GetDBID(Barry::Memo::GetDBName());
 126         }
 127
 128         if( m_TodoSync.m_Sync ) {
 129                 m_TodoSync.m_dbName = Barry::Task::GetDBName();
 130                 m_TodoSync.m_dbId = m_pDesktop->GetDBID(Barry::Task::GetDBName());
 131         }
 132 }
 133
 134 void BarryEnvironment::Connect(const Barry::ProbeResult &result)
 135 {
 136         Disconnect();
 137
 138         // save result in case we need to reconnect later
 139         m_ProbeResult.reset( new Barry::ProbeResult(result) );
 140
 141         DoConnect();
 142 }
 143
 144 void BarryEnvironment::Reconnect()
 145 {
 146         int tries = 0;
 147
 148         while(1) try {
 149
 150                 tries++;
 151
 152                 Disconnect();
 153
 154                 // let the device settle... this seems to help prevent the
 155                 // firmware hang, and therefore ultimately speeds up the sync
 156                 sleep(1);
 157
 158                 // FIXME - temporary fix for odd reconnect message... without this
 159                 // probe, the reconnect will often fail on newer Blackberries
 160                 // due to an unexpected close socket message.  It is unclear
 161                 // if this is really a message from the device, but until then,
 162                 // we add this probe.
 163                 {
 164                         Barry::Probe probe;
 165                         int i = probe.FindActive(m_ProbeResult->m_pin);
 166                         if( i != -1 )
 167                                 m_ProbeResult.reset( new Barry::ProbeResult(probe.Get(i)) );
 168                 }
 169
 170                 DoConnect();
 171
 172                 return;
 173         }
 174         catch( Usb::Timeout & ) {
 175                 if( tries > 1 ) {
 176                         throw;
 177                 }
 178                 else {
 179                         std::cout << "Timeout in Reconnect()... trying again" << std::endl;
 180                 }
 181         }
 182 }
 183
 184 void BarryEnvironment::Disconnect()
 185 {
 186         delete m_pDesktop;
 187         m_pDesktop = 0;
 188
 189         delete m_pCon;
 190         m_pCon = 0;
 191
 192         m_NeedsReconnect = false;
 193 }
 194
 195 bool BarryEnvironment::isConnected()
 196 {
 197         if (m_pCon != 0)
 198                 return true;
 199
 200         return false;
 201 }
 202
 203 void BarryEnvironment::ReconnectForDirtyFlags()
 204 {
 205         if( m_NeedsReconnect ) {
 206                 // Reconnect resets the m_NeedsReconnect via Disconnect
 207                 Reconnect();
 208         }
 209 }
 210
 211 void BarryEnvironment::RequireDirtyReconnect()
 212 {
 213         m_NeedsReconnect = true;
 214 }
 215
 216 void BarryEnvironment::ClearDirtyFlags(Barry::RecordStateTable &table,
 217                                 const std::string &dbname)
 218 {
 219         Trace trace("ClearDirtyFlags");
 220
 221         unsigned int dbId = m_pDesktop->GetDBID(dbname);
 222
 223         Barry::RecordStateTable::StateMapType::const_iterator i = table.StateMap.begin();
 224         for( ; i != table.StateMap.end(); ++i ) {
 225                 if( i->second.Dirty ) {
 226                         trace.logf("Clearing dirty flag for db %u, index %u",
 227                                 dbId, i->first);
 228                         m_pDesktop->ClearDirty(dbId, i->first);
 229                 }
 230         }
 231 }
 232
 233 void BarryEnvironment::ClearCalendarDirtyFlags()
 234 {
 235         Trace trace("ClearCalendarDirtyFlags");
 236         ClearDirtyFlags(m_CalendarSync.m_Table, Barry::Calendar::GetDBName());
 237 }
 238
 239 void BarryEnvironment::ClearContactsDirtyFlags()
 240 {
 241         Trace trace("ClearContactsDirtyFlags");
 242         ClearDirtyFlags(m_ContactsSync.m_Table, Barry::Contact::GetDBName());
 243 }
 244
 245 void BarryEnvironment::ClearJournalDirtyFlags()
 246 {
 247         Trace trace("ClearJournalDirtyFlags");
 248         ClearDirtyFlags(m_JournalSync.m_Table, Barry::Memo::GetDBName());
 249 }
 250
 251 void BarryEnvironment::ClearTodoDirtyFlags()
 252 {
 253         Trace trace("ClearTodoDirtyFlags");
 254         ClearDirtyFlags(m_TodoSync.m_Table, Barry::Task::GetDBName());
 255 }
 256
 257 DatabaseSyncState* BarryEnvironment::GetSyncObject(OSyncChange *change)
 258 {
 259         Trace trace("BarryEnvironment::GetSyncObject()");
 260
 261         const char *name = osync_change_get_objtype(change);
 262
 263         trace.logf("osync_change_get_objtype returns %s", name);
 264
 265         if( strcmp(name, "event") == 0 ) {
 266                 trace.log("return calendar object");
 267
 268                 return &m_CalendarSync;
 269         }
 270         else if( strcmp(name, "contact") == 0 ) {
 271                 trace.log("return contact object");
 272
 273                 return &m_ContactsSync;
 274         }
 275         else if( strcmp(name, "note") == 0 ) {
 276                 trace.log("return journal object");
 277
 278                 return &m_JournalSync;
 279         }
 280         else if( strcmp(name, "todo") == 0 ) {
 281                 trace.log("return todo object");
 282
 283                 return &m_TodoSync;
 284         }
 285
 286         trace.log("return none");
 287
 288         return 0;
 289 }
 290