Etiquetado: WP7

Async CTP y Windows Phone 7.5

Tal como os comentaba en mi artículo sobre Async y Windows Phone, la Async CTP de abril no funcionaba con el SDK de Windows Phone 7.1, así que nos quedamos con las ganas de poder utilizar esta potente librería en nuestro dispositivo favorito.

Bien, pues durante el tiempo que he estado sin actualizar mi blog han ocurrido muchas cosas, entre ellas: en Noviembre apareció la v3 de la Async CTP, que ya tiene soporte para Silverlight 5 y Windows Phone 7.5.  Tenéis más detalles en el post de Stephen Toub.

Si queréis probar Async en todo su esplendor, os recomiendo descargar Windows 8 Developer Preview con las herramientas, incluye una versión “preview” de Visual Studio 11 con el Framework 4.5 que lleva Async de serie y los métodos asíncronos son una parte muy importante del desarrollo de aplicaciones Metro en Windows 8.

Feliz Año 7DC

 

Anuncios

Tema personalizado en Windows Phone Mango

Vintage Phone Embroidery Hoop ArtEn la versión anterior de Windows Phone 7 crear un tema personalizado para nuestra aplicación era bastante sencillo. Bastaba con copiar el fichero ThemeResource.xaml que se encontraba en la carpeta en %programfiles%\Microsoft SDKs\Windows Phone\v7.0\Design y luego hacíamos un Merge de los diccionarios de recursos.

Según Peter Torr esto se podía hacer debido a un “bug” de Silverlight 3 que en el 4 está solucionado. Fuera o no un bug era bastante útil; en Mango usamos Silveright 4 así que tendremos que trabajar un poco más, pero aún podremos hacerlo. La recomendación de Peter Torr es usar estilos implícitos o bien actualizar los estilos del tema. En Windows Phone Geek han encontrado una manera de utilizar el ThemeResource.xaml, pero se han dejado algún paso, o no han probado a poner el tema del dispositivo/emulador en modo claro (light), así que os voy a contar cómo lo hago yo.

Vamos a combinar las dos técnicas y lo explicado en Windows Phone Geek para ahorrarnos el tedioso trabajo de crear todos los estilos de todos los controles de nuevo.

Creación y aplicación de tema personalizado

1. Copiaremos el fichero ThemeResource.xaml, que ahora lo encontramos en %programfiles%\Microsoft SDKs\Windows Phone\v7.1\Design, a una carpeta de nuestra solución, por ejemplo Themes:

2. Una vez copiado, cambiaremos su BuildAction a Resource para que la carga sea más rápida:

3. Editamos los colores del ThemeResource.xaml que hemos copiado a nuestra solución; podemos, por ejemplo, cambiar el color del Accent a un rojo claro:

<Color x:Key="PhoneAccentColor">#FFFF2828</Color>

4. Ahora, en el App.Xaml.cs creamos un método que nos permita copiar los valores del diccionario de recursos sobre los valores por defecto, tal como proponen en Windows Phone Geek:

private void MergeCustomColors()
{
    var dictionaries = new ResourceDictionary();
    string source = string.Format("/{0};component/Themes/ThemeResources.xaml",
        new System.Reflection.AssemblyName(
        this.GetType().Assembly.FullName).Name);
    var themeStyles = new ResourceDictionary { Source = new Uri(source, UriKind.Relative) };
    dictionaries.MergedDictionaries.Add(themeStyles);

    ResourceDictionary appResources = App.Current.Resources;
    foreach (DictionaryEntry entry in dictionaries.MergedDictionaries[0])
    {
        SolidColorBrush colorBrush = entry.Value as SolidColorBrush;
        SolidColorBrush existingBrush = appResources[entry.Key] as SolidColorBrush;
        if (existingBrush != null && colorBrush != null)
        {
            existingBrush.Color = colorBrush.Color;
        }
    }
}

5. Desde el constructor de App llamamos al método para que se efectúe la copia lo antes posible:

