Archivo

Archivo del autor

Replays Coderage XI

Viernes, 2 de diciembre de 2016 Sin comentarios
Share Button

Ya se han publicado los videos con los “replays” del CodeRage XI.

 

2e1ax_embarcadero_entry_CodeRage

Aquí tenéis el link de acceso a la lista de videos.

 

Y los videos uno por uno.

Bitmap Style Designer with Sarina DuPont – CodeRageXI

Developing user interface controls for both VCL and FMX with Bruno Fierens – CodeRage XI

Advantages of the Clang compilers with David Millington – CodeRageXI

Continuous integration with SVN, Jenkins and DUnit (Delphi) with Craig Chapman

Using Delphi containers like TList from C++ with David Millington – CodeRageXI

Effectively Using Radiant Shapes with Ray Konopka – CodeRageXI

C++ Standard Algorithms with David Millington – CodeRageXI

Using App Tethering to enable CodeSite for Tracing Mobile Apps with Bob Swart – CodeRage XI

Overview of New Windows 10 VCL Controls with Ray Konopka – CodeRageXI

Understanding FireDAC, The RAD Studio Data Access Framework of Choice with Cary Jensen – CodeRageXI

Artificial Intelligence with Delphi & C++Builder with Boian Mitov – CodeRageXI

Video, Audio, DSP, Computer Vision, and Animations with Mitov Software with Boian Mitov – CodeRageXI

Debug Faster. Debug Smarter; with Primoz Gabrijelcic – CodeRageXI

Working with Arduino with Mitov Software’s Visuino & Delphi – CodeRage XI Quick Idea

Arduino control via Delphi Mobile apps with Victory Fernandes – CodeRage XI

Arduino control via C++Builder Mobile apps with Victory Fernandes – CodeRage XI

Smart Pointers in C++: What, Why, and How with David Millington – CodeRage XI

Powerful GUIs using SVG and the RiverSoftAVG Component Library with Tom Grubb – CodeRage XI

Multi-device Applications Using Embedded InterBase ToGo (QuickTalk) with Al Mannarino – CodeRage XI

Debug logging in FireMonkey apps (C++) with Brian Long – CodeRage XI

Debug logging in FireMonkey apps (Delphi) with Brian Long – CodeRage XI

Share Button

CodeRage XI en Español, 7 y 8 de Diciembre

Lunes, 28 de noviembre de 2016 4 comentarios
Share Button

 

Header-CR

 

ACTUALIZACIÓN  09/12/2016: Ya están disponibles los “replays” de las conferencias, aquí:   http://embt.co/CRXIEspanolReplay

Esta conferencia en línea totalmente gratis se realizará el 7 y 8 de diciembre de 2016 y, como siempre, estará llena de sesiones donde se tratarán temas técnicos en profundidad para todos los niveles y todo sobre el desarrollo con RAD Studio.
Se está finalizando la selección de oradores de este año, ¡que incluirá también a los principales expertos de las comunidades hispanohablantes!

ACTUALIZACIÓN (01/12/2016)

Aquí está la agenda con los diferentes seminarios programados.

AGENDA
Fecha: 7 de Diciembre
9:00 México
10:00 Colombia
12:00 Argentina
16:00 España
Migración de aplicaciones a FireDAC Antonio Cabanillas
10:00 México
11:00 Colombia
13:00 Argentina
17:00 España
Aplicaciones distribuidas con REST Jose García
11:00 México
12:00 Colombia
14:00 Argentina
18:00 España
TBD TBD
12:00 México
13:00 Colombia
15:00 Argentina
19:00 España
Cómo modernizar su estilo de programación Jhonny Arley Suárez
Fecha: 8 de Diciembre
9:00 México
10:00 Colombia
12:00 Argentina
16:00 España
Delphi MVC Framework y FireDAC Emilio Pérez
10:00 México
11:00 Colombia
13:00 Argentina
17:00 España
Por qué usar C++Builder Luis Felipe Gonzalez Torres
11:00 México
12:00 Colombia
14:00 Argentina
18:00 España
Desarrollando Apps Móviles con Delphi y SQLite José Castillo Reyes
12:00 México
13:00 Colombia
15:00 Argentina
19:00 España
Creando un cliente de una API REST Fluida con la biblioteca cliente REST de Delphi Juan Antonio Castillo
Share Button

Delphi Boot Camp with 100% off Delphi (REPLAYS)

Lunes, 12 de septiembre de 2016 Sin comentarios
Share Button

Bueno, si no te has enterado, ya llegas tarde.  ;-D  (aunque tienes otra oportunidad).

La semana pasada del 5 al 9 de Septiembre se han realizado las 5 sesiones online gratuitas de 2 horas cada una, sobre la última versión de Delphi (15:00 y 20:00 hora española).

