Пример #1
0
char* BitmapHandler::loadBmpURL(const std::string &name, int &width, int &height, int mode, bool useCache)
{
   	char *data=NULL;

	AmigoRest restClient(amigoCoreAgent.c_str());
	restClient.enableCacheWrite(useCache);
	RestClient::response response = restClient.get(name);
	if (!response.isBad())
	{
		data = decompressImage((char*)response.body.c_str(), response.body.size(), width, height, mode);
	} else
	{
		if(useCache)
		{
			restClient.enableCacheRead(true);
			response = restClient.get(name);
			if (!response.isBad())
			{
				data = decompressImage((char*)response.body.c_str(), response.body.size(), width, height, mode);
				return data;
			}
		}
		AMIGO_LOG_I(TAG, "::loadBmpURL() FILED to load '%s'\n", name.c_str());
	}
	return data;
}
Пример #2
0
bool BitmapHandler::loadBmpURL(const std::string &name, std::string &data, bool useCache)
{
	AmigoRest restClient(amigoCoreAgent.c_str());
	restClient.enableCacheWrite(useCache);
	RestClient::response response = restClient.get(name);
	if (!response.isBad())
	{
		data.reserve(response.body.size());
		data.insert(0, response.body.c_str(), response.body.size());
	} else
	{
		if(useCache)
		{
			restClient.enableCacheRead(true);
			response = restClient.get(name);
			if (!response.isBad())
			{
				data.reserve(response.body.size());
				data.insert(0, response.body.c_str(), response.body.size());
				return true;
			}
		}
		AMIGO_LOG_I(TAG, "::loadBmpURL() FILED to load '%s'\n", name.c_str());
		return false;
	}
	return true;
}
Пример #3
0
bool Reprojector::_load_JSON_FromURL(const std::string &url, std::string &result)
{

	AmigoRest restClient(_userAgent.c_str());
	RestClient::response response = restClient.get(url);
	if (!response.isBad())
	{
		_escapeQuotes(response.body, result);
       return true;
	}
    return false;
}
Пример #4
0
QTM_USE_NAMESPACE