public App()
{
    // Global handler for uncaught exceptions.
    UnhandledException += Application_UnhandledException;

    // Standard Silverlight initialization
    InitializeComponent();

    // Phone-specific initialization
    InitializePhoneApplication();

    //Carga del esquema de colores:
    MergeCustomColors();
...

Si os habéis fijado en el método MergeCustomColors habréis visto que lo único que hacemos es ir actualizando los colores de todos los elementos Brush. El diccionario de recursos es read-only, así que no podemos reasignar los valores, sólo podemos cambiar propiedades de esos valores y en el caso de Color no es posible.
Esto tiene un problema y es que el LayoutRoot tiene el color predefinido a Transparent y toma el color de fondo del ApplicationFrame, que en lugar de utilizar un Brush utiliza directamente un Color.

Si ejecutamos nuestra aplicación en modo claro no veremos casi nada:

6. Para resolver el problema del fondo no nos quedará más remedio que cambiar el color de fondo para toda la aplicación. Podríamos ir pantalla por pantalla y cambiar el color de fondo de cada LayoutRoot a negro, pero no nos hará falta. Gracias a los estilos implícitos nos bastará con cambiar el color en el App.Xaml para el PhoneApplicationFrame:

<!--Application Resources-->
<Application.Resources>
    <Style TargetType="phone:PhoneApplicationFrame">
        <Setter Property="Background" Value="Black"/>
    </Style>
</Application.Resources>

Así conseguiremos ver todo el contenido correctamente.

Últimos retoques

Ahora que ya vemos correctamente nuestra aplicación en los colores que nosotros deseamos podemos dar un poco más de coherencia al tema si cambiamos también el color del ApplicationBar. Como no es un control no podremos controlar su aspecto con los estilos implícitos (o por lo menos yo no he sabido), así que o bien usamos una barra para toda la aplicación en el Application.Resources o tendremos que cambiar los colores en cada página donde tengamos una barra:

    <phone:PhoneApplicationPage.ApplicationBar>
        <shell:ApplicationBar IsVisible="True" IsMenuEnabled="True" 
               BackgroundColor="Black" ForegroundColor="White">
        ...

También se puede esconder la barra de sistema, pues en modo claro aparecerá también de color blanco, aunque no es recomendable pues a muchos usuarios les gusta saber qué hora es mientras usan la aplicación.
Para esconderla hay que editar también cada página y cambiar el valor shell:SystemTray.IsVisible a False.

Para probar con las nuevas maneras de cambiar los estilos es necesario utilizar el SDK7.1 de Windows Phone

Espero que os sirva de utilidad y si encontráis una forma mejor de hacerlo ¡compartid! 😀

Usar el micrófono de Windows Phone 7 desde Silverlight

Descarga el código de ejemplo aquí: WindowsPhoneMicrophoneSL.zip.
(Nueva versión corregida)

microphone
Hace unos meses escribí un artículo sobre cómo grabar un WAV con el micrófono del Windows Phone 7. En él explicaba cómo utilizar las clases de XNA desde Silverlight para poder leer la señal del micrófono y algún truco necesario para crear el archivo WAV.

Como sabréis ya ha salido la nueva versión Windows Phone 7.5 (AKA Mango) junto con el nuevo SDK 7.1.
Ahora ya podemos grabar la señal del micrófono desde Silverlight sin necesidad de usar XNA. Ya tenemos acceso a las clases de Silverlight 4, así podremos utilizar un AudioSink para poder grabar audio.

Para que funcione el micrófono en Silverlight necesitaremos habilitar el tag <Capability Name=“ID_CAP_CAMERA” />. He añadido una solicitud en UserVoice para que en próximas versiones no sea necesario y baste con el tag ID_CAP_MICROPHONE.

El código

La diferencia con el artículo anterior está en la clase MicrophoneWavRecorder, que ahora hereda de la clase AudioSink:

public sealed class MicrophoneWavRecorder : AudioSink
{
    private AudioFormat _format;
...

En el constructor solicitaremos acceso al dispositivo de captura y seleccionaremos el formato que más nos convenga utilizar, en nuestro caso 16 bits y algo mejor que 11Khz

Edit: por ahora no podemos seleccionar el formato, pidamos lo que pidamos el micrófono seguirá capturando a 16 bits Mono 16Khz, así que mejor no indicamos nada en ese punto.

public MicrophoneWavRecorder()
{
    if (!CaptureDeviceConfiguration.AllowedDeviceAccess)
        CaptureDeviceConfiguration.RequestDeviceAccess();

    AudioCaptureDevice device =
        CaptureDeviceConfiguration.GetDefaultAudioCaptureDevice();
    if (device == null)
    {
        throw new Exception("Can't get capture device!");
    }

    //Por ahora no podemos seleccionar el formato, esperemos que más adelante si...
//    _format = (from af in device.SupportedFormats
//              where af.BitsPerSample == 16 && af.SamplesPerSecond > 11025
//              select af).First();

//    device.DesiredFormat = _format;
//    device.AudioFrameSize = 100;

    this.CaptureSource = new CaptureSource();
    this.CaptureSource.AudioCaptureDevice = device;
}

Como no hemos podido asignar el formato de audio preferido tendremos que esperar que el dispositivo nos indique qué formato ha elegido él, para esto tenemos el método OnFormatChange con el que podremos capturar la información:

protected override void OnFormatChange(AudioFormat audioFormat)
{
    //capturamos el formato
    //en windows phone 7.1 es: mono 16 bit 16000 Hz
    _format = audioFormat;
}

Ahora ya sólo nos queda capturar el audio cada vez que se llena el buffer:

protected override void OnSamples(long sampleTime,
    long sampleDuration, byte[] sampleData)
{
    _bwOutput.Write(sampleData, 0, sampleData.Length);
    _rawDataLength += sampleData.Length;
}

Una de las ventajas que tenemos usando la clase AudioSink es que tenemos acceso al formato real y ya no tenemos que escribir los datos de la cabecera con valores fijos como hacíamos en el ejemplo anterior en el método WriteHeader, tendremos que ir con cuidado pues el formato de audio no lo sabemos en la primera escritura, pero lo tendremos cuando cerremos el audio:

if (_format != null)
{
    // Channel Numbers (Always 0x01=Mono, 0x02=Stereo)
    _bwOutput.Write((ushort)_format.Channels);

    // Sample Rate (Binary, in Hz)
    _bwOutput.Write((uint)this._format.SamplesPerSecond);

    // Bytes Per Second
    _bwOutput.Write((uint)(_format.BitsPerSample *
        _format.SamplesPerSecond * _format.Channels / 8));

    // Bytes Per Sample: 1=8 bit Mono,
    // 2=8 bit Stereo or 16 bit Mono, 4=16 bit Stereo
    _bwOutput.Write((ushort)(_format.BitsPerSample
        * _format.Channels / 8));

    // Bits Per Sample
    _bwOutput.Write((ushort)_format.BitsPerSample);
}

¿Qué voy a necesitar?

  1. Un dispositivo: aquí no os puedo ayudar mucho, en el emulador no funciona el micrófono, aunque podéis poner otra solicitud en UserVoice.
  2. El SDK 7.1 que puedes encontrar en 9 idiomas, incluido el castellano: Windows Phone SDK 7.1
  3. Descarga el código completo de ejemplo aquí: WindowsPhoneMicrophoneSL.zip

El Marketplace de Windows Phone ahora en la Web


Nos habían prometido grandes cambios y por fin han llegado.
Ahora podemos navegar por el Marketplace de Windows Phone desde cualquier explorador, ya no es necesario tener un Windows Phone a mano, ni el Zune instalado. Así podremos enviar enlaces de nuestras aplicaciones a todos.
Tenemos las mismas funcionalidades del Marketplace en el Zune, vamos a poder buscar, seleccionar, ver e incluso comprar las aplicaciones que se enviarán directamente al teléfono.

 

 

Desde la pantalla principal podemos seleccionar una aplicación, buscar por tipo o por nombre:

Seleccionarla y ver la descripción, opiniones, capturas de pantalla, etc…

Para acceder el Marketplace en la web aquí tenéis la dirección, no podía ser más fácil: http://www.windowsphone.com/marketplace

Ya podéis dar envidia a todos los que no tienen WP7 aunque estén muy lejos 😀

Noticias MSDN actualizada a Mango

Mango

He actualizado recientemente la aplicación de demostración que uso en mis tutoriales de WP7 para aprovechar unas pocas de las más de 500 novedades que trae Mango. Dentro de poco estará disponible en el Marketplace, aquí os adelanto los cambios que he hecho por ahora.

 

Actualización a 7.1

Lo primero que debemos hacer es actualizar el proyecto al nuevo SDK. Basta pulsar con el botón derecho sobre el proyecto y obtendremos la opción que necesitamos:

Una vez realizada la actualización ya podemos realizar los cambios necesarios en nuestra aplicación.

¿Adormecida o Deshidratada?

El nuevo modelo de ejecución de WP7.5 contempla una nueva posibilidad al volver a nuestra aplicación, puede que la aplicación no vuelva “deshidratada” (tombstoning) sino en un estado latente aún en memoria, por lo tanto no hará falta recuperar los datos desde el PhoneApplicationService.Current.State y podremos continuar la ejecución como si nada hubiera pasado.
Execution Model Diagram for Windows Phone 7.5

Para saber si la aplicación se debe recuperar o no basta con mirar la propiedad IsApplicationInstancePreserved del evento de activación. En el caso de la aplicación de ejemplo no hace falta mirar esta propiedad, pues ya mirábamos si el ViewModel era válido o no.

Compartir

Incluir funcionalidad para las redes sociales se complica un poco si lo queremos hacer usando las API de cada red, pues debemos pedir permiso, abrirnos una cuenta de desarrollador y gestionar la comunicación (login, datos, etc…) con la interfaz de cada red. Como ya os conté en un post anterior, Mango incorpora una novedad que nos facilitará mucho la vida: la tarea ShareLinkTask, con la que podremos en un par de líneas compartir cualquier información en todas las redes que tenga el usuario configuradas en el teléfono, en nuestro código se ve así:

new ShareLinkTask()
{
    LinkUri = new Uri( rss.Link),
    Message = HtmlStripper.HtmlToPlainText(rss.Description),
    Title = rss.Title
}.Show();

Texto rico rico

En la página principal tenemos un apartado “Acerca de…” que indica algunos datos sobre la aplicación. Para mostrar el texto, en la versión anterior estaba escrita dentro de etiquetas TextBlock en un StackPanel, en el que se iban colocando uno sobre el otro los bloques de texto.

Ahora tenemos una mejor opción para presentar texto, el control RichTextBox que nos permitirá formatear, añadir imágenes y representar hiperenlaces dentro del texto:

<controls:PanoramaItem Header="Acerca de..." >
    <StackPanel>
        <RichTextBox IsReadOnly="True" Background="Transparent">
            <Paragraph TextAlignment="Justify">Esta es una aplicación no oficial para la
            </Paragraph>
            <Paragraph TextAlignment="Center">
            <Hyperlink NavigateUri="http://msdn.microsoft.com/es-ES/" 
                       TargetName="_blank">http://msdn.microsoft.com/es-ES/
            </Hyperlink>
            </Paragraph>
            <Paragraph TextAlignment="Justify">Los datos mostrados en la aplicación son 
            </Paragraph>
            <Paragraph></Paragraph>
            <Paragraph TextAlignment="Justify">Desarrollada por
                    Juan Manuel Servera
                 en Marzo de 2011 como ejemplo del tutorial de aplicaciones de WP7.
            </Paragraph>
            <Paragraph TextAlignment="Center">
                <Hyperlink NavigateUri="https://jmservera.wordpress.com"
                           TargetName="_blank">https://jmservera.wordpress.com
                </Hyperlink>
            </Paragraph>
        </RichTextBox>
    </StackPanel>
</controls:PanoramaItem>

Para que los hiperenlaces funcionen es importante que el control esté en modo lectura (IsReadOnly=”True”) y que los enlaces tengan un TargetName (“_blank” en nuestro caso).

Podéis descargar el código fuente completo de la aplicación en Codeplex.

Las redes sociales y nuestras aplicaciones de Windows Phone 7.1

social media
Hasta ahora, añadir recursos de redes sociales en nuestras aplicaciones era algo tedioso, no sólo para nosotros, sino también para los usuarios.

Por nuestra parte teníamos que o bien programar un conector para cada red social, con la consecuencia de que además debíamos crear un sistema para guardar las credenciales usadas, solicitar una clave para la api de cada red social (facebook, twitter, etc), o bien hacer una “chapucilla” usando una URL que nos redirigiera a la red social usando una WebBrowserTask. Las soluciones de terceros no nos solucionan demasiado la vida.

Del lado del usuario también se complicaba bastante, pues la primera solución implicaba la introducción los datos de su cuenta en cada aplicación, complicando en exceso el mantenimiento en múltiples aplicaciones. La segunda solución es aún peor pues cada vez que se quiere compartir algo se salta a un navegador donde hay que introducir las credenciales.

Afortunadamente, la filosofía de hubs de Windows Phone 7 va a simplificar muchísimo esta tarea tan natural en el ser humano de compartir lo que sea que estemos haciendo. Como dicen en los anuncios de WP7: la gente tiene amigos, no aplicaciones.

¿Cómo se soluciona esto? Pues integrando las redes sociales en el sistema operativo del móvil. Gracias a esto y a una nueva Task que incluye el teléfono, compartir cualquier cosa desde nuestra aplicación de WP7 va a ser tan complicado como llamar a la ShareLinkask:

new Microsoft.Phone.Tasks.ShareLinkTask()
{
Title="Comparto link!",
Message="Aquí tenéis mi link compartido...",
LinkUri=new Uri("https://jmservera.wordpress.com")
}.Show();

Y si sólo es un mensaje es aún más fácil, basta con la ShareStatusTask:

new Microsoft.Phone.Tasks.ShareStatusTask(){
Status="Estoy compartiendo!"}.Show();

Pasadlo bien… y compartid! 😀

Grabar un WAV con el micrófono en Windows Phone 7

Descarga el código de ejemplo aquí: WindowsPhoneMicrophone.zip.

Desde la primera versión de WP7 tenemos acceso al micrófono a través del framework XNA. En algunas ocasiones nos bastará con poder leer el canal de audio, pero en otras muchas vamos a querer guardar el audio a disco e incluso enviarlo a un servicio web. Esto que parece tan natural representa un verdadero problema pues:

  • Estamos forzados a simular el ciclo de XNA  en nuestras aplicaciones Silverlight
  • El stream de audio nos da un PCM crudo y tenemos que añadir nosotros mismos las cabeceras para crear un WAV
  • No podemos crear fácilmente otros formatos más convenientes (wma, mp3, etc…)
Hoy vamos a ver cómo resolver los dos primeros. El primer punto es el más sencillo pues tenemos múltiples ejemplos de cómo llamar al dispatcher de XNA para hacerle creer al sistema que estamos dentro del ciclo. En Mango tenemos una nueva forma de integrar XNA y Silverlight con la clase GameTimer, pero para este caso no necesitamos una integración completa, así que seguiremos usando el sistema “antiguo” con un DispatcherTimer:
DispatcherTimer dt = new DispatcherTimer();
dt.Interval = TimeSpan.FromMilliseconds(33);
dt.Tick += delegate { try { FrameworkDispatcher.Update(); } catch { } };
Una vez instanciado el micrófono podremos empezar a guardar audio en un stream cualquiera. Para ello tendremos que reservar un buffer donde el micrófono irá guardando el audio y nos avisará cuando esté lleno para que lo podamos volcar al stream.
Microphone _microphone = Microphone.Default;
_microphone.BufferReady += 
   new EventHandler<EventArgs>(microphone_BufferReady);

_microphone.BufferDuration =
   TimeSpan.FromMilliseconds(500);

byte[] _buffer =
   new byte[_microphone.GetSampleSizeInBytes(_microphone.BufferDuration)];

_microphone.Start();
Así, en el evento BufferReady podremos ir guardando los datos a nuestro stream.
void microphone_BufferReady(object sender, EventArgs e)
{
    // Retrieve audio data
    int length = _microphone.GetData(_buffer);

    // Store the audio data in a stream
    _bwOutput.Write(_buffer, 0, length);
    _rawDataLength += (uint)length;
}
Si se nos ocurre guardar esos datos directamente a un fichero, usando la clase SoundEffect podremos volver a escuchar ese audio, pero, ¿Qué pasa si queremos enviar nuestro audio a un servicio? El audio que hemos guardado está en formato PCM en crudo y un programa de reproducción de sonido no sabrá cómo interpretarlo, pues le hace falta información de cómo es ese audio: bitrate, número de canales, etc…
Una solución muy rápida es crear una cabecera al PCM para darle formato WAV, hay ejemplos por la red, pero son genéricos y tenemos el problema de que no tenemos acceso a la clase AudioFormat, aunque en 7.1 está escondida dentro de la clase del micrófono. Por ahora tendremos que poner algunos datos a mano en la cabecera:
He utilizado uno de los ejemplos que hay para Silverlight y he modificado los valores para que coincidan con los del micrófono del WP7:
public void WriteHeader()
{
    // Write down the WAV header.
    // Refer to http://technology.niagarac.on.ca/courses/ctec1631/WavFileFormat.html
    // for details on the format.

    // Note that we use ToCharArray() when writing fixed strings
    // to force using the char[] overload because
    // Write(string) writes the string prefixed by its length.

    // -- RIFF chunk
    _bwOutput.Write("RIFF".ToCharArray());

    // Total Length Of Package To Follow
    // Computed as data length plus the header length without the data
    // we have written so far and this data (44 - 4 ("RIFF") - 4 (this data))
    _bwOutput.Write((uint)(_rawDataLength + 36));

    _bwOutput.Write("WAVE".ToCharArray());

    // -- FORMAT chunk

    _bwOutput.Write("fmt ".ToCharArray());

    // Length Of FORMAT Chunk (Binary, always 0x10)
    _bwOutput.Write((uint)0x10);

    // Always 0x01
    _bwOutput.Write((ushort)0x01);

    // Channel Numbers (Always 0x01=Mono, 0x02=Stereo)
    _bwOutput.Write((ushort)0x01);// audioFormat.Channels);

    // Sample Rate (Binary, in Hz)
    _bwOutput.Write((uint)_microphone.SampleRate);//audioFormat.SamplesPerSecond);

    // Bytes Per Second
    _bwOutput.Write((uint)(16 * _microphone.SampleRate * 1 / 8));//  audioFormat.BitsPerSample * audioFormat.SamplesPerSecond * audioFormat.Channels / 8));

    // Bytes Per Sample: 1=8 bit Mono, 2=8 bit Stereo or 16 bit Mono, 4=16 bit Stereo
    _bwOutput.Write((ushort)2);// audioFormat.BitsPerSample * audioFormat.Channels / 8));

    // Bits Per Sample
    _bwOutput.Write((ushort)16);

    // -- DATA chunk

    _bwOutput.Write("data".ToCharArray());

    // Length Of Data To Follow
    _bwOutput.Write((uint)_rawDataLength);
}
Y ahora si, ya podemos crear el WAV dentro del stream, tendremos que llamar a la escritura de la cabecera al principio de la grabación y al final para guardar de nuevo la longitud. Una vez hecho esto tendremos un archivo WAV completamente válido.
public void Start(Stream output)
{
    OnDispatcher();
    dt.Start();

    _bwOutput = new BinaryWriter(output);
    this.WriteHeader();
    _microphone.Start();
}

public void Stop()
{
    _microphone.Stop();

    dt.Stop();
    OnDispatcher();

    long pos = _bwOutput.BaseStream.Position;
    _bwOutput.Seek(0, SeekOrigin.Begin);
    //write the lenght into the header
    this.WriteHeader();
    _bwOutput.Seek(0, SeekOrigin.End);
}
El código fuente de ejemplo disponible aquí está preparado para Windows Phone 7.1 y utiliza alguna característica nueva, como por ejemplo la propiedad command en los botones :D, pero eso lo explicaré en otro post más completo.

El ejemplo está basado en el ejemplo de ondrejsv hecho en Silverlight 4, adaptado a las características de WP7.

Novedades en el SDK 7.1 de Windows Phone

Hace muy poco se ha liberado la beta del SDK 7.1 de Windows Phone y trae algunas de las novedades que ya os he comentado en este blog. Mientras esperamos impacientes que se actualice nuestro dispositivo ya podemos probar las novedades en el emulador, que además trae algunas cosas nuevas a nivel de emulación.

Para ello podemos ir descargando los ejemplos que encontraremos en el MSDN, el mejor punto de partida para probar las nuevas funcionalidades.

Una de las novedades que encontraremos nada más abrir el visual studio es que tenemos unos cuantos tipos de proyecto nuevos:

Ahora ya tenemos aplicaciones 3D en Silverlight y tres agentes, para aplicaciones que funcionarán en segundo plano gracias a la nueva característica multitarea.

Si no elegimos una de las nuevas plantillas, que sólo están disponibles para 7.1, podremos elegir para qué plataforma queremos realizar la aplicación:

De esta manera podremos empezar a probar las nuevas funcionalidades sin dejar de lado los desarrollos que ya tengamos en marcha y no puedan esperar a que la actualización llegue al teléfono.

Otra gran novedad que será muy agradecida, especialmente por aquellos desarrolladores que aún no tienen un dispositivo de pruebas, es la nueva ventana de simulación de acelerómetro …

desde la cual podemos mover el teléfono en los ejes XYZ libremente o usar gestos grabados, por ahora viene con el gesto de sacudida (shake). Desde la misma pantalla tenemos la simulación de GPS, sobre la que podemos definir diferentes puntos sobre un mapa para que se vaya moviendo:

Y para acabar IE9 en el dispositivo:

Fijaros que la barra de direcciones está ahora en la barra inferior, dando algo más de espacio a la ventana del IE9… y que pese a la polémica/susto en torno al número del SDK, la versión del sistema operativo es efectivamente 7.5 😀

Estas son algunas de las novedades más visibles, poco a poco iremos desgranando todo lo que viene como las aplicaciones en background, Live Tiles, realidad aumentada, sockets y mucho más.

WP7: Canal de noticias (episodio 4)

Este artículo fue publicado en www.cristalab.com, para ver el contenido completo sigue el siguiente enlace.

Este es un artículo de una serie dedicada al desarrollo de aplicaciones para Windows Phone 7 en Silverlight. Como primer ejemplo estamos creando una aplicación sencilla de representación de datos y la iremos refinando en sucesivos episodios:

  1. Aplicación base: representación de datos y visionado de vídeos.
  2. Mejoras visuales y navegación
  3. Guardar el estado (tombstoning)
  4. Mejoras de rendimiento
  5. Interacción con otros servicios
  6. Preparación para el Marketplace

Waiting Boring
Hoy toca el episodio 4Mejoras de rendimiento. Veremos cómo con unos pocos cambios nuestra aplicación irá como un tiro. Para ello vamos a mejorar la aplicación en tres puntos: primero daremos información al usuario sobre lo que está ocurriendo en la aplicación, luego mejoraremos la ejecución multihilos y finalmente aumentaremos la velocidad de las listas en el UI.

Sigue leyendo en Cristalab.

Más recursos útiles para Windows Phone 7

Microsoft Patterns & PracticesHace unos días hicimos unos laboratorios de Windows Azure para Windows Phone. Para los que os picó el gusanillo del cloud, los chicos de Patterns & Practices han creado una guía llena de documentos y ejemplos que nos ayudarán a hacer aplicaciones de WP7 con tecnología cloud. Se puede descargar del codeplex o podemos leerla online en el msdn.
Es una guía muy interesante aunque no vayamos a usar Azure, pues ya sabéis que los servicios WCF que hacemos en Azure son casi los mismos que los que podemos hacer en casa.

Y para compensar tanto post de programación hoy os pongo un enlace para para diseñadores y “devigners”, la escuela de diseño de Microsoft incluye un montón de tutoriales nuevos para Windows Phone 7:

Tutoriales de Windows Phone 7 para diseñadores

http://www.microsoft.com/design/toolbox/school/tutorials.aspx

¡Que los disfrutéis!