2e1ax_embarcadero_entry_DelphiBootCamp (1)

Desde la propia página del Boot Camp donde estaba toda la información, tienes ahora acceso al replay de todas las sesiones realizadas.

Delphi Boot Camp

También puedes acceder a ellas directamente desde Youtube.

Share Button
Categories: Código, Delphi, Embarcadero Tags:

Gratis, Delphi 10.1 Berlin Starter Edition

Martes, 23 de agosto de 2016 2 comentarios
Share Button

PROMOCIÓN ESPECIAL!!!

Como ya hizo en su día con la versión de C++ Builder, Embarcadero ofrece para descarga hasta el 9 de Septiembre del 2016, de forma gratuita de la versión Starter de Delphi 10.1 Berlin.

El acceso a la página de descarga es este.

 

Si queréis saber más sobre la versión Starter, aquí hay información.

Share Button
Categories: Delphi, Embarcadero Tags: ,

Actualizado el “Product Roadmap” (Agosto del 2016)

Jueves, 4 de agosto de 2016 Sin comentarios
Share Button

Como viene siendo habitual últimamente, Embarcadero ha actualizado el Roadmap de RAD Studio (normalmente lo hace cada 6 meses aproximadamente).

Aquí tenéis el acceso al documento completo.

En un primer vistazo podemos ver esto:

roadmap2016

Personalmente me llama la atención, y se que a muchos de vosotros también, porque lo hemos hablado en los foros, el bloque de “Linux Server”, que vendrá para la versión bautizada como Godzilla.

Antes de esa tendremos la actualización de Berlín, centrada bastante en los cambios de Microsoft y Windows 10.

Referente al soporte para Linux, se puede leer lo siguiente:

“The Linux version of RAD Server, with Apache integration, along with the ability to create Linux RAD Server API modules in Delphi and C++, some RAD Server Console UI enhancements and the Multi-Tenancy Capability”

A ver cómo se presenta esta nueva característica, que creo que abrirá nuevas puertas a RAD Studio, en un terreno que hasta ahora le estaba vetado.
Y que además viene a ofrecer la “pieza que falta”, en muchos desarrollos basados el REST que cada día se utilizan más.

Link al articulo completo.

Un saludo y hasta la próxima.

Share Button

Perfiles de audio

Miércoles, 20 de julio de 2016 Sin comentarios
Share Button

AudoioLevelsContinuando con la entrada anterior del blog, donde hablaba de cómo acceder a las propiedades de audio de un dispositivo Android; La idea de esta entrada es avanzar un poco más en el tema y generar una aplicación que nos permita gestionar varios perfiles de audio en nuestro dispositivo.

Una vez que vimos cómo acceder a la información del volumen actual, lo siguiente que nos interesa es poder almacenar diferentes perfiles, de forma que podamos seleccionar uno de los perfiles y configurar todos los parámetros de audio de forma rápida y automática.
Además debemos poder editar los perfiles existentes, borrar os que no nos interesen y tener la posibilidad de crear nuevos.

Contaremos con una serie de perfiles predefinidos, que podrían ser similares a estos:

  • Normal (Volúmenes al 100%)
  • Bajo (Volúmenes al 20%)
  • Sólo llamadas (todo al 0% excepto las llamadas)
  • Silencio total (Todo al 0%)

Leer más…

Share Button
Categories: Android, Delphi, Ejemplos Tags:

Gratis, C++Builder® 10.1 Berlin Starter Edition

Viernes, 17 de junio de 2016 Sin comentarios
Share Button

PROMOCIÓN ESPECIAL!!

Hoy (y no se si algunos días más) se puede descargar desde la web de embarcadero la versión Starter de C++ Builder 10.1 Berlín.

ClGAk_cXEAAcHbA

 

Enlace a la página.

Vídeo mostrando las características de esta versión.

Un saludo.

Share Button

Cuestión de volumen…

Martes, 14 de junio de 2016 3 comentarios
Share Button

volumen-audio-10054183Hace unos días se planteaba en el clubdelphi una cuestión acerca de la gestión de volúmenes en los dispositivos Android. Me llamó la atención porque días atrás me había planteado la cuestión de poder disponer de “perfiles de audio” en mi propio teléfono Android. Se trata de un Xiaomi con versión KitKat instalada y una ROM personalizada.

  • ¿Cómo podemos desde Delphi acceder a los volúmenes del dispositivo para las diferentes características (música, alarmas, llamadas,…)?
  • ¿Cómo podemos cambiarlos?

CONTROL DE VOLUMEN

