contactsmodule.cpp

python s60 1.4.5版本的源代码

  }

  if(fieldIdTuple){
    // Search only specified field types.
    CPbkFieldIdArray* selectedFieldIds = new (ELeave) CPbkFieldIdArray;
    CleanupStack::PushL(selectedFieldIds);

    for(TInt i=0;i<PyTuple_Size(fieldIdTuple);i++){
      PyObject* fieldIdItem = PyTuple_GetItem(fieldIdTuple, i);
      TInt fieldId = PyInt_AsLong(fieldIdItem);
      if(fieldIdArray->Find(fieldId)!=KErrNotFound){
        selectedFieldIds->AppendL(fieldId);
      }
    }
    CleanupStack::Pop(selectedFieldIds);
    CleanupStack::PopAndDestroy(fieldIdArray);
    return selectedFieldIds;
  }else{
    // Search all field types.
    CleanupStack::Pop(fieldIdArray);
    return fieldIdArray;
  }
}


/*
 * Execute the search.
 */
CContactIdArray*
ContactsDb_searchL(ContactsDb_object* self, 
                   TDesC& searchStr, 
                   CPbkFieldIdArray* selectedFieldIds)
{
  CContactIdArray* idArray = NULL;
  idArray = self->contactEngine->FindLC(searchStr, selectedFieldIds);
  CleanupStack::Pop(idArray);
  return idArray;
}


/*
 * Searches contacts by string (match is detected if the string is
 * a substring of some field value of the contact).
 * Returns tuple of unique contact ID:s representing contact entrys
 * matching the criteria.
 */
extern "C" PyObject *
ContactsDb_find(ContactsDb_object* self, PyObject *args)
{
  ASSERT_DBOPEN

  PyObject* searchString = NULL;
  CContactIdArray* idArray = NULL;
  PyObject* fieldIdTuple = NULL;

  if (!PyArg_ParseTuple(args, "U|O!", 
                        &searchString, &PyTuple_Type, &fieldIdTuple)){ 
    return NULL;
  }

  TPtrC searchStringPtr((TUint16*) PyUnicode_AsUnicode(searchString), 
                         PyUnicode_GetSize(searchString));
  
  TRAPD(error, {
    CPbkFieldIdArray* selectedFieldIds = 
      ContactsDb_getFieldIdArrayL(self, fieldIdTuple);
    CleanupStack::PushL(selectedFieldIds);
    idArray = ContactsDb_searchL(self, searchStringPtr, selectedFieldIds);
    CleanupStack::PopAndDestroy(selectedFieldIds);
  });

  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
 
  PyObject* idArrayTuple = PyTuple_New(idArray->Count());
  if (idArrayTuple == NULL){
    delete idArray;
    return PyErr_NoMemory();
  }
  
  for(TInt i=0; i<idArray->Count(); i++){
    PyObject* entryId = Py_BuildValue("i", (*idArray)[i]);
    if (entryId == NULL){
      delete idArray;
      Py_DECREF(idArrayTuple);
      return NULL;
    }
    if(PyTuple_SetItem(idArrayTuple, i, entryId)<0){
      Py_DECREF(idArrayTuple);
      delete idArray;
      return NULL;
    }
  }
  delete idArray;
  return (PyObject*)idArrayTuple;
}


/*
 * Imports VCards (vcards are given in unicode string).
 * Returns tuple that containts unique id:s of imported
 * contact entries.
 */
extern "C" PyObject *
ContactsDb_import_vcards(ContactsDb_object* self, PyObject* args)
{
  ASSERT_DBOPEN

  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;
  }

  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->contactEngine->Database().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 specified VCards into unicode string.
 */
extern "C" PyObject *
ContactsDb_export_vcards(ContactsDb_object* self, PyObject* args)
{
  ASSERT_DBOPEN

  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->contactEngine->Database().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;
}




/*
 * Returns id:s of contact groups in a list.
 */
extern "C" PyObject *
ContactsDb_contact_groups(ContactsDb_object* self, PyObject *args)
{
  TInt error = KErrNone;
  CContactIdArray* idArray = NULL;
  PyObject* idList = NULL;
  
  TRAP(error, {
    idArray = self->contactEngine->Database().GetGroupIdListL();
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  idList = PyList_New(idArray->Count());
  if(idList==NULL){
    idArray->Reset();
    delete idArray;
    return PyErr_NoMemory();
  }
  
  for(TInt i=0;i<idArray->Count();i++){
    PyObject* id = Py_BuildValue("i", (*idArray)[i]);
    if(id==NULL){
      idArray->Reset();
      delete idArray;
      Py_DECREF(idList);
      return NULL;
    }
    if(PyList_SetItem(idList, i, id)!=0){
      idArray->Reset();
      delete idArray;
      Py_DECREF(idList);
      return NULL;
    }
  }
  
  idArray->Reset();
  delete idArray;
  return idList;
}


/*
 * Returns name/label of specified contact group.
 */
extern "C" PyObject *
ContactsDb_contact_group_label(ContactsDb_object* self, PyObject *args)
{
  TInt error = KErrNone;
  PyObject* label = NULL;
  TInt32 entryId = -1;
  CContactItem* item = NULL;
  if (!PyArg_ParseTuple(args, "i", &entryId)){ 
    return NULL;
  }
    
  TRAP(error, {
    item = self->contactEngine->Database().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 = static_cast<CContactGroup*>(item);

  TRAP(error, {
    label = Py_BuildValue("u#",group->GetGroupLabelL().Ptr(),group->GetGroupLabelL().Length());
  });
  delete item;
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  return label;
}


/*
 * Sets name/label of the specified contact group.
 */
extern "C" PyObject *
ContactsDb_contact_group_set_label(ContactsDb_object* self, PyObject *args)
{
  TInt error = KErrNone;
  PyObject* label = NULL;
  TInt32 entryId = -1;
  CContactItem* item = NULL;
  if (!PyArg_ParseTuple(args, "iU", &entryId, &label)){ 
    return NULL;
  }
    
  TRAP(error, {
    item = self->contactEngine->Database().OpenContactL(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 = static_cast<CContactGroup*>(item);

  TPtrC labelPtr((TUint16*)PyUnicode_AsUnicode(label),PyUnicode_GetSize(label));  
  TRAP(error, {
    group->SetGroupLabelL(labelPtr);
    self->contactEngine->Database().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->contactEngine->Database().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 = static_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->contactEngine->Database().ReadContactL(groupId);
  });
  if(error!=KErrNone){