locationacqmodule.cpp

python s60 1.4.5版本的源代码

{
  // create Positioner_object.
  Positioner_object* positioner = 
    PyObject_New(Positioner_object, Positioner_type);
  if (positioner == NULL){
    return PyErr_NoMemory();
  }
  
  // initialize Subsession_object's pointers.
  positioner->positionServer=NULL;
  positioner->positioner=NULL;
  positioner->requestorStack=NULL;
  positioner->dataFetcher=NULL;
    
  positioner->moduleid=moduleUid;  
  positioner->isSubSessionOpen=EFalse;
  // create symbian object RPositioner and connect it.
  RPositioner* pos=NULL;
  TInt err=KErrNone;
  TRAP(err,{
    pos=new (ELeave) RPositioner;
    positioner->positioner=pos;
  });
  if(err!=KErrNone){
    delete pos;
    Py_DECREF(positioner);
    return SPyErr_SetFromSymbianOSErr(err);
  }
  
  // XXX add dataFetcher creation here?
  
  positioner->callBackSet=EFalse;
  
  positioner->positionServer=posServ;
  Py_INCREF(posServ);
  return (PyObject*)positioner;
}


/*
 * Set requestors.
 * Requestors must be given in a list.
 * Each requestor is represented as a dictionary.
 */
extern "C" PyObject *
Positioner_set_requestors(Positioner_object *self,PyObject* args)
{
  TInt err=KErrNone;
  if(!self->isSubSessionOpen){
    err=opensubsession(self);
    if(err!=KErrNone){
      return SPyErr_SetFromSymbianOSErr(err);
    }
  }
  
  PyObject* requestorList=NULL;
  if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &requestorList)){ 
    return NULL;
  }
  
  if(PyList_Size(requestorList)<1){
    PyErr_SetString(PyExc_SyntaxError, 
                    "no requestors given in the list");
    return NULL;
  }
    
  // Create requestor object.
  deleteRequestorStack(self);
  TRAP(err,{
    self->requestorStack=new (ELeave) RRequestorStack;
  });
  if(KErrNone!=err){
    return SPyErr_SetFromSymbianOSErr(err);
  }

  TInt reqType=0;
  TInt reqFormat=0;
  for(int i=0;i<PyList_Size(requestorList);i++){
    PyObject* requestor = PyList_GetItem(requestorList,i);
    if(!PyDict_Check(requestor)){
      PyErr_SetString(PyExc_TypeError, 
                    "requestors must be dictonaries");
      return NULL;
    };
 
    PyObject* key = Py_BuildValue("s","type");
    if(key==NULL){
      return NULL;
    }
    PyObject* value = PyDict_GetItem(requestor,key);
    Py_DECREF(key);
    if(!PyInt_Check(value)){
      PyErr_SetString(PyExc_TypeError, 
                     "illegal requestor type information");
      return NULL;
    }
    reqType=PyInt_AsLong(value);
 
    key = Py_BuildValue("s","format");
    if(key==NULL){
      return NULL;
    }
    value = PyDict_GetItem(requestor,key);
    Py_DECREF(key);
    if(!PyInt_Check(value)){
      PyErr_SetString(PyExc_TypeError, 
                     "illegal requestor format information");
      return NULL;
    }     
    reqFormat=PyInt_AsLong(value);
    
    key = Py_BuildValue("s","data");
    if(key==NULL){
      return NULL;
    }
    value = PyDict_GetItem(requestor,key);
    Py_DECREF(key);
    if(!PyUnicode_Check(value)){
      PyErr_SetString(PyExc_TypeError, 
                     "illegal requestor data");
      return NULL;
    };     
    TPtrC valuePtr((TUint16*) PyUnicode_AsUnicode(value), PyUnicode_GetSize(value));
    
    CRequestor* req=NULL;
    TRAP(err, req = CRequestor::NewL(reqType, reqFormat, valuePtr));
    if(KErrNone!=err){
      return SPyErr_SetFromSymbianOSErr(err);
    } 
    err=self->requestorStack->Append(req); 
    if(KErrNone!=err){
      delete req;
      return SPyErr_SetFromSymbianOSErr(err);
    }
  }
  
  err = self->positioner->SetRequestor(*(self->requestorStack));
  if(KErrNone!=err){
    return SPyErr_SetFromSymbianOSErr(err);
  }
    
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Return position infomation.
 */