Lo primero es saber cómo podemos acceder a esta información utilizando las clases de Android. Si revisamos la API de Android llegamos a la clase AudioManager,  que es la que se encarga de estos menesteres (y algunos más).
La descripción de la clase dice lo siguiente:

“AudioManager provides access to volume and ringer mode control.”

Leer más…

Share Button

NASA, la foto del día…

Viernes, 3 de junio de 2016 7 comentarios
Share Button

Hace bastante tiempo (cuando estábamos en la facultad) con mis amigos,  nos acostumbramos a visitar la web de  “la foto del día”. Había y sigue habiendo webs de muchas temáticas, pero una de las más conocidas en aquella época era la de la NASA. Las fotos de este tipo que hoy son más habituales, entonces era difícil encontrarlas (con aquella calidad).

ImagenDelDia

Actualmente la URL para acceder a “la foto del día” es esta.

http://apod.nasa.gov/apod/astropix.html

Hoy en día la NASA provee una API para poder acceder a través de un WebService a la fotos y otros datos asociados a la foto de cada día (título, descripción,…). Utilizando la API, el acceso a la foto del día se hace a partir de esta URL:

https://api.nasa.gov/planetary/apod

Para poder acceder a la información, necesitamos pasar una fecha válida, comprendida entre Junio de 1995 y la actualidad y nuestra KEY de desarrolladores.

Leer más…

Share Button

Procesos y Threads (GLibWMI)

Lunes, 14 de marzo de 2016 Sin comentarios
Share Button

threadA partir de esta consulta en el clubdelphi, sobre procesos y threads he decidido crear esta entrada; Para ello he compilado la librería GLibWMI en Delphi Seatle. La última versión que hay en la web está compilada y comprobada para Delphi XE7 y funciona sin problemas, así que era de esperar que en Seatle lo hiciera también sin cambios.

Yo mismo la estoy usando en algún proyecto antiguo en Delphi 6/7  y en algunas de las versiones más nuevas de Delphi XE.

Volviendo al tema que nos ocupa, en este caso nos interesa obtener información de los threads asociados a un determinado proceso que está corriendo en la máquina.

Para ello seguiremos los siguientes pasos:

  1. Acceder a la información del proceso
  2. Acceder a la información de los threads asociados a ese proceso.

Me voy a basar en la librería GLibWMI, aunque se puede hacer lo mismo utilizando código, sino deseamos instalar librerías de componentes adicionales.

Dentro de los componentes de GLibWMI, hay algunos que ya nos permiten acceder a clases “destacadas” o “habituales”. Entre ellos se encuentra ProcessInfo, por ejemplo, que nos da información  de los procesos ejecutandose (lo usaremos para el primer paso), pero WMI tiene muchas clases más.

Para acceder a cualquier otra clase o a datos particulares de una concreta, hay un componente llamado WMISQL, que nos permite lanzar “sentencias SQL” (algo parecido) sobre clases de WMI. Este componente es el que nos permitirá acceder a la información de los Threads (para los que no tenemos componente específico).

INFORMACIÓN DEL PROCESO

La información de los procesos funcionando en la máquina nos la da la clase Win32_Process.

Podemos utilizar el componente ProcessInfo. Basta con “soltar” el componente en un formulario y activarlo.

Este componente nos ofrece una lista de objetos TProcessProperties, la propiedad ObjectCount que nos da el número de elementos encontrados y la propiedad ObjectIndex que marca el elemento actual.

Podemos encontrar y obtener datos de un proceso con un código similar a este:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var
  str:string;
  i:integer;
  p:TProcessProperties; // para abreviar
begin
  // ini
  Memo1.Lines.Clear;
  // Activarlo
  ProcessInfo1.Active := True;
  // tenemos elementos?
  if (ProcessInfo1.ObjectsCount "MAYOR QUE" 0) then begin   //!!! Cambiar "MAYOR QUE" por el operador...
    // Buscamos un proceso concreto
    for i := 0 to (ProcessInfo1.ObjectsCount -1 ) do begin
      p := ProcessInfo1.ProcessProperties;
      // es el ibServer
      if (AnsiCompareText('ibserver.exe', p.Caption) = 0) then begin
        Memo1.Lines.Add('Nombre:        ' + p.Name);
        Memo1.Lines.Add('Caption:       ' + p.Caption);
        Memo1.Lines.Add('CommandLine:   ' + p.CommandLine);
        Memo1.Lines.Add('Path del EXE:  ' + p.ExecutablePath);
        Memo1.Lines.Add('Handle:        ' + p.Handle);
        Memo1.Lines.Add('Prioridad:     ' + IntToStr(p.Priority));
        Memo1.Lines.Add('Identificador: ' + IntToStr(p.ProcessId));
        Memo1.Lines.Add('Num. threads:  ' + IntToStr(p.ThreadCount));
 
        Break
      end;
      // Siguiente
      ProcessInfo1.ObjectIndex := ProcessInfo1.ObjectIndex + 1;
    end;
  end;
