contactsmodule.cpp

python s60 1.4.5版本的源代码

  }

  TPtrC8 vCardStrPtr((TUint8*)vCardStr, vCardStrLength); 
  
  TUid uid;
  uid.iUid = KVersitEntityUidVCard;
  TBool success = EFalse;
 
  TRAPD(error, {
    RMemReadStream inputStream(vCardStrPtr.Ptr(), vCardStrPtr.Length());  
    CleanupClosePushL(inputStream);  
    imported = 
      self->contactDatabase->ImportContactsL(uid, inputStream, 
                                               success, flags); 
    CleanupStack::PopAndDestroy(); // Close inputStream.
  });

  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  idTuple = PyTuple_New(imported->Count());

  if(idTuple==NULL){
    imported->ResetAndDestroy(); 
    delete imported;
    return PyErr_NoMemory();
  }

  for(TInt i=0;i<imported->Count();i++){
    PyObject* idObj = Py_BuildValue("i", ((*imported)[i])->Id());
    if(idObj==NULL){
      Py_DECREF(idTuple);
      imported->ResetAndDestroy(); 
      delete imported;
      return NULL;
    }
    if(PyTuple_SetItem(idTuple, i, idObj)<0){
      Py_DECREF(idTuple);
      imported->ResetAndDestroy(); 
      delete imported;
      return NULL;
    }
  }

  imported->ResetAndDestroy(); 
  delete imported;

  return idTuple;
}


/*
 * Writes VCards that represent specified contact entries into the unicode string.
 */
extern "C" PyObject *
ContactsDb_export_vcards(ContactsDb_object* self, PyObject* args)
{

  TInt error = KErrNone;
  PyObject* idTuple;
  CContactIdArray* idArray = NULL;
  TInt flags = CContactDatabase::EIncludeX
              |CContactDatabase::ETTFormat;
  PyObject* ret = NULL;
  
  if (!PyArg_ParseTuple(args, "O!|i", 
                        &PyTuple_Type, &idTuple, &flags)){ 
    return NULL;
  }

  if(PyTuple_Size(idTuple)<1){
    PyErr_SetString(PyExc_SyntaxError, "no contact id:s given in the tuple");
    return NULL;
  }

  TRAP(error, { 
    idArray = CContactIdArray::NewL();
  });

  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  // Put the unique contact id:s into the idArray.
  TInt idCount = PyTuple_Size(idTuple);
  for(TInt i=0;i<idCount;i++){
    PyObject* idItem = PyTuple_GetItem(idTuple, i);

    if(!PyInt_Check(idItem)){
      delete idArray;
      PyErr_SetString(PyExc_TypeError, "illegal argument in the tuple");
      return NULL;
    };

    TInt uniqueId = PyInt_AsLong(idItem);
    TRAPD(error, {
      idArray->AddL(uniqueId);
    });

    if(error != KErrNone){
      delete idArray;
      return SPyErr_SetFromSymbianOSErr(error);
    }
  }

  // Do the export.
  TRAP(error, {
    CleanupStack::PushL(idArray);

    CBufFlat* flatBuf = CBufFlat::NewL(4);
    CleanupStack::PushL(flatBuf);
    RBufWriteStream outputStream(*flatBuf);
    CleanupClosePushL(outputStream);

    TUid uid;
    uid.iUid = KVersitEntityUidVCard;
   
    // Export contacts into the stream.
    self->contactDatabase->ExportSelectedContactsL(uid,
                                                   *idArray, 
                                                   outputStream,
                                                   flags);  
    outputStream.CommitL();        
    CleanupStack::PopAndDestroy(); // Close outputStream.  
    
    ret = Py_BuildValue("s#", (char*)flatBuf->Ptr(0).Ptr(), flatBuf->Size());
    
    CleanupStack::PopAndDestroy(); // flatBuf.
    CleanupStack::PopAndDestroy(); // idArray.
  });

  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }    
  return ret;
}


/*
 * Quesses the default label of the field (in case of incomplete field definition
 * that has no match in the template).
 * This is used to determine the corresponding field type.
 */
