contactsmodule.cpp

python s60 1.4.5版本的源代码

  TRAPD(error, {
    self->contactItem = 
      self->contactsDb->contactDatabase->ReadContactL(self->uniqueID);
    self->mode = CONTACT_READ_ONLY;
  });  

  RETURN_ERROR_OR_PYNONE(error);
}


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

  TRAPD(error, {
    self->contactItem = 
      self->contactsDb->contactDatabase->OpenContactL(self->uniqueID);
    self->mode = CONTACT_READ_WRITE;
  });

  RETURN_ERROR_OR_PYNONE(error);
}


/*
 * Returns contact data (attributes of contact, not it's field data).
 */
extern "C" PyObject *
Contact_entry_data(Contact_object* self, PyObject* /*args*/)
{
  ASSERT_CONTACTOPEN
  
  PyObject* entryData = 
    Py_BuildValue("{s:i,s:d}", 
                   (const char*)(&KKeyStrUniqueId)->Ptr(), self->contactItem->Id(),
                   (const char*)(&KKeyStrLastModified)->Ptr(), 
                   time_as_UTC_TReal(self->contactItem->LastModified()));

  return  entryData;
}


/*
 * Opens contact for writing.
 */
extern "C" PyObject *
Contact_begin(Contact_object* self, PyObject* /*args*/)
{
  if(self->mode != CONTACT_READ_WRITE){
    Contact_delete_entry(self);
    return Contact_open_rw(self);
  }

  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Commits the contact.
 */
extern "C" PyObject *
Contact_commit(Contact_object* self, PyObject* /*args*/)
{
  ASSERT_CONTACT_READ_WRITE

  TInt error = KErrNone;
  
  if(self->uniqueID == KNullContactId){
    // New contact.
    TRAP(error, 
      self->uniqueID = 
        self->contactsDb->contactDatabase->AddNewContactL(*self->contactItem));
  } else {
    // Old contact (begin() called).
    TRAP(error, 
      self->contactsDb->contactDatabase->CommitContactL(*self->contactItem));
  }  
  
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  Contact_delete_entry(self);

  return Contact_open_ro(self);
}


/*
 * Closes (but does not commit) the contact.
 */
extern "C" PyObject *
Contact_rollback(Contact_object* self, PyObject* /*args*/)
{
  if(self->mode != CONTACT_READ_WRITE || self->uniqueID == KNullContactId){
    PyErr_SetString(PyExc_RuntimeError, "begin not called");
    return NULL; 
  }

  TInt error = KErrNone;

  TRAP(error, 
    self->contactsDb->contactDatabase->CloseContactL(self->uniqueID));
  
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  Contact_delete_entry(self);

  return Contact_open_ro(self);
}


/*
 * Returns indexes of the fields that represent given fieldtype.
 */
extern "C" PyObject *
Contact_find_field_indexes(Contact_object* self, PyObject* args)
{
  ASSERT_CONTACTOPEN
  
  TInt error = KErrNone;
  CArrayVarFlat<TInt>* indexArray = NULL;
  TInt fieldIndex=0;
  TInt fieldId = -1;

  if (!PyArg_ParseTuple(args, "i", &fieldId)){ 
    return NULL;
  }

  CContactItemFieldSet& fieldSet = self->contactItem->CardFields();

  TRAP(error, {
    indexArray = new (ELeave) CArrayVarFlat<TInt>(2); // 2 is the granularity (not the size..)
    TUid fieldUid;
    fieldUid = TUid::Uid(fieldId);
    do{
      fieldIndex = fieldSet.FindNext(fieldUid, fieldIndex);
      if(fieldIndex!=KErrNotFound){
        indexArray->AppendL(fieldIndex, sizeof(fieldIndex));  
        fieldIndex++;
      }
    }while(fieldIndex!=KErrNotFound);
  });
  if(error!=KErrNone){
    if(indexArray!=NULL){
      indexArray->Reset();
    }
    delete indexArray;
    return SPyErr_SetFromSymbianOSErr(error);
  }

  PyObject* indexList = PyList_New(indexArray->Count());
  if(indexList==NULL){
    indexArray->Reset();
    delete indexArray;
    return PyErr_NoMemory();
  }
  for(TInt i=0;i<indexArray->Count();i++){
    PyObject* theIndex = Py_BuildValue("i", indexArray->At(i));
    if(theIndex==NULL){
      indexArray->Reset();
      delete indexArray;
      Py_DECREF(indexList);
      return NULL;
    }
    if(0>PyList_SetItem(indexList,i,theIndex)){
      indexArray->Reset();
      delete indexArray;
      Py_DECREF(indexList);
      return NULL;
    }
  }

  indexArray->Reset();
  delete indexArray;
  return indexList;
}  


/*
 * Test if the contact entry is a contact group.
 */
extern "C" PyObject *
Contact_is_contact_group(Contact_object* self, PyObject* /*args*/)
{ 
  TBool isGroup = EFalse; 
  if(EFalse!=IsContactGroup(*(self->contactItem))){
    isGroup = ETrue;
  }
  
  return Py_BuildValue("i", isGroup);
}


/*
 * Modifies contact field.
 */
extern "C" PyObject *
Contact_modify_field(Contact_object* self, PyObject *args, PyObject *keywds)
{
  TInt error = KErrNone;
  PyObject* valueObj = NULL;
  PyObject* label = NULL;
  TInt fieldIndex = -1;
  TReal dateVal = -1;
  char* value = NULL; 
  TInt valueLength = 0;
  
  static const char *const kwlist[] = 
    {"field_index", "value", "label", NULL};
 
  if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|OU", (char**)kwlist,
                                   &fieldIndex, 
                                   &valueObj, 
                                   &label)){ 
    return NULL;
  }
  
  if(valueObj){ 
    if(PyFloat_Check(valueObj)){
      // DateTime type.
      dateVal = PyFloat_AsDouble(valueObj);
    } else if(PyUnicode_Check(valueObj)){
      // Text type.
      value = (char*)PyUnicode_AsUnicode(valueObj);
      valueLength = PyUnicode_GetSize(valueObj);
    } else {
      PyErr_SetString(PyExc_TypeError, "illegal value parameter");
      return NULL;
    }
  }
  
  if(fieldIndex >= self->contactItem->CardFields().Count()){
    PyErr_SetString(PyExc_ValueError, "illegal field index");
    return NULL;
  }
  
  CContactItemField& field = self->contactItem->CardFields()[fieldIndex];  
  if((field.StorageType()==KStorageTypeText) && (value !=NULL)){
    TRAP(error, {
      field.TextStorage()->SetTextL(TPtrC((TUint16*)value, valueLength));
    });
    if(error!=KErrNone){
      return SPyErr_SetFromSymbianOSErr(error);
    }
  }else if((field.StorageType()==KStorageTypeDateTime) && (dateVal > 0)){
    TTime datetime;
    pythonRealAsTTime(dateVal, datetime);
    field.DateTimeStorage()->SetTime(datetime);
  }else if((value != NULL) || (dateVal > 0)){
    PyErr_SetString(PyExc_ValueError, "illegal field type or value");
    return NULL;
  } 
      
  if(label!=NULL){    
    TRAP(error, {
      field.SetLabelL(TPtrC((TUint16*)PyUnicode_AsUnicode(label),PyUnicode_GetSize(label)));
    }); 
    if(error!=KErrNone){
      return SPyErr_SetFromSymbianOSErr(error);
    }  
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Adds field to the contact.
 */
extern "C" PyObject *
Contact_add_field(Contact_object* self, PyObject *args, PyObject *keywds)
{  
  ASSERT_CONTACT_READ_WRITE
  
  TInt error = KErrNone;
  TInt fieldInfoIndex = -1;
  PyObject* valueObj = NULL;
  char* value = NULL; 
  TInt valueLength = 0;
  PyObject* label = NULL;
  TReal dateVal = -1;
  TInt userError = 0;
  CContactItemField* field = NULL;
 
  static const char *const kwlist[] = 
    {"fieldtype", "value", "label", NULL};
 
  if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|OU", (char**)kwlist,
                                   &fieldInfoIndex, 
                                   &valueObj, 
                                   &label)){ 
    return NULL;
  }

  if(valueObj){ 
    if(PyFloat_Check(valueObj)){
      // DateTime type.
      dateVal = PyFloat_AsDouble(valueObj);
    } else if(PyUnicode_Check(valueObj)){
      // Text type.
      value = (char*)PyUnicode_AsUnicode(valueObj);
      valueLength = PyUnicode_GetSize(valueObj);
    } else {
      PyErr_SetString(PyExc_TypeError, "illegal value parameter");
      return NULL;
    }
  }
  
  TRAP(error, {
    CContactItem* templateItem = 
      self->contactsDb->contactDatabase->ReadContactL(self->contactsDb->contactDatabase->TemplateId());
    CleanupStack::PushL(templateItem);
    
    CContactItemFieldSet& templateFields = templateItem->CardFields(); 
    if(templateFields.Count() > fieldInfoIndex){
      field = CContactItemField::NewL(templateFields[fieldInfoIndex]);
    }else{
      userError = 1;
    }
    CleanupStack::PopAndDestroy(templateItem);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  if(userError == 1){
    PyErr_SetString(PyExc_ValueError, "illegal fieldtype index");
    return NULL;
  }
  
  TRAP(error, {
    CleanupStack::PushL(field);
    if((field->StorageType()==KStorageTypeText) && (value !=NULL)){
      field->TextStorage()->SetTextL(TPtrC((TUint16*)value, valueLength));
    }else if((field->StorageType()==KStorageTypeDateTime) && (dateVal > 0)){
      TTime datetime;
      pythonRealAsTTime(dateVal, datetime);
      field->DateTimeStorage()->SetTime(datetime);
    }else{
      userError = 1; 
    }   
    if(userError == 0){
      if(label!=NULL){    
        field->SetLabelL(TPtrC((TUint16*)PyUnicode_AsUnicode(label),PyUnicode_GetSize(label)));
      }
      self->contactItem->AddFieldL(*field);
      CleanupStack::Pop(field);
    }else{
      CleanupStack::PopAndDestroy(field);
    }
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(userError == 1){
    PyErr_SetString(PyExc_ValueError, "illegal field type or value");
    return NULL;
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Returns field data of the field indicated by the fieldIndex.
 */
extern "C" PyObject *
Contact_build_field_data_object(Contact_object* self, TInt fieldIndex)
{
  ASSERT_CONTACTOPEN
  PyObject* fieldValue = NULL;
  PyObject* idList = NULL;
  
  CContactItemFieldSet& fieldArray = self->contactItem->CardFields();

  if (fieldIndex < 0 || fieldIndex >= fieldArray.Count()){
    PyErr_SetString(PyExc_IndexError, "illegal field index");
    return NULL; 
  }  

  CContactItemField& field = fieldArray[fieldIndex];
  
  if(KStorageTypeText == field.StorageType()){
    fieldValue = 
      Py_BuildValue("u#", field.TextStorage()->Text().Ptr(), field.TextStorage()->Text().Length()); 
  }else if(KStorageTypeDateTime == field.StorageType()){
    fieldValue = ttimeAsPythonFloat(field.DateTimeStorage()->Time());
  }else{
    fieldValue = Py_BuildValue("u", ""); // binary support ???
  }

  if(fieldValue == NULL){      
    return NULL;
  }
  
  idList = PyList_New(field.ContentType().FieldTypeCount());
  if(idList==NULL){
    Py_DECREF(fieldValue);
    return PyErr_NoMemory();
  }
  for(int i=0;i<field.ContentType().FieldTypeCount();i++){
    PyList_SetItem(idList,i,Py_BuildValue("i",field.ContentType().FieldType(i)));
  }

  PyObject* ret =  
    Py_BuildValue("{s:u#,s:O,s:i,s:i,s:i,s:i,s:O,s:i}",
                  "label",field.Label().Ptr(), field.Label().Length(),
                  "value", fieldValue,
                  "fieldindex", fieldIndex,
                  (const char*)(&KKeyStrFieldId)->Ptr(), 
                    field.Id(),
                  "storagetype", field.StorageType(),
                  "maxlength", KCntMaxTextFieldLength,
                  "field_ids",idList,
                  "vcard_mapping",field.ContentType().Mapping());

  Py_DECREF(fieldValue);
  Py_DECREF(idList);

  return ret;
}


/*
 * Returns indices of the fields that represent given fieldtype. 
 */
extern "C" PyObject *