contactsmodule.cpp

python s60 1.4.5版本的源代码

    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(IsContactGroup(*item)==EFalse){
    delete item;
    PyErr_SetString(PyExc_RuntimeError, "not a contact group");
    return NULL;
  }
  
  CContactGroup* group = dynamic_cast<CContactGroup*>(item);

  TPtrC labelPtr((TUint16*)PyUnicode_AsUnicode(label),PyUnicode_GetSize(label));  
  TRAP(error, {
    group->SetGroupLabelL(labelPtr);
    self->contactDatabase->CommitContactL(*group);
  });
  delete item;
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Returns id:s of contacts that are members of the specified contact group.
 */
extern "C" PyObject *
ContactsDb_contact_group_ids(ContactsDb_object* self, PyObject *args)
{
  TInt error = KErrNone;
  TInt32 entryId = -1;
  CContactItem* item = NULL;
  PyObject* idList = NULL;
  const CContactIdArray* idArray = NULL;
  
  if (!PyArg_ParseTuple(args, "i", &entryId)){ 
    return NULL;
  }
    
  TRAP(error, {
    item = self->contactDatabase->ReadContactL(entryId);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(IsContactGroup(*item)==EFalse){
    delete item;
    PyErr_SetString(PyExc_RuntimeError, "not a contact group");
    return NULL;
  }
  
  CContactGroup* group = dynamic_cast<CContactGroup*>(item);
  idArray = group->ItemsContained();
  
  idList = PyList_New(idArray->Count());
  if(idList==NULL){
    delete item;
    return PyErr_NoMemory();
  }
  
  for(TInt i=0;i<idArray->Count();i++){
    PyObject* id = Py_BuildValue("i", (*idArray)[i]);
    if(id==NULL){
      delete item;
      Py_DECREF(idList);
      return NULL;
    }
    if(PyList_SetItem(idList, i, id)!=0){
      delete item;
      Py_DECREF(idList);
      return NULL;
    }
  }
  delete item;
  return idList;
}


/*
 * Adds contact entry to the specified contact group.
 */
extern "C" PyObject *
ContactsDb_add_contact_to_group(ContactsDb_object* self, PyObject *args)
{
  TInt error = KErrNone;
  TInt32 entryId = -1;
  TInt32 groupId = -1;
  CContactItem* item = NULL;
  
  if (!PyArg_ParseTuple(args, "ii", &entryId, &groupId)){ 
    return NULL;
  }
 
  TRAP(error, {
    item = self->contactDatabase->ReadContactL(groupId);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(IsContactGroup(*item)==EFalse){
    delete item;
    PyErr_SetString(PyExc_RuntimeError, "not a contact group");
    return NULL;
  }
  delete item;
  
  
  TRAP(error, {
    self->contactDatabase->AddContactToGroupL(entryId,groupId);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Removes contact from the group.
 */
extern "C" PyObject *
ContactsDb_remove_contact_from_group(ContactsDb_object* self, PyObject *args)
{
  TInt error = KErrNone;
  TInt32 entryId = -1;
  TInt32 groupId = -1;
  CContactItem* item = NULL;
  CContactGroup* group = NULL;
  
  if (!PyArg_ParseTuple(args, "ii", &entryId, &groupId)){ 
    return NULL;
  }
  
  TRAP(error, {
    item = self->contactDatabase->ReadContactL(groupId);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(IsContactGroup(*item)==EFalse){
    delete item;
    PyErr_SetString(PyExc_RuntimeError, "not a contact group");
    return NULL;
  }
  group = dynamic_cast<CContactGroup*>(item);
  if(group->ContainsItem(entryId)==EFalse){
    delete item;
    PyErr_SetString(PyExc_RuntimeError, "contact is not a member of the group");
    return NULL;
  }
  delete item;
 
  TRAP(error, {
    self->contactDatabase->RemoveContactFromGroupL(entryId,groupId);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Creates a new contact group.
 */
extern "C" PyObject *
ContactsDb_create_contact_group(ContactsDb_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;
  CContactItem* item = NULL;
  PyObject* ret = NULL;
    
  TRAP(error, {
    item = self->contactDatabase->CreateContactGroupL();
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  ret = Py_BuildValue("i", item->Id());
  delete item;
  
  return ret;
}


/*
 * Returns number of contact groups.
 */
extern "C" PyObject *
ContactsDb_contact_group_count(ContactsDb_object* self, PyObject* /*args*/)
{    
  return Py_BuildValue("i", self->contactDatabase->GroupCount());
}


/*
 * ContactsDb_object deletes given contact entry from the database.
 */
extern "C" PyObject *
ContactsDb_delete_entry(ContactsDb_object* self, PyObject* args)
{
  TInt32 entryId = -1;
  if (!PyArg_ParseTuple(args, "i", &entryId)){ 
    return NULL;
  }
    
  
  TInt error = KErrNone;
  TRAP(error, self->contactDatabase->DeleteContactL(entryId));
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  Py_INCREF(Py_None);
  return Py_None;   
}


/*
 * Returns number of contacts.
 */
extern "C" PyObject *
ContactsDb_entry_count(ContactsDb_object *self, PyObject* /*args*/)
{
  TInt length = -1;

  TRAPD(error, {
    length = self->contactDatabase->CountL();
  });
  if(error != KErrNone){
    SPyErr_SetFromSymbianOSErr(error);
  }

  return Py_BuildValue("i", length);
}


/*
 * Tests whether a compressing is recommended.
 */
extern "C" PyObject *
ContactsDb_compact_recommended(ContactsDb_object* self, PyObject* /*args*/)
{
  return Py_BuildValue("i", self->contactDatabase->CompressRequired());
}


/*
 * Compresses the database.
 */
extern "C" PyObject *
ContactsDb_compact(ContactsDb_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;

  Py_BEGIN_ALLOW_THREADS
  TRAP(error, {
    self->contactDatabase->CompactL();
  });
  Py_END_ALLOW_THREADS

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


/*
 * Returns information about the specified field type.
 */
extern "C" PyObject *
ContactsDB_field_type_info(ContactsDb_object* self, PyObject* args)
{
  TInt error = KErrNone;
  TInt index = -1;
  CContactItem* templateItem = NULL;
  PyObject* ret = NULL;
    
  if (!PyArg_ParseTuple(args, "i", &index)){ 
    return NULL;
  }
  
  TRAP(error, {
    templateItem = self->contactDatabase->ReadContactL(self->contactDatabase->TemplateId());
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  CContactItemFieldSet& templateFields = templateItem->CardFields(); 
  if(templateFields.Count()<=index){
    delete templateItem;
    PyErr_SetString(PyExc_ValueError,   "illegal index");
    return NULL;
  }
  
  CContactItemField& field = templateFields[index];
  
  ret = Py_BuildValue("{s:u#,s:i,s:i}", "name", field.Label().Ptr(),
                                                field.Label().Length(),
                                        "storagetype", field.StorageType(),
                                        "vcard_mapping", field.ContentType().Mapping());
                                    
  delete templateItem;
  return ret;  
}


/*
 * Returns ids of all field types (all that exist in the system template).
 */
extern "C" PyObject *
ContactsDB_field_types(ContactsDb_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;
  CContactItem* templateItem = NULL;
  PyObject* fieldTypes = NULL;
  PyObject* vcardMapping = NULL;
  PyObject* packedLists = NULL;
    
  TRAP(error, {
    templateItem = self->contactDatabase->ReadContactL(self->contactDatabase->TemplateId());
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
    
  CContactItemFieldSet& templateFields = templateItem->CardFields(); 
  TInt templateFieldsCount = templateFields.Count();
  fieldTypes = PyList_New(templateFieldsCount);
  if(fieldTypes==NULL){
    delete templateItem;
    return PyErr_NoMemory();
  }
  vcardMapping = PyList_New(templateFieldsCount);
  if(vcardMapping==NULL){
    delete templateItem;
    delete fieldTypes;
    return PyErr_NoMemory();
  }
  
  for(TInt i=0;i<templateFieldsCount;i++){
    CContactItemField& field = templateFields[i];  
    TInt fieldTypesCount = field.ContentType().FieldTypeCount();
    PyObject* idList = PyList_New(fieldTypesCount);
    if(idList==NULL){
      Py_DECREF(fieldTypes);
      delete templateItem;
      return PyErr_NoMemory();
    }
    for(TInt j=0;j<fieldTypesCount;j++){
      PyObject* id = Py_BuildValue("i",field.ContentType().FieldType(j));
      if(id==NULL){
        Py_DECREF(idList);
        Py_DECREF(fieldTypes);
        delete templateItem;
        return NULL;
      }
      if(PyList_SetItem(idList,j,id)!=0){
        Py_DECREF(idList);
        Py_DECREF(fieldTypes);
        delete templateItem;
        return NULL;
      }
    }
    if(PyList_SetItem(fieldTypes,i,idList)!=0){
      Py_DECREF(idList);
      Py_DECREF(fieldTypes);
      delete templateItem;
      return NULL;
    }
    PyObject* vcard_id = Py_BuildValue("i",field.ContentType().Mapping());
    if(vcard_id==NULL){
        Py_DECREF(fieldTypes);
        Py_DECREF(vcardMapping);
        delete templateItem;
        return NULL;
      }
    if(PyList_SetItem(vcardMapping,i,vcard_id)!=0){
      Py_DECREF(vcardMapping);
      Py_DECREF(fieldTypes);
      delete templateItem;
      return NULL;
    }
  }   
  
  delete templateItem;
  packedLists = PyList_New(2*templateFieldsCount);
  if(packedLists==NULL){
    Py_DECREF(fieldTypes);
    Py_DECREF(vcardMapping);
    return PyErr_NoMemory();
  }
  if(PyList_SetItem(packedLists,0,fieldTypes)!=0){
    Py_DECREF(packedLists);
    delete fieldTypes;
    delete vcardMapping;
    return NULL;
  }
  if(PyList_SetItem(packedLists,1,vcardMapping)!=0){
    Py_DECREF(packedLists);
    delete fieldTypes;
    delete vcardMapping;
    return NULL;
  }
  return packedLists;
}


/*
 * Imports VCards (vcards are given in a string).
 * Returns tuple that containts unique id:s of imported
 * contact entries.
 */
extern "C" PyObject *
ContactsDb_import_vcards(ContactsDb_object* self, PyObject* args)
{
  char* vCardStr = NULL;
  TInt vCardStrLength = 0;
  TInt flags = CContactDatabase::EIncludeX 
              |CContactDatabase::ETTFormat;
  PyObject* idTuple = NULL;
  CArrayPtr<CContactItem>* imported = NULL;
   
  if (!PyArg_ParseTuple(args, "s#|i",
                        &vCardStr, &vCardStrLength, &flags)){ 

    return NULL;