Q_DECL_EXPORT int main(int argc, char *argv[])
{
    QCoreApplication::setOrganizationName("Synchroma");
    QCoreApplication::setOrganizationDomain("synchroma.com.au");
    QCoreApplication::setApplicationName("Arca");

    QScopedPointer<QApplication> app(createApplication(argc, argv));
    QmlApplicationViewer viewer;

    QDeclarativeEngine *engine = viewer.engine();
    QDeclarativeContext *context = engine->rootContext();

    DBSession session;
    session.setConsumerKey(DROPBOX_APP_KEY);
    session.setConsumerSecret(DROPBOX_APP_SECRET);

    // Have the REST client visible in the QML
    DBRestClient restClient(session);
    context->setContextProperty("restClient", &restClient);

    // TESTING
    context->setContextProperty("param", QString(argv[1]));

    // TESTING
    qDebug() << "temp dir: " << QDir::tempPath();
    qDebug() << "home dir: " << QDir::homePath();
    qDebug() << "current dir: " << QDir::currentPath();

    QServiceManager serviceManager(QService::SystemScope);
    QStringList stringList = serviceManager.findServices();
    foreach (QString interfaceName, stringList)
        qDebug() << "service interface: " << interfaceName;

    QList<QServiceInterfaceDescriptor> descriptors = serviceManager.findInterfaces();
    for (int i=0; i<descriptors.count(); i++)
    {
        QString service = descriptors[i].serviceName();

        if (descriptors[i].scope() == QService::SystemScope)
            service += " (system)";

        qDebug() << "service: " << service;
    }

    viewer.setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
    viewer.setMainQmlFile(QLatin1String("qml/arca/main.qml"));
    viewer.showExpanded();

    return app->exec();
}
bool PublicIpLookup::lookupIpAddress( String& ipAddress ) {

  WiFiRestClient restClient( "api.ipify.org" );

  int statusCode = restClient.get( "/?format=text", &ipAddress );
  if( statusCode == 200 ) {

    ipAddress.trim();
    return true;

  } else {

    ipAddress = "";
    return false;
  }
}
Пример #6
0
char* load_JPEG_FromURL (const char *url, int *width, int *height, bool useCache )
{

//	AmigoCloud::CurlHandler ch;
//	if( !ch.doRequest(url) )
//	 return 0;

	AmigoRest restClient(imageUtilsUserAgent.c_str(), useCache);
	//restClient.setIgnoreSSLCertificate(true); // because of certficate problems.
	RestClient::response response = restClient.get(url);
    if (response.isBad())
    	return 0;

  /* This struct contains the JPEG decompression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_decompress_struct cinfo;
  /* We use our private extension JPEG error handler.
   * Note that this struct must live as long as the main JPEG parameter
   * struct, to avoid dangling-pointer problems.
   */
  struct my_error_mgr jerr;
  /* More stuff */
//  FILE * infile;		/* source file */
  JSAMPARRAY buffer;		/* Output row buffer */
  int row_stride;		/* physical row width in output buffer */

  /* In this example we want to open the input file before doing anything else,
   * so that the setjmp() error recovery below can assume the file is open.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to read binary files.
   */

//  if ((infile = fopen(filename, "rb")) == NULL) {
//    fprintf(stderr, "can't open %s\n", filename);
//    return 0;
//  }

  /* Step 1: allocate and initialize JPEG decompression object */

  /* We set up the normal JPEG error routines, then override error_exit. */
  cinfo.err = jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = my_error_exit;
  /* Establish the setjmp return context for my_error_exit to use. */
  if (setjmp(jerr.setjmp_buffer)) {
    /* If we get here, the JPEG code has signaled an error.
     * We need to clean up the JPEG object, close the input file, and return.
     */
    jpeg_destroy_decompress(&cinfo);
//    fclose(infile);
    return NULL;
  }
  /* Now we can initialize the JPEG decompression object. */
  jpeg_create_decompress(&cinfo);

  /* Step 2: specify data source (eg, a file) */

  FILE * infile = fmemopen((void*)response.body.c_str(), response.body.size(), "rb");
  if (infile == NULL)
  {
      AMIGO_LOG_E(TAG, "Calling fmemopen() has failed.\n");
//      exit(1);
      return NULL;
  }

  jpeg_stdio_src(&cinfo, infile);

  /* Step 3: read file parameters with jpeg_read_header() */

  (void) jpeg_read_header(&cinfo, TRUE);
  /* We can ignore the return value from jpeg_read_header since
   *   (a) suspension is not possible with the stdio data source, and
   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
   * See libjpeg.doc for more info.
   */

  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  /* Step 5: Start decompressor */

  (void) jpeg_start_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* We may need to do some setup of our own at this point before reading
   * the data.  After jpeg_start_decompress() we have the correct scaled
   * output image dimensions available, as well as the output colormap
   * if we asked for color quantization.
   * In this example, we need to make an output work buffer of the right size.
   */

   *width = cinfo.output_width;
   *height = cinfo.output_height;
   int numcomp = 4;//cinfo.num_components;

   row_stride = cinfo.output_width * numcomp;//cinfo.output_components;

   char *buff = new char[ *width * *height * numcomp ];

//   printf("load_JPEG_FromURL() %dx%d, %d, buff=%p\n", *width, *height, numcomp, buff);

  /* JSAMPLEs per row in output buffer */

//  char *buffS = new char[ row_stride ];

  /* Step 6: while (scan lines remain to be read) */
  /*           jpeg_read_scanlines(...); */

  /* Here we use the library's state variable cinfo.output_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   */

  /* Make a one-row-high sample array that will go away when done with image */
  buffer = (*cinfo.mem->alloc_sarray)
				((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);

  while (cinfo.output_scanline < cinfo.output_height) {
	  /* jpeg_read_scanlines expects an array of pointers to scanlines.
	   * Here the array is only one element long, but you could ask for
	   * more than one scanline at a time if that's more convenient.
	   */
	  (void) jpeg_read_scanlines(&cinfo, buffer, 1);
	  /* Assume put_scanline_someplace wants a pointer and sample count. */

	  int index = (cinfo.output_scanline-1) * row_stride;
	  // Convert RGB to RGBA
	  int cb=0;
	  char *bb = (char*)buffer[0];
	  for(int i=0; i<row_stride; i+=4 )
	  {

		  buff[index + i]   = bb[cb]; cb++;
		  buff[index + i+1] = bb[cb]; cb++;
		  buff[index + i+2] = bb[cb]; cb++;
		  buff[index + i+3] = 255;
	  }
//	  memcpy((void*)&buff[(cinfo.output_scanline-1) * row_stride], buffS, row_stride);
  }

//  delete [] buffS;
  /* Step 7: Finish decompression */

  (void) jpeg_finish_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* Step 8: Release JPEG decompression object */

  /* This is an important step since it will release a good deal of memory. */
  jpeg_destroy_decompress(&cinfo);

  /* After finish_decompress, we can close the input file.
   * Here we postpone it until after no more JPEG errors are possible,
   * so as to simplify the setjmp error logic above.  (Actually, I don't
   * think that jpeg_destroy can do an error exit, but why assume anything...)
   */
  fclose(infile);

  /* At this point you may want to check to see whether any corrupt-data
   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
   */
//  printf("load_JPEG_FromURL() done.\n");

  /* And we're done! */
  return buff;
}