extern "C" PyObject *
ContactsDb_determine_field_name(ContactsDb_object* self, PyObject *args)
{  
  _LIT(KTempText,"123456789");
  _LIT8(KTempText8,"123456789");
  TTime tempTime;
  tempTime.HomeTime();
  
  TInt error=KErrNone;
  CContactItem* tempContact = NULL;
  CContactItemField* field = NULL;
  PyObject* label = NULL;
  TContactItemId id = KNullContactId;
  TInt userError = 0;
  
  PyObject* idTuple = NULL;
  TInt mapping = 0;
  TInt storageType = 0;
  
  if (!PyArg_ParseTuple(args, "iiO", &storageType, &mapping, &idTuple)){ 
    return NULL;
  }
  
  if(!PyTuple_Check(idTuple)){
    PyErr_SetString(PyExc_TypeError, "ids must be given in a tuple");
    return NULL;
  }
  
  TRAP(error,{  
    tempContact = (CContactItem*) CContactCard::NewL(); 
    CleanupStack::PushL(tempContact);
    
    field = CContactItemField::NewL(storageType);
    CleanupStack::PushL(field);   
    
    for(TInt i=0;i<PyTuple_Size(idTuple);i++){
      PyObject* fieldIdObj = PyTuple_GetItem(idTuple,i);
      field->AddFieldTypeL(TUid::Uid(PyInt_AsLong(fieldIdObj)));
    }
    
    field->SetMapping(TUid::Uid(mapping));
    
    if(storageType==KStorageTypeText){
      field->TextStorage()->SetTextL(KTempText);
    }else if(storageType==KStorageTypeDateTime){
      field->DateTimeStorage()->SetTime(tempTime);
    }else if(storageType==KStorageTypeStore){
      field->StoreStorage()->SetThingL(KTempText8);
    }else if(storageType==KStorageTypeContactItemId){
      field->AgentStorage()->SetAgentId(0);
    }else{
      // this can never happen unless additional storage types will be specified in the SDK.
      User::Leave(KErrNotSupported);
    }
    
    tempContact->AddFieldL(*field);
    CleanupStack::Pop(); // field.
    CleanupStack::Pop(); // tempContact.
  });  
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }   
  
  TRAP(error, {
    id=self->contactDatabase->AddNewContactL(*tempContact);
  });
  delete tempContact;
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  TRAP(error, {
    tempContact = NULL;  
    tempContact = self->contactDatabase->OpenContactL(id); 
    CleanupStack::PushL(tempContact); 
    if(tempContact->CardFields().Count()==1){
      label = Py_BuildValue("u#", tempContact->CardFields()[0].Label().Ptr(),tempContact->CardFields()[0].Label().Length());
    }else{
      userError = 1;
    }
    self->contactDatabase->CloseContactL(id);
    CleanupStack::PopAndDestroy(tempContact);
    self->contactDatabase->DeleteContactL(id);
  });
  if(error!=KErrNone){
    Py_XDECREF(label);
    return SPyErr_SetFromSymbianOSErr(error);
  }
  if(userError==1){
    PyErr_SetString(PyExc_RuntimeError, "field type check failed");
    return NULL;
  }
      
  return label;  
}


/*
 * Deallocate ContactsDb_object.
 */
extern "C" {
  static void ContactsDb_dealloc(ContactsDb_object *contactsDb)
  {
    delete contactsDb->contactDatabase;
    PyObject_Del(contactsDb);
  }
} 



/*
 * ContactIterator methods.
 */


 
/*
 * Create new ContactIterator object.
 */