extern "C" PyObject *
Positioner_position(Positioner_object *self, PyObject* args)
{ 
  TInt flags=0;
  PyObject* c;
  LONG_LONG tv;
  TInt partial=0;
  TInt err=KErrNone;
  if(!self->isSubSessionOpen){
    err=opensubsession(self);
    if(err!=KErrNone){
      return SPyErr_SetFromSymbianOSErr(err);
    }
    if(self->requestorStack){
      err=self->positioner->SetRequestor(*(self->requestorStack));
      if(err!=KErrNone){
        return SPyErr_SetFromSymbianOSErr(err);
      }
    }
  }
    
  if (!PyArg_ParseTuple(args, "|iOLi", &flags, &c, &tv, &partial)){ 
    return NULL;
  }

  TTimeIntervalMicroSeconds timeInterval = lltoTIMS(tv);

  if (c == Py_None)
    c = NULL;
  else if (!PyCallable_Check(c)) {
    PyErr_SetString(PyExc_TypeError, "callable expected");
    return NULL;
  }

  Py_XINCREF(c);
  
  self->myCallBack.iCb = c;
  self->callBackSet = ETrue;

  // ask for position updates
  TRequestStatus status; 
  
  Py_BEGIN_ALLOW_THREADS
  TRAP(err,{
    self->dataFetcher=CPosDataFetcher::NewL(*(self->positioner));
    self->dataFetcher->CreatePositionType(flags);
    self->dataFetcher->SetCallBack(self->myCallBack);
    self->dataFetcher->FetchData(status, timeInterval, partial);
  });
  Py_END_ALLOW_THREADS
  
  Py_INCREF(Py_None);
  return Py_None;            
}
/*
 *  Returns Last Position information
 */
extern "C" PyObject*
Positioner_last_position(Positioner_object* self, PyObject* /*args*/)
{
  TInt err=KErrNone;
  if(!self->isSubSessionOpen){
    err=opensubsession(self);
    if(err!=KErrNone){
      return SPyErr_SetFromSymbianOSErr(err);
    }
    if(self->requestorStack){
      err=self->positioner->SetRequestor(*(self->requestorStack));
      if(err!=KErrNone){
        return SPyErr_SetFromSymbianOSErr(err);
      }
    }
  }
  TRequestStatus status;
  TPositionInfo posInfo;
  self->positioner->GetLastKnownPosition(posInfo, status);
  User::WaitForRequest(status);
  if(status.Int()!=KErrNone)
    return SPyErr_SetFromSymbianOSErr(status.Int());
  TPosition position;
  posInfo.GetPosition(position);
  // convert TTime to TReal
  _LIT(KEpoch, "19700000:");
  TTime epochTime;
  epochTime.Set(KEpoch);
  TLocale locale;
  TReal time;
  #ifndef EKA2
    time=((position.Time().Int64().GetTReal()-(epochTime.Int64().GetTReal()))/(1000.0*1000.0))-
         TInt64(locale.UniversalTimeOffset().Int()).GetTReal();
  #else
    time=((TReal64(position.Time().Int64())-TReal64(epochTime.Int64()))/(1000.0*1000.0))-
         TInt64(TReal64(locale.UniversalTimeOffset().Int()));
  #endif

  return Py_BuildValue("{s:d,s:d,s:d,s:d,s:d,s:d}",
                       "latitude", position.Latitude(),
                       "longitude", position.Longitude(),
                       "altitude", position.Altitude(),
                       "vertical_accuracy", position.VerticalAccuracy(),
                       "horizontal_accuracy", position.HorizontalAccuracy(),
                       "time",time); 
}

/*
 * Stop position position infomation feed.
 */
extern "C" PyObject *
Positioner_stop_position(Positioner_object *self, PyObject* args)
{ 
  if (self->callBackSet){
    Py_BEGIN_ALLOW_THREADS
    self->dataFetcher->Cancel();
    Py_END_ALLOW_THREADS
  
    delete self->dataFetcher;
    self->dataFetcher = NULL;
  
    Py_XDECREF(self->myCallBack.iCb);
    self->callBackSet = EFalse;  
  }
  if (self->positioner){
    self->positioner->Close();
  }

  self->isSubSessionOpen = EFalse;
  
  Py_INCREF(Py_None);
  return Py_None;
}

/*
 * Deletes the requestors in the requestor stack and the stack itself.
 */
void deleteRequestorStack(Positioner_object *positioner)
{
  if(positioner->requestorStack){
    TInt count=positioner->requestorStack->Count();
    for(int i=0;i<count;i++){
       CRequestor* req = (*(positioner->requestorStack))[i];