end;

 

Si lo ejecutamos obtendremos algo como esto:

En este caso, el componente ProcessInfo no es el más adecuado, ya que estamos obteniendo la información de TODOS los procesos, cuando sólo queremos acceder a uno sólo (ibserver, en el ejemplo anterior).

Para este caso, es más conveniente utilizar el componente WMISQL. Ya que podemos “minimizar” el tráfico de datos que solicitamos.

Para ello, este componente posee la propiedad SQL.

Aquí vemos las propiedades de este componente:

Añadiremos esta sentencia:

0
SELECT * FROM Win32_Process WHERE name = "ibserver.exe"

Si tan sólo queremos algunos datos, podemos afinar más la consulta para dejarla así:

0
1
SELECT Caption, CommandLine, ExecutablePath, Name, Handle, Handlecount, 
Priority, ProcessId, ThreadCount FROM Win32_Process WHERE name = "ibserver.exe"

 

Una vez activamos el componente, podemos acceder al resultado de la siguiente manera (vemos 2 opciones diferentes utilizando un TMemo -con la respuesta tal cual la da WMI- y un ValueListEditor -cuadro inferior-).

0
1
2
3
4
5
6
7
8
9
10
   // ini
  Memo1.Lines.Clear;
  // Activar
  WMISQL1.Active := True;
  // tenemos elementos?
  if (WMISQL1.ObjectsCount > 0) then begin
    // respuesta de WMI
    Memo1.Lines.Text := WMISQL1.AllProperties.Text;
    // Lista de propiedades
    ValueListEditor1.Strings.AddStrings(WMISQL1.Properties);
  end;

Como resultado obtendremos algo como esto:

Vemos que la propiedad ThreadCount nos devuelve 5.

 

INFORMACIÓN DE THREADS

Volviendo al tema original, una vez tenemos el identificador de nuestro proceso (en este caso el ProcessID=5848), necesitamos obtener los threads de este proceso y los datos asociados.

Para ver más información, podéis acceder a este link donde están todas las propiedades accesibles, la explicación de cada una de ellas y los diferentes valores que adoptan.

Vamos a utilizar en este caso otro componente WMISQL (o reaprovechar el mismo) y cambiaremos la consulta por esta otra:

0
SELECT * FROM Win32_Thread WHERE ProcessHandle=5848

 

Si activamos el componente en diseño (que se puede hacer) ya podemos ver que la propiedad ObjectCount es 5, por lo tanto ibserver tiene en este momento, 5 threads en marcha que dependen de él.

Con el siguiente código podemos obtener información de cada uno de ellos:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var
  i, j:integer;
  str:string;
  h, m, s:int64;
  p:TStrings;  // para abreviar
begin
  // ini
  Memo1.Lines.Clear;
  ValueListEditor1.Strings.Clear;
  // Activar
  WMISQL1.Active := True;
  // tenemos elementos?
  if (WMISQL1.ObjectsCount > 0) then begin
    // recorrer los threads y obtener datos
    for i := 0 to (WMISQL1.ObjectsCount - 1) do begin
      p := WMISQL1.Properties;
      j := StrToIntDef(p.Values['ElapsedTime'], 0); // milisegundos
      if (j > 0) then begin
      h := (j DIV 3600000);                        // horas
      m := (j - (h * 3600000)) DIV 60000;          // minutos
      s := (j MOD 60000) DIV 1000;                 // segundos
        Memo1.Lines.Add(Format('Tiempo ejec.:   %d:%d:%d', [h, m, s]));
      end;
      Memo1.Lines.Add('Handle:         ' + p.Values['Handle']);
      Memo1.Lines.Add('Prioridad:      ' + p.Values['Priority']);
      Memo1.Lines.Add('Prioridad base: ' + p.Values['PriorityBase']);
      Memo1.Lines.Add('Id. proceso:    ' + p.Values['ProcessHandle']);
      Memo1.Lines.Add('Estado:         ' + p.Values['ThreadState']);
      Memo1.Lines.Add('··········································');
    end;
  end;
end;

 

El resultado al mostrarlo por pantalla será algo similar a esto:

Con esto ya hemos acabado. La idea es mostrar la potencia de WMI y la sencillez con la que podemos utilizar esa información accediendo desde Delphi. Como os he dicho, podéis acceder a WMI sin necesidad de componentes, utilizando código delphi.

En entradas anteriores hemos comentado cómo hacerlo.

Un saludo y hasta la próxima.

Share Button
Categories: Delphi, Ejemplos, GLibWMI, WMI Tags: , ,