extern "C" PyObject *
new_ContactIterator_object(ContactsDb_object* self, PyObject* /**args*/)
{
  TContactIter* iterator = NULL;
  ContactIterator_object* ci = NULL;
  
  TRAPD(error, {
    iterator = new (ELeave) TContactIter(*(self->contactDatabase));
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  ci = PyObject_New(ContactIterator_object, ContactIterator_type);
  if (ci == NULL){
    delete iterator;
    return PyErr_NoMemory();
  }
  
  ci->initialized = false;
  ci->contactsDb = self;
  ci->iterator = iterator; 
  
  ci->contactsDb = self;
  Py_INCREF(ci->contactsDb);
  return (PyObject*)ci;
}


/*
 * Get the uniqueId of the next contact entry object.
 */
extern "C" PyObject *
ContactIterator_next(ContactIterator_object* self, PyObject* /**args*/)
{
  TContactItemId uniqueId = KNullContactId;
  TInt error = KErrNone;
  CContactIdArray* groupIdArray = NULL; // prevent "group entries" from iterating.
  
  TRAP(error, {
    // note that this returns NULL if there are no groups.
    groupIdArray = self->contactsDb->contactDatabase->GetGroupIdListL();
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  do{
    if (self->initialized){
      TRAP(error, uniqueId = self->iterator->NextL());   
    }else{
      TRAP(error, uniqueId = self->iterator->FirstL());
      self->initialized = true;
    }
    if(error != KErrNone){   
      if(groupIdArray!=NULL){
        groupIdArray->Reset();
        delete groupIdArray;
      }
      return SPyErr_SetFromSymbianOSErr(error);
    }
  
    // Check if the iteration ended.
    if(uniqueId == KNullContactId){
      if(groupIdArray!=NULL){
        groupIdArray->Reset();
        delete groupIdArray;
      }
      PyErr_SetObject(PyExc_StopIteration, Py_None);
      return NULL;
    }
  }while((groupIdArray!=NULL) && (groupIdArray->Find(uniqueId)!=KErrNotFound));  
    
  if(groupIdArray!=NULL){
    groupIdArray->Reset();
    delete groupIdArray;
  }
  
  return Py_BuildValue("i", uniqueId);
}


/*
 * Deallocate ContactIterator_object.
 */
extern "C" {
  static void ContactIterator_dealloc(ContactIterator_object *contactIterator)
  {  
    delete contactIterator->iterator;
    contactIterator->iterator = NULL;
  
    Py_DECREF(contactIterator->contactsDb);
    PyObject_Del(contactIterator);
  }
}



/*
 * Contact methods.
 */


 
/*
 * Create new Contact object.
 * if (uniqueId == KNullContactId) completely new contact entry is created.
 * Else only new (python) contact object is created (wrapper object to 
 * existing native contact entry that the uniqueId identifies).
 */
extern "C" PyObject *
new_Contact_object(ContactsDb_object* self, TContactItemId uniqueId)
{
  Contact_object* contact = PyObject_New(Contact_object, Contact_type);
  if (contact == NULL){
    return PyErr_NoMemory();
  }

  // Initialize the contact struct.
  contact->mode = CONTACT_NOT_OPEN;
  contact->contactItem = NULL;
  contact->contactsDb = NULL;
  contact->uniqueID = KNullContactId;
  
  if(uniqueId == KNullContactId){        
    // a new contact entry must be created into the database.
    TRAPD(error, {
      contact->contactItem = (CContactItem*) CContactCard::NewL();
      contact->mode = CONTACT_READ_WRITE;
    });

    if(error != KErrNone){  
      PyObject_Del(contact);
      return SPyErr_SetFromSymbianOSErr(error);
    } 
  }else{
    // contact entry that corresponds to given unique id exists.
    TRAPD(error, {
      contact->contactItem = self->contactDatabase->ReadContactL(uniqueId); 
      contact->mode = CONTACT_READ_ONLY;
    });
    if(error != KErrNone){  
      PyObject_Del(contact);
      return SPyErr_SetFromSymbianOSErr(error);
    }
  }

  contact->contactsDb = self;
  contact->uniqueID = uniqueId;
  Py_INCREF(contact->contactsDb);
  return (PyObject*)contact;
}


/*
 * Deletes the CContactItem inside the contact object.
 */
void Contact_delete_entry(Contact_object* self)
{
  if((self->mode==CONTACT_READ_WRITE) && (self->uniqueID!=KNullContactId)){
    self->contactsDb->contactDatabase->CloseContactL(self->uniqueID);
  }
  delete self->contactItem;
  self->contactItem = NULL;
  self->mode = CONTACT_NOT_OPEN;
}


/*
 * Sets the contact to the read-only mode.
 */
extern "C" PyObject *
Contact_open_ro(Contact_object* self)
{
  if(self->mode == CONTACT_READ_ONLY){
    // Already in read-only mode.
    Py_INCREF(Py_None);
    return Py_None;
  }