DK Development

The Rise of the Engineering Agent Manager

2026-04-07T00:00:00+00:00

There’s a conversation happening in every engineering org right now, whether it’s out loud or just quietly in people’s heads: what exactly is my job now?

For a long time, the path was well understood. Junior developers write code, senior developers write better code and review it, tech leads set patterns and mentor, and engineering managers coordinate people and delivery. Everyone had a lane. AI has blown that model up, not by replacing people, but by fundamentally changing where the value is.

The engineers and leaders who are thriving right now aren’t the ones who are best at writing code. They’re the ones who are best at directing, reviewing, and shaping the work that AI agents are producing.

From Producer to Director

Here’s the mental shift that took me a while to internalise: your job is no longer to be the best implementer. It’s to be the best decision-maker about what gets implemented and why.

Think of it like the difference between being a craftsman and being an architect. A craftsman’s value is in their ability to produce the work with their hands. An architect’s value is in their ability to understand the brief, envision the outcome, and communicate that clearly enough for others (or now, agents) to execute it faithfully.

The coding work itself hasn’t disappeared. There’s more of it than ever. But the constraint has shifted from how fast can humans write code to how well can humans define, review, and guide what agents produce. That changes everything about what a strong engineering leader looks like.

Architecture, Strategy, Vision: Now the Whole Job

When an agent can scaffold a feature in minutes, the bottleneck becomes the quality of what you gave it to work from. Vague requirements produce vague code. Poorly considered architecture decisions, when handed to an agent that will faithfully implement them at scale, produce large amounts of faithfully bad code.

This is where Engineering Managers and tech leads are finding renewed purpose. Spending time deeply on:

System design and architecture: The decisions that are hard to reverse, that constrain everything downstream, that require experience and judgment.
Product strategy: What should we actually be building? What’s the simplest version of this that delivers value?
Technical vision: Where is the codebase going in 6 months? What patterns should agents be following? What should they never do?
Context documents: More on this below, but writing the documentation that puts agents in the right headspace is now a core leadership skill.

The engineers who are leaning into this are finding that their impact is multiplied. One person with a clear vision and a well-configured agent workflow can ship what used to take a team.

Controlling Agents Through Context

One of the more interesting things about working with AI coding agents (tools like GitHub Copilot, Cursor, and others) is that they’re heavily influenced by the context you give them. This has spawned a new type of document that’s becoming a standard part of engineering workflows: the AGENTS.md file, custom instruction files, and project-scoped prompt documents.

These documents are essentially your communication layer with your agents. A well-written AGENTS.md might define:

The coding style and conventions for the project
Which patterns to use and which to avoid
How to structure components, name things, and organise files
Testing expectations
Scope boundaries: what the agent should and shouldn’t touch

Tech leads who are writing these documents well are discovering something important: it forces you to articulate things that usually live only in your head. The conventions that you’d catch in a code review but never wrote down anywhere. The architectural decisions that are obvious to you but invisible to a new team member, or an agent.

There’s also a feedback loop here. When an agent produces something that misses the mark, the right response isn’t just to fix the output. It’s to update your context documents so the agent gets it right next time. This is a fundamentally different kind of engineering leadership work, and it’s a skill that takes practice.

Linear and the Agent-Friendly Backlog

Project management tooling is catching up fast. Linear has become the tool of choice for a lot of engineering teams, and it’s easy to see why when you start working in an AI-native way.

Where a traditional Jira ticket might be a title and two sentences, Linear has nudged teams toward writing richer, more structured issue descriptions. And now with AI agents that can be pointed at a Linear ticket to execute on, the quality of that ticket has a direct impact on the quality of what gets built.

The mental model is shifting from assign this to a developer to can an agent execute on this ticket as written? If the answer is no (too vague, missing acceptance criteria, or lacking technical context), that’s a signal the issue needs more work before it goes anywhere.

For engineering managers and leads, this creates a new responsibility around backlog hygiene. Grooming a ticket used to be about making sure a human developer had enough information to get started. Now it’s about making sure that information is structured clearly enough that an agent can run with it autonomously, with a human reviewing the output rather than doing the work line by line.

Some teams are even going further, using agents to draft tickets from higher-level briefs, then having leads review and refine those before they’re executed. The human judgment is still in the loop, just at a different stage.

The Review Layer Is the New Craft

If you’re an engineering leader and you’re worried that AI is devaluing your expertise, I’d push back on that. What’s changing is where you apply it.

The code review is becoming more important, not less. When agents are generating code, the review is where human expertise catches the subtle misalignments: the technically correct implementation that misses the intent, the approach that works for this feature but creates problems for the next one, the security concern that the agent didn’t have enough context to see coming.

This requires:

Deep familiarity with the codebase and its constraints
Clear communication about why something isn’t right, not just that it isn’t
The ability to update context documents so the same mistake doesn’t happen again
Trust in your own judgment about when to approve and when to push back

These are the skills that separate a great engineering leader from a mediocre one, and they haven’t changed. They’ve just been relocated to a new part of the workflow.

The Leaders Who Are Struggling

It’s also worth being honest about where the friction is. Not everyone is finding this transition easy.

The engineers who built their identity around being great implementers — who took pride in hammering out clean code quickly — are having to find a new source of professional satisfaction. That’s genuinely hard. The craft is real and it matters, and being asked to step back from it to direct others (or agents) doing it can feel like a demotion even when it isn’t.

There’s also a learning curve to working effectively with agents that a lot of people underestimate. It’s not as simple as asking a question and accepting whatever comes back. It requires developing intuition for when to trust the output, when to scrutinise it, and how to give feedback that actually improves future results.

The leaders who are investing time in building this intuition are pulling ahead. The ones who are treating AI tools as a productivity shortcut but not changing how they think about their role are finding the benefits much more limited.

Getting Started

If you’re an Engineering Manager or tech lead who’s still finding your footing with this shift, a few practical starting points:

Write an AGENTS.md for one of your projects. Even if it’s imperfect, the act of writing down your conventions is valuable regardless of agents.
Try completing a full feature with an agent, staying in the director seat. Define the work clearly, review what it produces, iterate through feedback. Notice where you struggle to articulate what you want.
Audit your Linear (or equivalent) backlog. Would an agent have enough context to work from these tickets? Where are the gaps?
Share the experience with your team. The best teams right now are learning together, sharing prompt patterns that work, updating shared context docs based on what agents get wrong.

The shift is real and it’s happening fast. The good news is that the skills that make a great engineering leader (clear thinking, good judgment, strong communication, technical depth) are exactly what this new way of working demands. They just need to be applied in new places.

The Engineering Agent Manager is already here. The question is whether you’re ready to step into that role.

Using Schema.org structured data to improve SEO

2025-12-03T00:00:00+00:00

Search engine optimization has long been a cornerstone of the web, continually evolving as search engines and open‑web initiatives shape how information is discovered.

Today, the rise of AI tools and AI‑powered search is accelerating that evolution, making structured data more critical than ever. In this post, I’ll explore how adding schema.org markup can enrich your content, improve visibility across both traditional search and AI‑driven platforms, and ultimately create a better experience for users.

Schema.org is a set of extensible schemas that enables webmasters to embed structured data on their web pages for use by search engines and other applications. For more details, see the homepage.

Why Use Structured Data?

Adding structured data to your website provides several benefits:

Rich Search Results: Your content can appear with enhanced visuals in search results, including star ratings, images, prices, and availability information
Better Click-Through Rates: Rich snippets stand out in search results, leading to higher engagement
Voice Search Optimization: Search assistants use structured data to provide spoken answers
Knowledge Graph Integration: Your content can be featured in Google’s Knowledge Panel
AI Agent Compatibility: Modern AI systems can better understand and utilise your content (more on this below)

How to Implement Structured Data

There are 3 main ways to include structured data in a website’s markup:

Microdata
JSON-LD
RDFa

Microdata adds additional attributes to HTML elements to identify the data on the page. The data is embedded directly within your existing HTML.

<article itemscope itemtype="https://schema.org/BlogPosting">
  <h1 itemprop="headline">My Blog Post Title</h1>
  <span itemprop="author" itemscope itemtype="https://schema.org/Person">
    <span itemprop="name">Damian Karzon</span>
  </span>
  <time itemprop="datePublished" datetime="2025-12-04">December 4, 2025</time>
  <div itemprop="articleBody">
    <p>The content of the blog post goes here...</p>
  </div>
</article>

JSON-LD (JavaScript Object Notation for Linked Data) adds a JSON block to the page where the structured data is output in a single location. This is Google’s recommended format as it’s easier to implement and maintain.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "My Blog Post Title",
  "author": {
    "@type": "Person",
    "name": "Damian Karzon"
  },
  "datePublished": "2025-12-04",
  "dateModified": "2025-12-04",
  "image": "https://example.com/images/post-banner.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "DK Development",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  }
}
</script>

RDFa (Resource Description Framework in Attributes) like Microdata, adds additional attributes to HTML elements to identify the data on the page. It’s more verbose but offers greater flexibility.

<article vocab="https://schema.org/" typeof="BlogPosting">
  <h1 property="headline">My Blog Post Title</h1>
  <span property="author" typeof="Person">
    <span property="name">Damian Karzon</span>
  </span>
  <time property="datePublished" datetime="2025-12-04">December 4, 2025</time>
  <div property="articleBody">
    <p>The content of the blog post goes here...</p>
  </div>
</article>

Which Format Should You Use?

JSON-LD is the recommended approach for most implementations because:

It’s easier to add and maintain (no need to modify existing HTML)
It keeps your markup cleaner
It’s Google’s preferred format
It can be dynamically generated server-side or via JavaScript

Popular Schema Types

A comprehensive list of schema types can be found at schema.org/docs/schemas.html.

The vocabulary currently consists of 792 Types, 1447 Properties, 15 Datatypes, 83 Enumerations and 445 Enumeration members.

Here are some of the most commonly used schema types:

Schema Type	Use Case
Article/BlogPosting	Blog posts and news articles
Product	E-commerce product pages
LocalBusiness	Physical business locations
Organization	Company information
Person	Individual profiles
Recipe	Cooking recipes
Event	Upcoming events
FAQPage	Frequently asked questions
HowTo	Step-by-step guides
Review	Product or service reviews
BreadcrumbList	Site navigation breadcrumbs
VideoObject	Video content

AI Agents and Structured Data

With the rise of AI assistants like ChatGPT, Claude, Gemini, and others, structured data has taken on a new dimension of importance. Here’s how AI agents interact with schema.org markup:

Enhanced Content Understanding

AI agents parse structured data to better understand the context and meaning of web content. When an AI encounters a page with proper schema markup, it can:

Accurately identify the type of content (article, product, recipe, etc.)
Extract key information like authors, dates, prices, and ratings
Understand relationships between entities on the page

AI-Powered Search and Assistants

Many AI systems now power search experiences and virtual assistants:

Retrieval-Augmented Generation (RAG): AI systems that search and synthesise information benefit from structured data to provide accurate, well-attributed responses
Voice Assistants: Siri, Alexa, and Google Assistant use structured data to answer questions directly
AI Search Engines: Perplexity, Bing Copilot, and Google’s AI Overviews leverage schema markup to generate accurate summaries

Agentic Web Browsing

As AI agents become more autonomous in browsing and interacting with websites:

Structured data helps agents understand page purpose and available actions
Schema types like Action and EntryPoint can indicate how to interact with a service
Well-marked content is more likely to be correctly interpreted and cited

Best Practices for AI Compatibility

To optimise your structured data for AI agents:

Be comprehensive: Include as many relevant properties as possible
Use accurate data: AI systems may cross-reference your claims
Include sameAs properties: Link to authoritative sources (Wikipedia, social profiles)
Add speakable schema: Indicates content suitable for text-to-speech
Implement WebPage and WebSite schemas: Helps AI understand your site structure

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "name": "DK Development",
  "url": "https://dkdevelopment.net",
  "potentialAction": {
    "@type": "SearchAction",
    "target": "https://dkdevelopment.net/search?q={search_term_string}",
    "query-input": "required name=search_term_string"
  }
}
</script>

Testing Your Structured Data

Before deploying structured data to production, validate it using these tools:

Google Rich Results Test: Tests if your page is eligible for rich results
Schema.org Validator: Validates your markup against the schema.org specification
Google Structured Data Markup Helper: Helps generate markup for your pages

A Real-World Blog Example

Here’s how I’ve implemented structured data on this very blog using JSON-LD:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://dkdevelopment.net/seo-structured-data-2025/"
  },
  "headline": "Using Schema.org structured data to improve SEO",
  "description": "How to add Schema.org markup to your websites to improve users search experience.",
  "image": "https://dkdevelopment.net/img/Banners/book.jpg",
  "author": {
    "@type": "Person",
    "name": "Damian Karzon",
    "url": "https://dkdevelopment.net"
  },
  "publisher": {
    "@type": "Organization",
    "name": "DK Development",
    "logo": {
      "@type": "ImageObject",
      "url": "https://dkdevelopment.net/img/favicon.ico"
    }
  },
  "datePublished": "2025-12-04",
  "dateModified": "2025-12-04"
}
</script>

Recap

Structured data is no longer just about improving traditional search results—it’s becoming essential infrastructure for how AI systems understand and interact with web content. By implementing schema.org markup:

Choose JSON-LD as your primary format for ease of implementation
Start with the basics: Add Article/BlogPosting schema to your blog posts
Expand to business schemas: Organization, LocalBusiness, and Person for your about pages
Test thoroughly before deployment using Google’s validation tools
Think about AI: Your structured data helps AI agents accurately represent your content

As AI continues to transform how users discover and consume web content, well-structured data will become a competitive advantage—not just for SEO, but for ensuring your content is accurately understood and represented across an increasingly AI-mediated web.

My Home Assistant Docker Compose file

2022-05-19T00:00:00+00:00

Over the last few months I have been playing around with a Home Assistant instance in Docker to run all of my home automation and over time I have slowly added more and more to it (more integrations, more services, more devices, etc.).

Some info about my setup before we get into it.

Host machine running Windows 10 Pro
Docker Desktop using WSL2 backend
.wslconfig configured with 30GB Ram and 5 Processors

Since I don’t run Home Assistant Operating System I don’t have the ability to use the supervisor and install services through that which means I’ve had to setup my own docker containers for additional services. The containers I have running here are:

Home Assistant - The standalone Home Assistant Core install
PostgreSQL - Database storage for Home Assistant recorder (instead of using filesystem)
Node Red - Low-code programming tool for wiring up events
Mosquitto - An MQTT message broker (to allow devices to use a publish/subscribe model of messaging)
Tasmoadmin - Administration platform for Tasmota devices (to allow OTA updates of devices without direct internet access)
Chrony - A Network Time Protocol (NTP) Server (to allow devices without internet access to synchronise time)
InfluxDB - A Scalable datastore for metrics, events, and real-time analytics (used for long term storage of sensor data)
Grafana - Open source data visualisation platform (to create dashboards from the data in InfluxDB)

So let’s take a look at the docker-compose.yml file:

version: '3.1'

services:

  home-assistant:
    container_name: home-assistant
    image: homeassistant/home-assistant:2022.5.4
    restart: always
    networks:
      - localnet
    volumes:
      - /c/local-docker/home-assistant/config:/config
      - /c/local-docker/home-assistant/media:/media
    depends_on:
      - mosquitto
    ports:
      - 8123:8123
      - 1400:1400
    environment:
      TZ: "Australia/Brisbane"

  postgres:
    container_name: postgres
    image: postgres:12.6
    restart: always
    networks:
      - localnet
    ports:
      - 5432:5432
    environment:
      POSTGRES_DB: homeassistant
      POSTGRES_USER: ha_user
      POSTGRES_PASSWORD: CrazyStr0ngPa$$word

  nodered:
    container_name: nodered
    image: nodered/node-red
    restart: always
    networks:
      - localnet
    ports:
      - 1880:1880
    volumes:
      - /c/local-docker/home-assistant/nodered:/data
    depends_on:
      - home-assistant
      - mosquitto
    environment:
      TZ: "Australia/Brisbane"

  mosquitto:
    container_name: mosquitto
    image: eclipse-mosquitto
    restart: always
    networks:
      - localnet
    ports:
      - 1883:1883
      - 1884:1884
    volumes:
      - /c/local-docker/home-assistant/mosquitto/config:/mosquitto/config
      - /c/local-docker/home-assistant/mosquitto/data:/mosquitto/data
      - /c/local-docker/home-assistant/mosquitto/log:/mosquitto/log
    environment:
      TZ: "Australia/Brisbane"

  tasmoadmin:
    container_name: tasmoadmin
    image: ghcr.io/tasmoadmin/tasmoadmin:v1.8.0
    restart: always
    networks:
      - localnet
    ports:
      - 8124:80
    volumes:
      - /c/local-docker/home-assistant/tasmoadmin:/data/tasmoadmin

  chrony:
    container_name: chrony
    image: cturra/ntp
    restart: always
    networks:
      - localnet
    environment:
      - NTP_SERVERS=time.windows.com
    ports:
      - 123:123

  influxdb:
    container_name: influxdb 
    image: influxdb:latest
    restart: always
    networks:
      - localnet
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - INFLUXDB_DB=home_assistant
      - DOCKER_INFLUXDB_INIT_USERNAME=influx_user
      - DOCKER_INFLUXDB_INIT_PASSWORD=CrazyStr0ngPa$$word
      - DOCKER_INFLUXDB_INIT_ORG=ha-org
      - DOCKER_INFLUXDB_INIT_BUCKET=ha-bucket
    ports:
      - 8086:8086
    volumes:
      - /c/local-docker/home-assistant/influxdb:/var/lib/influxdb2

  grafana:
    container_name: grafana
    image: grafana/grafana:latest
    restart: always
    networks:
      - localnet
    depends_on:
      - influxdb
    environment:
      - GF_SECURITY_ADMIN_USER=grafana_user
      - GF_SECURITY_ADMIN_PASSWORD=CrazyStr0ngPa$$word
    ports:
      - 8125:3000
    volumes:
      - /c/local-docker/home-assistant/grafana:/var/lib/grafana

networks:
  localnet:
    driver: bridge

Let’s start with a few of the common parts to it.

Commons

container_name - I’ve given all of the containers specific names instead of the default naming of <folder name>_<service name>_1
networks - All the containers have been added to a custom network called localnet which is also defined at the top level with the driver set to bridge. This is to make sure all of the containers can properly talk to each other and get around some network oddities I was experiencing with my setup.
restart - All of the containers are also set to always restart so whenever docker starts up they will also startup. So if the host is every restarted the containers will come back automatically.
depends_on - I have a few containers that set the depends on to ensure other containers are successfully loaded before them but this isn’t necessary.

Now into the containers themselves…

home-assistant

The main Home Assistant Core image, here I have given it a specific version so that I can easily see which version I’m using and update when I need to. Using latest here would work as well but may need to make sure if pulls down latest instead of using the existing cached version.

I also have setup some mapped volumes for this so I can keep my config files in a folder on the Windows host machine. /c/local-docker/home-assistant/config:/config This one maps the Windows folder C:\local-docker\home-assistant\config to the /config directory within the container which is where the main config yaml files are kept. This allows me to more easily edit the config files from the host machine as well as persisting the config across rebuilds of the container. The other volume entry is for media which allows me to easily add media to the server for local playback on media players. The TZ environment variable here sets the timezone of the container to make sure it’s running in my local timezone.

postgres

I’ve gone with using a PostgreSQL instance here for the recorder because my home assistant container has it’s config folder as a mounted volume which on Windows has a bit of a performance hit and since I run these folders from my local C Drive I wanted to make sure my home assistant wasn’t slowing anything else running on the host machine too much. The recorder integration also supports MySQL, MariaDB and SQLite (default), more info here: https://www.home-assistant.io/integrations/recorder/. The container I actually use is in a separate docker-compose file because I use it for other things as well but I included it here for completeness.

nodered

I am not setting a version for this image so it will just use the latest available when it is started (I haven’t had any issues with this so far). To connect the node red instance to home assistant you need to make sure you install the relevant home assistant packages:

node-red-contrib-home-assistant
node-red-contrib-home-assistant-websocket

Running node red in docker like this I found that installing packages from the UI didn’t install the latest from npm, because it installed them from the node red flows library (https://flows.nodered.org/). To install the latest versions here I had to run the npm install commands in the /data directory on the container itself. This container has a volume setup for the /data directory so that I can backup the config and the flow json files and state is again persisted between rebuilds of the container.

mosquitto

Using the eclipse-mosquitto broker for MQTT (latest version works fine here) because it seems to be the best supported one for home assistant. For this one I have 3 different volumes to map the config, data and log directories to local folders, mainly so I can backup the config and ensure state is persistent between container rebuilds.

tasmoadmin

The image for this is no longer being uploaded to docker hub which is why it is pulling from github packages (ghcr.io/tasmoadmin/tasmoadmin:v1.8.0). The mapped volume here lets me keep a backup of my config and devices as well as helping to persist state between container rebuilds.

chrony

Not too much to configure for this one, there is an environment variable to set the time server to use (NTP_SERVERS) this can be set to what ever you want. I went with time.windows.com because my host machine is running windows and wanted to have the 2 running against the same time server.

influxdb

Took me a little bit to decipher the documentation to get the right config I needed for this one since I hadn’t used influxdb before but got all the environment variables setup for it to work. Most of these are pretty straight forward for things like username, password, org and bucket, DOCKER_INFLUXDB_INIT_MODE=setup is used to ensure the automated setup is run the first time it is started. I also have a volume mapped here so that it persists between container builds mainly so that I don’t have to go about reconfiguring the integration with home assistant which requires the organisation id (not the same as the org environment variable) and the API token (generated through the automated setup).

grafana

This one I haven’t used too much yet but so this config may change as I use it more. At the moment I just have a mapped volume for backups and persistent state.

Bonus Content!

Since these services are all installed manually via docker I miss some of the integration points that comes with installing them through the HA supervisor. One of those is adding them to the side menu in home assistant, to do this we can make use of the panel_iframe integration in home assistant, here is an example of that integration in configuration.yaml.

panel_iframe:
  nodered:
    title: "Node Red"
    url: "http://192.168.1.5:1880/"
    icon: mdi:file-tree
  tasmoadmin:
    title: "TasmoAdmin"
    url: "http://192.168.1.5:8124/"
    icon: mdi:home-automation

Basic remote PC monitoring through Home Assistant

2021-12-15T00:00:00+00:00

I’ve had a server running at home for a while to run various things for work and personal use and recently I put Home Assistant on it to have a play with. If you haven’t heard of Home Assistant before it is an Open source home automation that puts local control and privacy first.

One thing that I wanted to do was be able to monitor the server status itself, things like storage, memory usage and temps then feed that into Home Assistant so I could try out a notification pipeline. The problem was since my HA instance runs as a docker container it doesn’t have direct access to those APIs in windows to give out that kind of info.

To get around this limitation I figured I had a look at a few tools that could surface that info as a Rest API that HA could consume but none did quite what I wanted easily so I decided to write my own light weight api to surface this data (also because it was fun). Then using the built in rest integration within HA I could set it up to read this data in as sensors.

I did this in .net core using the System.IO.DriveInfo.GetDrives() method which gets me all the details I need about the attached hard drives. Once I had that I filtered out to only should fixed drives (ie. non-removable storage) and mapped it to a model object so that I could output it as JSON without circular reference issues. I also outputted it as a dictionary where the drive letter was the key, this is to make it easier to pick up the specific drives later in HA.

Here is the code for the controller:

using Microsoft.AspNetCore.Mvc;
using System.IO;
using System.Linq;

namespace WinSysMon.Controllers
{
    public class HomeController : Controller
    {
        [Route("drives")]
        public IActionResult Drives()
        {
            DriveInfo[] drives = DriveInfo.GetDrives();

            var driveModels = drives
                .Where(d => d.DriveType == DriveType.Fixed)
                .Select(d => DriveInfoModel.Create(d))
                .ToDictionary(d => d.Name.Split(":").First());

            return Json(driveModels);
        }
    }

    public class DriveInfoModel
    {
        public long AvailableFreeSpace { get; set; }
        public string DriveFormat { get; set; }
        public string Name { get; set; }
        public long TotalFreeSpace { get; set; }
        public long TotalSize { get; set; }
        public string VolumeLabel { get; set; }

        public static DriveInfoModel Create(DriveInfo drive)
        {
            return new DriveInfoModel
            {
                AvailableFreeSpace = drive.AvailableFreeSpace,
                DriveFormat = drive.DriveFormat,
                Name = drive.Name,
                TotalFreeSpace = drive.TotalFreeSpace,
                TotalSize = drive.TotalSize,
                VolumeLabel = drive.VolumeLabel
            };
        }
    }
}

Once that was done and the API was working I needed to setup the sensors in HA using the rest integration. I setup 3 sensors per drive: availableFreeSpace, totalSize and volumeLabel which gave me enough info to do what I needed. The rest integration can be configured via the yaml file in HA and it allows you to setup multiple sensors from a single endpoint it also lets you set the interval times and authentication.

Using host.docker.internal as the url so that my HA instance running in docker can reference the host PC. Also doing some calculations on the values here since the API outputs the values in bytes so that I can just read them in as GB with 2 decimal places which is enough for me but can be changed easily. Here is my yaml configuration for the rest sensors setting

rest:
  - scan_interval: 600
    resource: http://host.docker.internal:55555/drives
    sensor:
      - name: "Server Drive C availableFreeSpace"
        value_template: "{{(value_json.C.availableFreeSpace | float / 1024 / 1024 / 1024) | round(2)}}"
        unit_of_measurement: GB
        
      - name: "Server Drive C totalSize"
        value_template: "{{(value_json.C.totalSize | float / 1024 / 1024 / 1024) | round(2)}}"
        unit_of_measurement: GB
        
      - name: "Server Drive C volumeLabel"
        value_template: "{{value_json.C.volumeLabel}}"
        

      - name: "Server Drive D availableFreeSpace"
        value_template: "{{(value_json.D.availableFreeSpace | float / 1024 / 1024 / 1024) | round(2)}}"
        unit_of_measurement: GB
        
      - name: "Server Drive D totalSize"
        value_template: "{{(value_json.D.totalSize | float / 1024 / 1024 / 1024) | round(2)}}"
        unit_of_measurement: GB
        
      - name: "Server Drive D volumeLabel"
        value_template: "{{value_json.D.volumeLabel}}"

This will add some new entities to Home Assistant for us which look something like this in the dev tools.

Now that we have the sensor data in HA we can start using it, for now I have put it into a lovelace dashboard but it can also be used in automation rules and setup as triggers etc. I created a simple gauge card to test it setting severity with red as under 10%, orange as under 50% and green over 50%.

type: gauge
entity: sensor.server_drive_c_availablefreespace
min: 0
max: 233
severity:
  green: 115
  yellow: 23
  red: 0
needle: true
name: 'C: Drive Usage'

From here next steps would be to look at integrating more sensors into the pipeline such as memory and temperature which can be done by querying with System.Manamgent.ManagementObjectSearcher.

Google Lighthouse CI Server Automation

2021-09-28T00:00:00+00:00

Website performance is one of those things that is “important” to everyone but it is sometime hard to test and keep track of the results in a way that is easy to navigate and doesn’t require too much effort. Recently it has become even more important for SEO (Search Engine Optimization) with the big search engines starting to use these metrics more to affect ranking (See: Understanding page experience in Google Search results).

Google Lighthouse is a well known performance testing tool for websites that is built into Google Chrome and used by Google PageSpeed Insights. But there is also Lighthouse CI which is an open source CLI tool for automating running lighthouse for a CI/CD environment.

Lighthouse CI also has a server component that let’s you save reports and compare them which can be very useful.

To setup the Lighthouse CI server through docker there are 3 parts to it.

Dockerfile

Setup the docker image to run the Lighthouse CI server with the appropriate config.

FROM node:12-buster-slim

WORKDIR /usr/src/lhci
COPY package.json .
RUN npm install
COPY lighthouserc.json .

EXPOSE 8000
CMD [ "npm", "start" ]

package.json

The package.json file used to install the libraries and configure the server start.

{
  "name": "lhci",
  "version": "0.0.0",
  "scripts": {
    "start": "lhci server --config=./lighthouserc.json"
  },
  "dependencies": {
    "@lhci/cli": "^0.8.1",
    "@lhci/server": "^0.8.1",
    "mysql2": "^2.1.0",
    "pg": "^7.12.1",
    "pg-hstore": "^2.3.3",
    "sqlite3": "^4.0.6"
  }
}

lighthouserc.json

The configuration file for the server, using PostgreSQL storage and daily CRON task to collect reports from PageSpeed Insights. Check out the Lighthouse CI Server docs for more info on this. To enable the PageSpeed Insights cron task you will need to get an API Key from the official documentation.

{
    "ci": {
        "server": {
            "port": 8000,
            "storage": {
                "storageMethod": "sql",
                "sqlDialect": "postgres",
                "sqlConnectionUrl": "postgres://lhci_user:<password>@host.docker.internal:5432/lighthouseci_db"
            },
            "basicAuth": {
                "username": "damian",
                "password": "<PASSWORD>"
            },
            "psiCollectCron": {
                "psiApiKey": "<psiApiKey>",
                "sites":[
                    {
                        "urls": ["https://dkdevelopment.net/", "https://dkdevelopment.net/2019/05/25/working-remotely/", "https://dkdevelopment.net/resume/"],
                        "schedule": "0 0 * * *",
                        "projectSlug": "dkdevelopment.net"
                    }
                ]
            }
        }
    }
}

Once the server is up and running you then need to create a project on the server, to do this run: lhci wizard to create a new project on the server and answer the questions it asks. Save the tokens it generates (you will need these later).

With the project setup and the PSI CRON tasks running you will then be able to see the daily reports coming in with the ability to compare reports over time.

Tips and tricks for Github Pages

2020-07-26T00:00:00+00:00

This blog has been hosted on Github Pages for a long time, a very very long time, according to my git history since Feb 2012 (before that it was on Wordpress).

I decided to make the change for a few reasons:
-To learn something new (Jekyll/Liquid were new to me)
-Have it feel more like a dev blog (writing posts in a dev IDE pushing to git etc.)
-Also the Pretzel Code52 project had just kicked off and I was interested in getting involved in that (https://github.com/Code52/pretzel).

Now, 8 years later I am trying to get into blogging again so I am breathing new life into my Github Pages blog as well as building a new website for a podcast using Github Page so I thought I’d share some of the interesting things it can do.

Docker

I’m not a ruby developer and I didn’t want to have to install all of the ruby dev tools just to be able to add blog posts. Previously I was using a prebuilt version of pretzel locally which worked pretty well, there were a few things that worked differently or were not supported but I got by. After doing a fair bit of work with docker I figured I should just be able to run jekyll on docker, run the same version that runs on Gihub Pages without all the overhead.

Luckily there are already github pages images setup so I didn’t need to do much to get this working, the one I went with is Starefossen/docker-github-pages. After finding that it was as easy as creating a powershell script to run it, which also mounts the directory to the docker container so it will auto update when changes are made.

docker run -it --rm -v ${PWD}:/usr/src/app -p "1000:4000" starefossen/github-pages jekyll serve -d /_site --drafts --watch --force_polling -H 0.0.0.0 -P 4000

For each loops

Github pages and Jekyll use the Liquid templating language which lets you do some fun things, one of them is for loops. The below code loops through the posts on the site (getting the first 12) to display links for each. {% for post in site.posts limit: 12 %} - site.posts being the collection to iterate over. for post in defines a post as the individual item being iterated. limit: 12 sets the loop to only iterate over the first 12 items, this can also be used with offset: 12 which sets the iteration to start at item 12 in the collection.

{% for post in site.posts limit: 12 %}
    <a href="{{ post.url }}">
        {{ post.title }}
    </a>
{% endfor %}

Combine and Minify CSS

This one is a bit of a hack but it allows you to combine and (somewhat) minify CSS files using some of the liquid templating. Starting with the capture block which lets you store a result in a variable without rendering it. Using the capture we then include the relevant css files inside the capture here using the include_relative tag. Finally we render the newly captured variable making sure to strip out the new lines and multiple spaces.

---
permalink: /css/dkdev.min.css
---
{%- capture sitecss -%}
    {% include_relative bootstrap.min.css %}
    {% include_relative fontawesome-free.min.css %}
    {% include_relative clean-blog.css %}
{%- endcapture -%}
{{- sitecss | strip_newlines | replace: "  ", "" -}}

Data files

Jekyll allows you to add other data files that can be used by various pages. These are just yml, json or csv files that can be put in the _data folder that can be accessed from any page or layout using site.data.

- name: Phili J Fry
  title: Delivery Boy

- name: Bender
  title: Company Chef

- name: Turanga Leela
  title: Captain

- name: John Zoidberg
  title: Staff doctor

This data file can then be used by a for loop to display all the items:

{% for character in site.data.characters %}
    <li>
        {{ character.name }} - {{ character.title }}
    </li>
{% endfor %}

Syntax Highlighting

Github Pages has built in syntax highlighting that uses the Rouge Ruby syntax highlighter library. It let’s you wrap your code with {% highlight %} and {% endhighlight %} and it will do some formatting with it which allows you to easily style it. All you need to do is include a rouge or pygments compatible stylesheet.

Here is what mine looks like for reference: https://dkdevelopment.net/css/pygments_style.css

Getting started with Singer and Docker

2020-06-14T00:00:00+00:00

I’ve been doing a lot of work with data recently and I wanted a way to be able to join some of our platform data to our traffic data from Google Analytics.

After trying a few methods to get data out of Google Analytics into our PostgreSQL database with not much success I discovered singer.io a “Simple, Composable, Open Source ETL” tool. So I started playing around with the Google Analytics tap and the PostgreSQL target (https://www.singer.io/tap/google-analytics/postgresql/). After a lot of digging through various documentations and source code I was able to get it working!

Now that I have it running it was time to try and automate it somehow, to do this I tried to set it up as a docker container that way it can be run in the cloud (In our case AWS) on a schedule to pull in data daily from Google Analytics.

Here is the Docker file that puts it all together.

FROM python:3.7.6-stretch

RUN pip install singer-target-postgres

COPY ./tap-google-analytics-master/ ./external/tap-google-analytics-master/
WORKDIR /external/tap-google-analytics-master
RUN pip install -e .

WORKDIR /
COPY ./singer/tap_google-analytics_config.json ./tap_google-analytics_config.json
COPY ./singer/client_secrets.json ./client_secrets.json
COPY ./singer/tap_google-analytics_reports.json ./tap_google-analytics_reports.json
COPY ./singer/target_postgres_config.json ./target_postgres_config.json

CMD tap-google-analytics -c ./tap_google-analytics_config.json | target-postgres -c ./target_postgres_config.json >> state.json

A few things here to call out to get this working. Installing the PostgreSQL target was straight forward but for the Google Analytics tap I used an unofficial library and built it from the source at https://gitlab.com/meltano/tap-google-analytics. After that we have the various config files.

tap_google-analytics_config.json This is the config for the Google Analytics tap, key file location is name of the config file that details the service account credentials. The reports property is a json file that defines the reports to pull from Google Analytics. The start date and end date here define the date range to pull the report data for.

{
  "key_file_location": "client_secrets.json",
  "view_id": "111111111",
  "reports": "tap_google-analytics_reports.json",
  "start_date": "2020-06-01T00:00:00Z",
  "end_date": "2020-06-15T00:00:00Z"
}

client_secrets.json this file contains the service account credentials, to get these follow the instructions defined in https://gitlab.com/meltano/tap-google-analytics#creating-service-account-credentials.

tap_google-analytics_reports.json this file defines the report data being pulled from Google Analytics. A full list of the available dimensions and metrics can be found here: https://ga-dev-tools.appspot.com/dimensions-metrics-explorer/. Here is an example of a report for pageviews.

[{
    "name": "ga_pageviews",
    "dimensions": [
        "ga:date",
        "ga:pagePath",
        "ga:source",
        "ga:medium",
        "ga:sourceMedium"
    ],
    "metrics": [
        "ga:pageviews"
    ]
}]

target_postgres_config.json This file is the config for the PostgreSQL target, mostly straight forward connection config.

{
  "postgres_host": "localhost",
  "postgres_port": 5432,
  "postgres_database": "ga_data",
  "postgres_username": "db_user",
  "postgres_password": "db_treasure",
  "postgres_schema": "public",
  "after_run_sql": ""
}

Now that we have everything setup to run in docker to truly automate this all that is left to do is being able to update the start and end date properties in the Google Analytics config file dynamically. This can be done with a bit of bash.

Working Remotely (and how)

2019-05-25T00:00:00+00:00

I work remotely and have been full time for over 6 months now and I wanted to take some time to talk about my experience with it. I quite often joke about this, for example here is a post from my Instagram after my 2nd week at another fully remote workplace.

damiankarzon

Damian Karzon (@damiankarzon) on Mar 8, 2019 at 4:42pm PST

What people think of when I say I work from home vs. what it's actually like.

But this is actually something I take very seriously and I am constantly asked about it. When I tell people I work from home they often ask me a question like “How often do you have to go into the office?” or “Where is their head office?”. My current workplacehas no office, none at all. The entire company works remotely which is sometimes a strange concept for people.

When I first started working remotely there were a few things that I was worried about:

Distractions
Cabin fever
Isolation
Work-life balance

Again, this post is specifically about my experience with remote work and, as I have learned throughout this time, everyone is different and depending on personalities are affected in different ways when it comes to this sort of thing.

Distractions

When I first started I thought the distractions would be a big problem for me (from past experience working from home in a non-full time way) so I set out to make sure I could minimise it. The main thing I did for this was to separate my home and work life both physically and mentally. I had a spare room at my place which I have converted into my home office that I use exclusively for working, I also have a dedicated work computer that I don’t use for anything else (ie. no games on it). To separate my home and work life mentally I try to go for a walk every day when I finish work, this helps to break up the work day from the non-work day (it’s also good to get some exercise in).

Cabin fever

This wasn’t something I had actually considered when I started since I am quite comfortable staying at home for long periods of time. However the problem came up often when I found myself being stuck in a problem that I couldn’t solve. I would start to get irritated very easily by my surroundings and not being able to solve the problem in front of me so I would end up walking up and down the hallway for no reason. In this situation now I quite often turn to someone else on the team and jump of a quick call just to talk things out or I leave the house and go for a walk to get some fresh air.

Isolation

I often hear people talk about isolation being their biggest problem when it comes to working remotely but this hasn’t been a massive problem for me, probably due to living alone for the last 6 years. This is also helped by the virtual meetings we have which are all video calls and always start with a bit of a chat before getting into business. A great example of this is our weekly whole company meetings where we start by everyone having a chance to share something personal (maybe they did something exciting on the weekend or during the week) or they can share a learning from the previous week.

Work-life balance

“Do you find yourself working more since it’s all just there?” or “Do you sometimes just go and watch tv instead of working?” other questions I sometimes get asked. Both are on opposite sides of the work-life balance, on one hand you have the potential to over work since it is so close and on the other you could do no work at all because you are not confined to an office. My answer to both of these questions is normally “Yes but…”, yes sometimes I do find myself working more, yes sometimes I do take a random break during the day if I’m feeling drained or stuck. It’s all about having the balance between the 2, it is much easier when working from home to over work or to under work but if you are motivated to do the work and have the discipline to keep working when you need to then you won’t have a problem. Motivation can be hard to find sometimes so it’s important to have work that you enjoy and are passionate about and to have a team that work well together. It is also important to remember that no job is awesome all the time and work will sometimes get you down but you need to keep at it anyway and work on making it better where you can.

Environment

I have put a lot a lot of time, effort and investment into getting my home office setup and it’s at a point where I am more productive there than any office I have ever worked at.

Desk: SKARSTA sit/stand desk from IKEA (120x70 cm)
Chair: DX Racer Classic Series
Laptop: Microsoft Surface Book 2 (13” i7, 16GB Ram, 512GB SSD) with Surface dock
Monitor: Dell P2715Q 27” 4K
Audio: Steelseries Arctis 3 Bluetooth headset & JBL Charge 2 Bluetooth speaker
Keyboard: Steelseries Apex 350
Mouse: Steelseries Rival 110

Tools

It is also super important to find the right tools and team process to be able to work remotely. The majority of our communication is text based and for that we use Slack mostly (some emails here and there when dealing with external parties). Sometimes it’s harder to communicate things over text, when this happens we tend to jump on a quick call using either a phone call, Slack call or a Zoom video call. We currently run a “scrum-like” development process which includes daily virtual stand-ups, for this we use Zoom. We also use video calls for larger team meetings such as the weekly whole company or product team meetings, this makes discussions much easier and allows people to share screens if required.

There are also times when the team (or at least part of the team) will meet up in person, for example the Brisbane dev team try to get together once a month and spend the day working together, this is either at a co-working space or a shared space (such as a library). There are also times when all of the workers in Brisbane will get together for a team lunch, this greatly heaps everyone get to know each other more and to feel more comfortable with each other.

Well that’s enough ramblings from me about working remotely, let me know your thoughts on it or if you have any questions feel free to reach out to me (@dkarzon on Twitter).

Building a Discord voice bot with Discord.NET

2019-02-18T00:00:00+00:00

I've been playing around with the Discord api recently, I wanted to see what could actually be done with it. I set a goal to make a discord bot that slightly annoys people by joining voice channels and randomly say Zapp Brannigan quotes.

For those who don't know Discord is an:

All-in-one voice and text chat for gamers that's free, secure, and works on both your desktop and phone. - https://discordapp.com/

I got started with Discord.NET and was able to get the bot connected very quickly. Discord.NET is an unofficial .NET API wrapper for discord which seem to be the most popular and widely used library for it so I went with it. Be sure to check out the documentation for details. For this to work with voice connections there are a few native dlls that you need to download and put with your application. These are simple enough to get from the voice documentation (or check out my full source link at the end).

First thing you need to do is get an instance of DiscordSocketClient for my project I am doing a .NET Core 2.2 console app with the built in dependency injection.

_discord = _services.GetRequiredService<DiscordSocketClient>();
await _discord.LoginAsync(TokenType.Bot, _botToken);
await _discord.StartAsync();

That is all the code you need to have your bot connect to discord!

I wanted my bot to detect when a user joined a voice channel and connect to that channel (if it wasn't already). To do that I used the UserVoiceStateUpdated event on the DiscordSocketClient which can tell us when a users voice state updates (join/leave/move voice channels).

// Add this before calling StartAsync
_discord.UserVoiceStateUpdated += OnVoiceStateUpdated;

The code to handle the event then looks like this:

private async Task OnVoiceStateUpdated(SocketUser user, SocketVoiceState state1, SocketVoiceState state2)
{
    // Check if this was a non-bot user joining a voice channel
    if (user.IsBot)
        return;

    if (state1.VoiceChannel == null && state2.VoiceChannel != null)
    {
        ConnectToVoice(state2.VoiceChannel).Start();
    }
}

private async Task ConnectToVoice(SocketVoiceChannel voiceChannel)
{
    if (voiceChannel == null)
        return;

    Console.WriteLine($"Connecting to channel {voiceChannel.Id}");
    var connection = await voiceChannel.ConnectAsync();
    Console.WriteLine($"Connected to channel {voiceChannel.Id}");
}

Important to note here is that we don't await ConnectToVoice, this is because if we await that call from inside the UserVoiceStateUpdated event it will cause a deadlock and never return from connecting to the voice channel.

Now we are connecting to a voice channel when we detect a user joins it so lets look at having the bot actually send audio through. To do this the documentation for the library has an example using ffmpeg to read the sound files and pipes that into a stream that then gets sent to Discord.

var psi = new ProcessStartInfo
{
    FileName = "ffmpeg",
    Arguments = $@"-i ""{sound.Filename}"" -ac 2 -f s16le -ar 48000 pipe:1",
    RedirectStandardOutput = true,
    UseShellExecute = false
};
var ffmpeg = Process.Start(psi);

var output = ffmpeg.StandardOutput.BaseStream;
var discord = connection.CreatePCMStream(AudioApplication.Voice);
await output.CopyToAsync(discord);
await discord.FlushAsync();

Here we start a new process passing in start info that opens up ffmpeg.exe (also included in the project) passing in a relative path to out sound file and a few other command line args to play the sound and pipe the output which we then copy into a stream into discord.

This is the basics of creating a voice capable discord bot with Discord.NET, for a more advanced implementation take a look at the full source for this project at https://github.com/dkarzon/DiscordZapBot.

Responsive xaml properties in Xamarin.Forms

2018-06-24T00:00:00+00:00

I have been working on UI and UX a bit lately and trying to come up with views that are fluid across a whole range of device resolutions.

Now, Xamarin.Forms does do a great job with UI but sometimes there are little things that you want to change on a per device or per resolution level.

I noticed that there is a built in xaml helper called OnPlatform that lets you set xaml properties differently per platform so I dug into that to try and make my own and I found markup extensions which let you do just that, extend markup. So I decided to make a markup extension which allows me to set different xaml properties based on screen size.

Here is the ResponsiveWidthProp, using similar logic we have also created one for height but for now we’ll just work with the width. It’s a pretty simple class it implements the IMarkupExtension interface, it has a public list property for Query which will hold the values and max widths we want, using the ContentProperty attribute here so we can use the elements content to set this property as well as a Default property in case we don’t have a value set for the given width. We then have a ProvideValue function that gets the current screen width then goes through the query list to find a match for the width or falls back to the default.

Markup extension

[ContentProperty("Query")]
public class ResponsiveWidthProp<T> : IMarkupExtension
{
    public IList<ResponsiveSet> Query { get; set; } = new List<ResponsiveSet>();
    
    public T Default { get; set; }

    public object ProvideValue(IServiceProvider serviceProvider)
    {
        var size = GetSize();

        foreach (var res in Query.OrderBy(r => r.MaxSize))
        {
            if (size > res.MaxSize)
                continue;
            return res.Value;
        }

        return Default != null ? Default : default(T);
    }
    
    public int GetSize()
    {
        var width = Application.Current.MainPage.Width;

        return (int)width;
    }
}

[ContentProperty("Value")]
public class ResponsiveSet
{
    public int MaxSize { get; set; }
    public object Value { get; set; }
}

Usage

<Image HorizontalOptions="Start" Source="Logo" VerticalOptions="Start">
    <Image.Margin>
        <xaml:ResponsiveHeightProp x:TypeArguments="Thickness" Default="4,24">
            <xaml:ResponsiveSet MaxSize="570">0,16</xaml:ResponsiveSet>
            <xaml:ResponsiveSet MaxSize="1000">2,18</xaml:ResponsiveSet>
        </xaml:ResponsiveHeightProp>
    </Image.Margin>
</Image>

Read the docs on Creating XAML Markup Extensions to find out more about them.

Handling image paths in Xamarin.Forms on UWP

2017-07-20T00:00:00+00:00

Adding a Universal Windows Platform project to an existing Xamarin.Forms Android/iOS solution is meant to "just work". However when doing this myself I have found a few things that don't work as expected, one of those was images and image paths.

On iOS and Android there are special folders where the platform stores it's image files, iOS has Resources\Images.xcassets and Android has Resources\drawable.

So on either of these 2 platforms all you need to do to add an image in xaml is something like this: <Image Source="MyIcon" /> and it would pull an image from the relevant folder for you, you don't even have to put in the file extension.

I found on a UWP app this isn't the case, so I did a bit of searching and came across this on the official Xamarin.Forms guide for images:

iOS - Place images in the Resources folder with Build Action: BundleResource. Retina versions of the image should also be supplied - two and three times the resolution with a @2x or @3x suffixes on the filename before the file extension (eg. myimage@2x.png).
Android - Place images in the Resources/drawable directory with Build Action: AndroidResource. High- and low-DPI versions of an image can also be supplied (in appropriately named Resources subdirectories such as drawable-ldpi, drawable-hdpi, and drawable-xhdpi).
Windows Phone - Place images in the application's root directory with Build Action: Content.
Windows/UWP - Place images in the application's root directory with Build Action: Content.

The project I am working on has just over 200 images, so putting them in the project root is ridiculous!

The solution?

I created a custom renderer for the Image control on UWP and from there I could override the native image source and change the path of the image to one that suited me. This isn't a perfect solution but it's done the job so far, as long as all your images are in the same folder and have the png extension.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DkDevelopment.UWP;
using Xamarin.Forms;
using Xamarin.Forms.Platform.UWP;
using Xamarin.Forms.Internals;

[assembly: ExportRenderer(typeof(Image), typeof(FixedImageRenderer))]

namespace DkDevelopment.UWP
{
    // Image renderer based on The Xamarin.Forms UWP ImageRenderer
    // https://github.com/xamarin/Xamarin.Forms/blob/master/Xamarin.Forms.Platform.WinRT/ImageRenderer.cs
    // Ensures images are loaded from an Images folder in the project instead of the root and they have the .png extension which is required for UWP but not iOS or Android.
    public class FixedImageRenderer : ImageRenderer
    {
        bool _disposed;

        private string _imagePrefix = "Images\\";

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);

            _disposed = true;
        }

        protected override async Task TryUpdateSource()
        {
            // By default we'll just catch and log any exceptions thrown by UpdateSource so we don't bring down
            // the application; a custom renderer can override this method and handle exceptions from
            // UpdateSource differently if it wants to

            try
            {
                await UpdateSource2().ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Log.Warning(nameof(ImageRenderer), "Error loading image: {0}", ex);
            }
            finally
            {
                ((IImageController)Element)?.SetIsLoading(false);
            }
        }

        private void TryFixSourcePath(ImageSource source)
        {
            if (source is FileImageSource)
            {
                var fileSource = source as FileImageSource;
                if (fileSource != null)
                {
                    var filePath = fileSource.File;
                    if (!filePath.StartsWith(_imagePrefix))
                        filePath = _imagePrefix + filePath;
                    if (!filePath.EndsWith(".png"))
                        filePath += ".png";

                    if (filePath != fileSource.File)
                        fileSource.File = filePath;
                }
            }
        }

        protected async Task UpdateSource2()
        {
            if (_disposed || Element == null || Control == null)
            {
                return;
            }

            Element.SetIsLoading(true);

            ImageSource source = Element.Source;
            TryFixSourcePath(source);

            IImageSourceHandler handler;
            if (source != null && (handler = Registrar.Registered.GetHandler<IImageSourceHandler>(source.GetType())) != null)
            {
                Windows.UI.Xaml.Media.ImageSource imagesource;

                try
                {
                    imagesource = await handler.LoadImageAsync(source);
                }
                catch (OperationCanceledException)
                {
                    imagesource = null;
                }

                // In the time it takes to await the imagesource, some zippy little app
                // might have disposed of this Image already.
                if (Control != null)
                {
                    Control.Source = imagesource;
                }

                RefreshImage();
            }
            else
            {
                Control.Source = null;
                Element.SetIsLoading(false);
            }
        }

        void RefreshImage()
        {
            ((IVisualElementController)Element)?.InvalidateMeasure(InvalidationTrigger.RendererReady);
        }
    }
}

Get the full source here: https://gist.github.com/dkarzon/fe029bc1b3e31fcb9753855437241467

What's the deal with cordova on WP

2015-04-01T00:00:00+00:00

Lately I have been talking to a few people about getting Ionic (open source framework for developing hybrid mobile apps with HTML5) running on a Windows Phone and just talking about it has shown me that it's a little bit of a mess working with Windows solutions at the moment because of the convergence of Windows that has slowly been happening since Windows 8 arrived.

The aim of this post is to get those starting out with Cordova apps on Windows to better understand what's going on behind the scenes because it can greatly affect how and where the app runs.

There are 2 ways to run Cordova on Windows Phone which have slightly different implications.

1. Windows Phone 8.0 - This solution compiles into a Silverlight project with an embeded webview. A few things to think about when working with this kind of project.

This will give you greater device support (Runs on Windows Phone 8.0 and above)
Performance is not as good as below.
Less debug support within Visual Studio
Seems to be less reliable with versions of IE depending on OS versions (large difference between IE rendering between WP8.1 and WP8.1-Update1)

2. Windows Phone 8.1 (or Universal) - This is a native javascript project as supported by the Windows Runtime (Windows 8.1 and Windows Phone 8.1)

Less device support (only Windows Phone 8.1, apparently that is over 50% of Windows Phone users now)
Much better performance than above
100% support between Windows Store and Windows Phone
Upgrade path to Windows 10 will be a lot easier
Can debug within Visual Studio with full javascript inspection, breakpoints, DOM Explorer, etc.

Depending on how you generate your Windows Phone project with cordova determines which solution you get. With the current tools adding the wp8 platform will get you the silverlight project but adding the windows platform will give you the native javascript solution with projects for Windows Store and Windows Phone in a universal solution.

Converting ANID (WP7) to ANID2 (WP8)

2014-12-25T00:00:00+00:00

Your Windows Phone 7 app uses ANID and you want to upgrade to Windows Phone 8.1 WinRT or native Javascript?
Short answer is you can't.

What am I even doing here?
As the title suggests the answer is to update to either 8.0 or 8.1 sliverlight and for the love of god store your ids locally.

In Windows Phone 7 there was a property we could use called ANID UserExtendedProperties.GetValue("ANID") this gave you a user specific id based on the logged in Microsoft account (across devices).

Then in Windows Phone 8 ANID was phased out and instead we were given ANID2 UserExtendedProperties.GetValue("ANID2") which is a more specific id based on the publisher id of the application. This was done to improve privacy so no entity could track a user across devices and applications.

Now with Windows Phone 8.1 Universal apps we get the the WinRT xaml stack and native javascript apps!
EVERYTHING IS AWESOME!
Wait, didn't you say you can't upgrade?
Unfortunately moving to Universal (Either Xaml or Javascript) means you lose access to the Phone APIs such as Microsoft.Phone.Info.UserExtendedProperties so no access to ANID or ANID2. So we need to stay on Silverlight for now.

This is where I got to before cursing the world and asking myself why I didn't store the id locally. Store your ids locally!

After coming to the realisation that I couldn't update to a native javascript app I started looking at how to go about the ANID to ANID2 upgrade process. I came across this article from the Windows blog http://blogs.windows.com/buildingapps/2013/03/11/migrating-anids-to-windows-phone-8/. Only to realise I was truncating the ANID because thats how the site did it where I got the code.

Don't worry if you are as well, here is how to fix it.
If you are truncating the ANID with Substring(2, 32) then all you need to do is append "A=" to the start and "&E=f48&W=3" to the end and the converter will work for it.

The conversion can also be done in C# with a few lines of code:

//Put your publisher id here
var publisherId = new Guid("000000000-0000-0000-0000-000000000000");

var anidAsBytes = System.Text.Encoding.Unicode.GetBytes(anid);
var publisherAsBytes = publisherId.ToByteArray();
var macObject = new HMACSHA256(anidAsBytes.Take(anidAsBytes.Length / 2).ToArray());
var hashedBytes = macObject.ComputeHash(publisherAsBytes);

var result = Convert.ToBase64String(hashedBytes);

Windows 8 sharing the right way

2014-05-08T00:00:00+00:00

For the love of god SetText()

In Windows 8 the share charm can be a very powerful concept allowing selections of data to be easily sent between apps with a nice user experience. Working on the Windows 8 platform for some time I have seen a lot of apps with poorly implemented share charms and this really annoys me.

The first thing to do when implementing a share contract is to subscribe to the DataRequested event on the current view's DataTransferManager. This event will be fired when ever the share charm is invoked while you app is running.

var transferManager = DataTransferManager.GetForCurrentView();
transferManager.DataRequested += OnDataRequested;

From this event you get access to a DataRequest object where you can set all of your properties to share to other apps. Below is both a bad and good example of implementing this event. I have seen too many apps using the bad example out of developer laziness or lack of understanding about what to share.

This is a bad example of sharing.

public void OnDataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
    args.Request.Data.Properties.Title = "My awesome app!";
    args.Request.Data.Properties.Description = "I CAN HAZ FACEBOOK SHARE FEATURE";
}

This is a good example of sharing.

In this example we will give our share a title, description as well as a custom share test, a thumbnail and an image of the awesome emotion.

public async void OnDataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
    args.Request.Data.Properties.Title = "Share Tester!";
    args.Request.Data.Properties.Description = "I'm going to share Text, Image, Thumb, Link and StorageItems.";

	//Set the text content for the share target to use
    args.Request.Data.SetText("Check this out, sharing with the Share Tester");

    //NOTE: to use await you will need to call args.Request.GetDeferral() then call Complete() on the deferral
    //Get the image file you want to share
    StorageFile imageFile = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFileAsync("test.png");

    var ranAccStreamRef = RandomAccessStreamReference.CreateFromFile(imageFile);

    //Set an image for the share target
    args.Request.Data.SetBitmap(ranAccStreamRef);
	
	//Set the thumbnail for the image (can set this to a different image if you have one)
    args.Request.Data.Properties.Thumbnail = ranAccStreamRef;

	//Some share targets prefer images as a StorageFile :S
    args.Request.Data.SetStorageItems(new List<StorageFile> { imageFile });

    //Set a link to share
    args.Request.Data.SetUri(new Uri("https://dkdevelopment.net/"));
}

This is what you get in the share charm

This is what we get sharing to Facebook

This is what we get sharing to Mail

If you're looking for more information about sharing checkout the MSDN Sharing content Quickstart or some of the other pages related to sharing.

WinJS SearchBox - Suggestions, results, focus!

2013-09-03T00:00:00+00:00

In Windows 8.1 there is less focus on the search charm for apps and more on "open the app and start typing". This is where the SearchBox control comes in, it makes it easier to add searching to your app by handling suggestions, results and focus. Both the XAML and WinJS stacks have this new control included but I'm going to be focusing on the WinJS version of it in this post.

At the moment there isn't a huge amount of info on the MSDN documentation for this control (WinJS.UI.SearchBox on MSDN). But it uses similar events to the search pane.

Here's a searchbox control

<div class="search"
    data-win-control="WinJS.UI.SearchBox"
    data-win-options="{
	chooseSuggestionOnEnter: false,
	focusOnKeyboardInput : true,
	placeholderText: 'start typing anywhere',
	searchHistoryContext: 'search',
	searchHistoryDisabled: false,
        onsuggestionsrequested: HubPage.searchBoxSuggestionsRequested }" />

A few interesting properties on that:

focusOnKeyboardInput: Automatically get focus when typing into the app window. This property gives the app the "just start typing" experience and seems to work pretty well.
NOTE: this will also take away focus from form controls!
searchHistoryDisabled: The SearchBox control will manage search history for you and show the previous search terms when the user focuses on the box.
searchHistoryContext: To give you a little more control over the search history this property allows you to set a secondary key to save the results against. This is helpful if you use more than one SearchBox control in your app and want to keep the history separate between the two.
onsuggestionsrequested: This is the even that fires when the user enters text in the box. This is where we can offer suggestions or results and the control will show a dropdown for the user.

function searchBoxSuggestionsRequested() {
    return util.markSupportedForProcessing(function (eventInfo) {
        //Do something with the search query to bring back suggestions
        var searchQuery = eventInfo.detail.queryText;
        var searchLanguage = eventInfo.detail.language;

        //Populate suggestions here
        eventInfo.detail.searchSuggestionCollection.appendQuerySuggestion("Swat at dog");
        eventInfo.detail.searchSuggestionCollection.appendQuerySuggestion("Stand in front of the computer screen");

        //or you can append an array of suggestions
        eventInfo.detail.searchSuggestionCollection.appendQuerySuggestions(["rub face on everything", "intrigued by the shower"]);

        //or you can append actual result data
        //NOTE: you must handle the resultsuggestionchosen event for selection of these results
        var imageUri = new Windows.Foundation.Uri("ms-appx:///images/cats/section1.png");
        var imageSource = Windows.Storage.Streams.RandomAccessStreamReference.createFromUri(imageUri);
        eventInfo.detail.searchSuggestionCollection.appendResultSuggestion("Cat page", "View all the cat page", "tag", imageSource, "image alt text");
    });
};

We can then use the onsuggestionsrequested event to add suggestions and/or results to the SearchBox. The above code shows the queryText and language are exposed as part of the eventInfo. It also allows suggestions to be added via the searchSuggestionCollection property using appendQuerySuggestion for adding single suggestions and appendQuerySuggestions for adding a list.

More detailed results can also be added to the suggestions list this is dont with the appendResultSuggestion function. This function takes a few more parameters, such as title, description, image and image alt text. But give a better result in the suggestions box (bottom item in the screenshot).

Sample code available Here on Gihub.

The Dropbox WinRT app that should have been

2013-06-16T00:00:00+00:00

Let me start off by saying that I am a big fan of Dropbox, I love its simplicity and their API is great to work with. But lately I have been thinking about switching to SkyDrive as the experience on Windows platforms are so much better. For me to be saying that is a pretty big deal as I use Dropbox for everything and have put so many hours into Dropbox related projects. However if they just put a bit more effort into the Windows RT app it would be very functional.

How do you even upload a file with the Windows RT app? The short answer is: You can't. The long answer is: using the file picker you can save files to Dropbox.

Here is an example for you. I take a screenshot on my Surface RT, it automatically gets saved to the Screenshots folder under the Pictures library. Now opening that with the built in Photos app there is no option to save. You can Share it but not to the Dropbox app. From there I can open it in a photo editing app, say "Enhance", make no change to the image and hit save as which will bring up the file picker where I can select Dropbox.

Have does Skydrive do this better? Simple, they have an upload button in the app that lets you select a file and uploads it to the folder you are currently viewing. SkyDrive also is a Share target so from the photos app you can invoke the share charm and select Skydrive from the list.

So I decided to dig into the Dropbox Windows Store app installed on my my PC to find it was WinJS and the code was not obfuscated or minified at all.
I fired up a new project and added in all the code from the Dropbox app, sweet it works! Then I started to implement an upload button and about an hour later I had a working upload button using the built in file picker and the same file upload function already in the app.

I added an appbar button to upload a file, easy. Then I couldn't see my quota info anywhere so I added it to the account flyout, though this would be much better suited in the top right corner with some user info (similar style to a lot of other apps, such as SkyDrive).

What to do now? For obvious reasons I wont be submitting this to the store nor will I be releasing the code online. However I would like to be able to submit it to Dropbox in the hopes of them updating their app.

I would also like to get your thoughts on the Dropbox app, maybe some other ways of improving it?

DropNet2 - async/await, WinRT and more!

2013-03-28T00:00:00+00:00

UPDATE: DropNet2 has now been renamed to DropNetRT, check out the DropNetRT documentation for more details

DropNet has been in NuGet now for 2 years! (As of March 31st). Which means its getting old and some of the methods and technologies it was built off are out of date.

Working on my own Windows Phone Dropbox client BoxShot I started running into some limitations of DropNet then finding that DropNet was actually being held back from by RestSharp. No offence to John Sheehan or any of the RestSharp contributers, they have built an excellent library which still use for numerous projects. However I wanted something more flexible and I wanted to use new technologies such as async/await and support for WinRT (ARM).

So it was time to rewrite DropNet from the ground up using not RestSharp but the new portable HTTP Client from Microsoft's Base Class Library which now supports Windows Phone (7.5+).

And here it is: DropNet2 (I'm not very good at naming things). Source is available on Github including a basic Windows Phone 8 sample project (login and folder contents functionality).

Fork

What different about it you say? Lets have a look at the code. I kept the API pretty similar to the original.

{
	var client = new DropNetClient("APIKEY", "APPSECRET");
	client.SetUserToken("TOKEN", "SECRET");

	var rootMetaData = await client.GetMetaData("/");
	var myFile = await client.GetFile("/MyFile.txt");
}

supported API functions

oauth/request_token
oauth/access_token
account/info
metadata
shares
search
media
files (GetFile and Upload)
fileops/delete
fileops/copy
fileops/move
fileops/create_folder
thumbnails
delta

platform support

.NET 4.5
.NET for Windows Store apps (WinRT)
Windows Phone 7.5 and higher
Silverlight 4 and higher

future plans

Implement remaining API functions
Progress feedback on upload and download functions
Better error handling
Support for Mono
Unit Tests

TFS Builds for Octopus Deploys

2012-07-15T00:00:00+00:00

I have been playing around with Octopus Deploy lately and I have setup our TFS build server to automatically create releases and deploy to a Dev environment.

Here is how you can setup a TFS build server to create NuGet packages ready for deployment through Octopus. Building off my previous post TFS to private NuGet.

Lets start with the build script:

<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets"/>

    <PropertyGroup>
        <VersionMajor>0</VersionMajor>
        <VersionMinor>8</VersionMinor>
        <VersionPatch>1</VersionPatch>
        <BuildOutputDirectory>C:\Builds\Temp\SiriuswareUtil</BuildOutputDirectory>
    </PropertyGroup>

    <Target Name="Build">
        <MSBuild Projects="SiriuswareUtil/SiriuswareUtil.csproj" Targets="Build"
			      Properties="Configuration=Release;WebProjectOutputDir=$(BuildOutputDirectory);" />
        <TfsVersion TfsLibraryLocation="C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0"
		    LocalPath="$(MSBuildProjectDirectory)..\">
			<Output TaskParameter="Changeset" PropertyName="ChangesetNumber"/>
        </TfsVersion>
        <Copy SourceFiles="$(BuildOutputDirectory)\SiriuswareUtil.nuspec" DestinationFolder="$(BuildOutputDirectory)" />
        <Exec Command='"C:\NuGet\NuGet.exe" pack "$(BuildOutputDirectory)\SiriuswareUtil.nuspec" -OutputDirectory "\\grp-dev02\f$\Websites\Ardent.NuGet\Packages"  -basePath "$(BuildOutputDirectory)" -Version "$(VersionMajor).$(VersionMinor).$(VersionPatch)$(ChangesetNumber)" -NoPackageAnalysis' />
        <Exec Command='"C:\Octopus\Octo.exe" create-release --server=http://octopus.ardentleisure.com/api --project=SiriuswareUtil --deployto=Dev --apikey=YOUR_KEY_HERE' />
	</Target>
</Project>

Now lets have a look at what each part does:

<PropertyGroup>
    <VersionMajor>0</VersionMajor>
    <VersionMinor>8</VersionMinor>
    <VersionPatch>1</VersionPatch>
    <BuildOutputDirectory>C:\Builds\Temp\SiriuswareUtil</BuildOutputDirectory>
</PropertyGroup>

The PropertyGroup element defines a few variables for later use. Starting at the top there are 3 properties for the version number, these let us set the version of the package (later on we also append the TFS changeset). The BuildOutputDirectory is a temporary path to build the project to so we can generate the NuGet package from the output.

<MSBuild Projects="SiriuswareUtil/SiriuswareUtil.csproj" Targets="Build"
	Properties="Configuration=Release;WebProjectOutputDir=$(BuildOutputDirectory);" />

Next we need to build the project, this part is pretty straight forward, set the path to the project file and the output directory. This project is a web project so I'm using the WebProjectOutputDir property on the build which publishs the project to the set path.

<TfsVersion TfsLibraryLocation="C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0"
	LocalPath="$(MSBuildProjectDirectory)..\">
	<Output TaskParameter="Changeset" PropertyName="ChangesetNumber"/>
</TfsVersion>

Now we want to check what the TFS changeset is so we can append it to the package version. For this we need the MSBuild Community Tasks with the import at the top of the build script. This function takes a few parameters such as the TFS binary location and outputs to a set variable (in this instance its "ChangesetNumber").

<Copy SourceFiles="$(BuildOutputDirectory)\SiriuswareUtil.nuspec" DestinationFolder="$(BuildOutputDirectory)" />

The next element ensures the nuspec file is copied to the output directory, instead of having to include it as content and it getting deployed to our servers.

<Exec Command='"C:\NuGet\NuGet.exe" pack "$(BuildOutputDirectory)\SiriuswareUtil.nuspec" -OutputDirectory "\\grp-dev02\f$\Websites\Ardent.NuGet\Packages"  -basePath "$(BuildOutputDirectory)" -Version "$(VersionMajor).$(VersionMinor).$(VersionPatch)$(ChangesetNumber)" -NoPackageAnalysis' />

Now we call the NuGet command line to create the package, pointing it at our nuspec file and setting to the output to where ever out nuget server is. This is where we also set the version of the package using our set properties and the tfs changeset number (-Version "$(VersionMajor).$(VersionMinor).$(VersionPatch)$(ChangesetNumber)").

<Exec Command='"C:\Octopus\Octo.exe" create-release --server=http://octopus.ardentleisure.com/api --project=SiriuswareUtil --deployto=Dev --apikey=YOUR_KEY_HERE' />

Lastly we want to use Octopus-Tools octo.exe to create a release in Octopus and schedule a deploy for our Dev environment. Octo.exe is a command line interface for the octopus server api, we just need to set a few variables for it to use such as the server address, project we want to create the release for and an API key that can be obtained through the web interface.

So the process for code changes is now:

Developer checks in code to TFS
CI Build server picks up code change fires off a build of the custom script
NuGet package is created in repo
New release is created and deployed to Dev environment via Octopus

And now I know exactly what code is running on all my servers and can easily deploy new versions.

YeahToast - WinJS Toast Library

2012-07-11T00:00:00+00:00

Windows 8 Toast notifications with WinJS isnt the easiest thing to do. First you have to figure out what template you want, then get the XML from the template manager, then modifying the XML with the image url, title and description. Then finally creating a toast notifier to parse the XML into a toast notification.

I wanted an easier solution to add Toasts to WinJS apps, something closer to the javascript alert function: alert("Message does here!"); So we started the YeahToast library, a WinJS library for easily adding toast notifications to Windows 8 applications.

YeahToast can automatically determine the template to use if you dont specifically set one, it does this based on the other options you give it. If there is an image set it will use a template with an image. If you set both text contents it will use a template with a 2 content lines. If you just set the title it will use the template with just the title.

Basic usage:

YeahToast.show({ title: "YEAHTOAST!" });
YeahToast.show({ title: "YEAHTOAST!", textContent: "message does here" });
YeahToast.show({ title: "YEAHTOAST!", textContent: "message does here", textContent2: "message line 2" });
YeahToast.show({ imgsrc: "images/placeholder.png", title: "This one has an image!", textContent: "something something" });

Options:

{
	template: , //Windows.UI.Notifications.ToastTemplateType to define the toast template if not set YeahToast will guess based on other parameters
	imgsrc: , //Image url to appear on toast
	title: , //The toasts header text
	textContent: , //Toast description line 1
	textContent2: , //Toast description line 2
}

Where to get it

PM> Install-Package YeahToast

Or download the js file directly from Github (https://github.com/Tboda/YeahToast/blob/master/lib/YeahToast.js)

What they look like:

The source for YeahToast is available on github to add the your project. There is also an example project to show basic usage.

Fork

Post JSON data to web services in Windows 8

2012-04-27T00:00:00+00:00

I have started working on a few metro style apps on Windows 8 using WinJS so I thought I might show some of my findings.

Using the WinJS.xhr function. (MSDN on WinJS.xhr)

Lets have a look at a basic basic example: (GET)

WinJS.xhr({ url: "http://example.com/api/test" });

This function takes an options object as a parameter. The url property is the only required option for this function, this sets the url for the request.

A more advanced example: (POST)

WinJS.xhr({
            type: "post",
            url: "http://example.com/api/test",
            headers: { "Content-type": "application/json" },
            data: JSON.stringify({ someProperty: "DK" })
        })

Looking at the example above we have set a few other options here:

type - this is the HTTP method used for the request (get, post, head, etc.)
data - this is the actual data I want to send through with the request
headers - this lets us set specific headers on the http request (NOTE: If your sending JSON make sure you set the content-type here!)

Now if we wanted to add handlers for success and error we can do this using the Promise.done method (MSDN on Promise.done)

WinJS.xhr({
            type: "post",
            url: "http://example.com/api/test",
            headers: { "Content-type": "application/json" },
            data: JSON.stringify({ someProperty: "DK" })
        }).done(onSuccess, onError, onProgress);

There you go, thats using WinJS to post JSON data to web services.

DroppedBoxx is now Open Source!

2012-02-21T00:00:00+00:00

Back in 2010 I started a project for uni called DroppedBoxx, it was a dropbox client for Windows Mobile 6.5.

This app got me starting to develop mobile apps and sparked my interest for working with web APIs (especially Dropbox as it spawned the DropNet library). It began as a free download during its beta period to get feedback for it while I was developing it for uni and later was sold for about $1 on various stores but it is no longer available and since I no longer have a Windows Mobile 6.5 device I lost interest.

No updates for almost a year :(

So I have now decided to open source it!

I have put the source up on Github for anyone to fork, as well as the latest .cab installer. https://github.com/dkarzon/DroppedBoxx

The source code is actually made up of a few different components.

I must give credit to Fluid .NET controls, DroppedBoxx has a slightly customised version of the library in it.

I should also give credit to RestSharp for which a lot of the http request handling was based off (modified to work with .NET Compact Framework)

Fork

JabbrPhone: It's like JabbR on your Phone

2012-01-23T00:00:00+00:00

I like development, working with new technologies and Windows Phone and over the past few weeks I have been working on a project that combines all of these. I call it JabbrPhone, its a Windows Phone client for Jabbr (the signalR based developer chat site).

So why did I want to make a phone app for JabbR? Well simply, for fun and to try something new that I haven't done before (in this instance its signalR).

For those who don't know what signalR is:

Async signaling library for .NET to help build real-time, multi-user interactive web applications.

It really is an awesome library. The JabbR project is also based on this and open sourced on Github which was great for me to get started.

The app isn't too far off at the moment, still a bit to do before its officially released. Current functionality:

Login/Create user (/nick)
List rooms
Join a room
send messages to a room (and get responses)
List users in a room

Things left to do:

Lobby functions
User Actions
Handle links in messages better
support for private rooms

The source is available on github: https://github.com/dkarzon/JabbrPhone

Or download the xap from here: http://bit.ly/zTsCpu

abSee 'ay be see' - A/B Test library

2011-12-13T00:00:00+00:00

I have often wondered “What if” when it comes design aspects of a website.

What if this button was green instead of blue?
What if I call it an upgrade instead of a purchase?
What if the background wasn’t as dark?
What if I make that notification flashing red instead of dark yellow?

You get the point…

So I’ve been working on an A/B testing library with the 1 goal of making it simple to insert tests into my web applications, thus abSee was born!

abSee is in NuGet so its pretty easy to install. (hurray!)

Its usage is simple enough also:

Firstly fire up an instance of the Tester, do so by calling the Start function. Or you could filter out certain users here to only show tests for them. (non-Admins etc.)

protected void Application_BeginRequest()
{
    ABTester.Start();
}

From there we can fire off tests to the User where ever we like by calling the Test function. Now to make a test we need to give it a name, this will be used to identify what we are testing in this specific instance. Then you give the function the different options and it will randomly select 1 for you as the output and save the result.

var output = ABTester.Test("MyTest1", "A", "B");

After running the test we then need to let the Tester know if it was successful or not so we can track conversions of the different options. We do this by calling the Convert function with the test name from the test we ran before. abSee will then store that result for us as converted.

ABTester.Convert("MyTest1");

So now we are running tests, how do I see the results?

You can get results for a given test using the GetResults function, this function returns a list of ABSeeResult which contains a few details about the test instance as well as the option that was selected and if it was converted or not.

var results = abSee.ABTester.GetResults("MyTest1");

More detailed documentation is coming soon with details on implementing custom storage and user identification.

Feel free to leave me some feedback about abSee or even fork it on Github.

BoxShot v2.0: Mango, Logo, Pictures hub and more

2011-11-23T00:00:00+00:00

So I got a fair bit of feedback from the old BoxShot logo and how most of my users disliked it (some even called it offensive). Now that Iâ€™ve had my fun I decided to put together a serious update for the app, here is what this new update (that I am calling v2.0) includes:

NEW LOGO!

As mentioned before I have changed the logo, this gives the app a more professional look and fits in much better with the Metro UI of Windows Phone. Hope you all like it.

Its now Mango...

This version is build for Mango so it takes advantage of fast app switching and general Mango goodness.

Picture Hub Integration

BoxShot now integrates into the Pictures Hub, so you can share your photos through BoxShot to your dropbox folder.

New Dropbox API

Dropbox have recently updated their API to be more secure. For a user this pretty much means the login process has changed, so now instead of giving the app the Email and Password you login to the dropbox mobile site and give permission to BoxShot.

Background Live Tile

The Live Tiles are now generated on the phone itself with a background agent, this makes them much more stable.

Referrals

BoxShot now lets you send out referral links to email or social networks so you can get that extra free space!

Others?

Some UI fixes (better following the metro style guide)
Few bug fixes (to do with ads and the tile colour picker)
Picture view now rotates and can pinch to zoom

Download it now from the Windows Phone Marketplace!

Ad-Free Version:

Free Version:

Future Versions

I'm always open to feedback about what new features users would like to see but heres a list of whats on the roadmap.

Pin Folders to start screen (maybe files as well)
Thumbnails for pictures
Fix bug when uploading files with international characters

Update:

All of the above features have now been implemented in v2.2 (Thumbnails and international characters fixed in v2.1)

From TFS to Private NuGet

2011-08-19T00:00:00+00:00

Let me start by saying this: I love NuGet, its straight up awesome!

This post is about how I created a TFS CI Build to create NuGet packages and push them to a private NuGet server hosted on site.

I have been playing around with the TFS Build server, mainly for a Continuous Integration (CI) build on some of our projects and I wanted a way for me to be able to update a core library and have it propagated to all of the projects that use that library without them all needing to be in the same solution.

The answer was a private NuGet server with a CI build that automatically packaged my library.

I started by setting up a private NuGet server, reading Phil Haack’s post about hosting a simple package feed. Once that was done I could start pumping out packages!

Now that I have my NuGet server I need to setup the build. I created an Ardent.CommonBuild.proj for my build config and tasks. I found its easier to manage as a separate file to the actual project file, this file has to be a .sln or .*proj file for the TFS Build server to be able to run it.

Now I also wanted to control the version numbers of the packages being pushed out (both manually and automatic). So I set a major and minor version property at the top.

<PropertyGroup>
    <VersionMajor>0</VersionMajor>
    <VersionMinor>1</VersionMinor>
</PropertyGroup>

I then wanted to include the TFS Changeset number as the 3rd part of the version. So I kicked off a TfsVersion task which outputs the changeset number of a specific path (Set this to the project root to get all changes).

<TfsVersion
  TfsLibraryLocation="C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0"
  LocalPath="$(MSBuildProjectDirectory)">
  <Output TaskParameter="Changeset" PropertyName="ChangesetNumber"/>
</TfsVersion>

From there I build the Project, normally the TFS build outputs the dlls to a binaries folder in the build output folder, but I decided to skip the nuspec file step but pointing NuGet at the project file directly. However you could create a nuspec file and point that to the built dlls, your choice. I also set the version number here for the build.

<MSBuild Projects="$(MSBuildProjectDirectory)\Ardent.Common\Ardent.Common.csproj"
    Targets="Build"
    Properties="Configuration=Debug;
      OutDir=$(MSBuildProjectDirectory)\Ardent.Common\Bin\Debug\;
    ApplicationVersion=$(VersionMajor).$(VersionMinor).$(ChangesetNumber)" />

So now we have built our project and we have the version we want so lets create the package. Using the Exec function I then run the NuGet.exe pack command on my project file using the –Version flag to set the version of the package. I also cheated a bit here by setting the –OutputDirectory flag and pointing that to the packages folder on the NuGet server I created. This will populate the feed now with the new package.

<Exec Command="C:\NuGet\NuGet.exe pack $(MSBuildProjectDirectory)\Ardent.Common\Ardent.Common.csproj -Version $(VersionMajor).$(VersionMinor).$(ChangesetNumber) -OutputDirectory \\grp-dev02\f$\Websites\Ardent.NuGet\Packages"></Exec>

The only thing left to do is create a TFS build definition under that points to my Ardent.CommonBuild.proj file in source control set the definition to CI mode. Done!

Now for every check-in to that project in TFS I get a new package created with the updated code then NuGet handles the updates in all of my other projects.

Life is good…

BoxShot gets a live tile!

2011-08-15T00:00:00+00:00

Following the recent release of my Windows Phone 7 app BoxShot, I have implemented a live tile displaying your dropbox.com quota info.

Boring old tile	Fancy new tile	Another fancy new tile

Also, you can customise the colour of the tile from the settings screen.

Thats pretty much it for now, be sure to leave feedback for any new features you want!

BoxShot – Its like Dropbox on your phone…

2011-07-23T00:00:00+00:00

BoxShot is a dropbox app for Windows Phone 7.

Features:

Open files from your Dropbox using their default apps (Office files, PDFs, etc.)
View/Edit text files within BoxShot with the built in editor
View Image files within BoxShot and save them to your library
Copy/Move files or folders within your dropbox folder
Delete files or folder from your Dropbox folder
Rename files or folders in your Dropbox folder
Email a public file link
View Account usage information

BoxShot also lets you add your frequently used folder to a favourites list which are displayed on the main Panorama.

Premium Version:

Free Version:

AppEvents - Do stuff when things happen (WP7)

2011-04-29T00:00:00+00:00

Ever wanted an easy way for apps to track certain events then run code based off what events the user has triggered? Well now you can with AppEvents!

So AppEvents is a Windows Phone 7 library to manage events for a user across multiple sessions. In this example I will use it with CodeTrack to prompt the user to rate the app after they have added 3 repos.

Lets get started, App.xaml.cs (this code can be put anywhere in the app but I felt this was better to be done at the start of the app)

public App()
{
    ...
    EventClient.New()
        .Add(RuleSet.When("rate-app",
            el =&gt; el.Any(e =&gt; e.Name == "addrepo" &amp;&amp; e.Occurrrences.Count &gt; 2))
            .Do(r =&gt; AskToRate())
        );
}

Now lets break that down, first we have the New() function being called, this creates the instance (and sets the Current singleton in the EventClient class). It also uses the default JsonEventStorageProvider to store the EventStore data, this can be overwritten with a type parameter on the new function:

EventClient.New&lt;MyCustomEventStoreage&gt;()

Now this is where the RuleSets are added to the client using RuleSet.When() The first parameter of this function is a name of the rule. This is mainly to keep track of the rule and make sure we don’t run it twice. The second parameter is a Func<UserEventList, bool> which means we can create lamba expressions to be run against the UserEventList object, this expression tells the RuleSet when it should fire its Do Action.

    .Add(RuleSet.When("rate-app",
        el =&gt; el.Any(e =&gt; e.Name == "addrepo" &amp;&amp; e.Occurrrences.Count &gt; 2))
        .Do(r =&gt; AskToRate())
    );

So where do I get it?

The last part to this is firing off the events this part is very simple.

    EventClient.Current.Fire("addrepo");

And thats pretty much it, the library then does the rest

The library also allows for manual checking of events if for instance you fire an event on a page but want the RuleSet to be executed on a different page. To do this we simply add a false optional parameter to the Fire method to stop it running the RuleSets with the event. We can also manually run rules, either singly by the RuleSet name or all the rules in the list. We can also set the EventClient to not save the EventStore using the provider each time (and just have it saved later for performance).

EventClient.Current.Fire("addrepo", false);
EventClient.Current.Fire("addrepo", false, false);
EventClient.Current.RunRule("rate-app");
EventClient.Current.RunRules();
EventClient.Current.SaveEventStore();

So where do I get it?

The project if on GitHub for your forking, issues and discussions.AppEvents on Github.

Windows Mobile 6: Legacy

I have also made a Windows Mobile 6 version of this library but haven't actively tested it too much, if you feel like giving it a go be sure to let me know how you go.

Dropbox on Windows Phone 7 with DropNet

2011-04-01T00:00:00+00:00

So I have been working on an open source Dropbox client library for a while now called DropNet. I have recently put this project into NuGet so its super easy to add Dropbox support to your Windows Phone 7 apps.

Update: The source for this sample project is available here: https://github.com/dkarzon/DropNet/tree/master/DropNet.Samples/DropNet.Samples.WP7

Update: The DropNet and DropNet-WP NuGet packages have been merged and allow for both Project Types.

I’ll start with a File -> New Project, creating a sample Windows Phone Application.

First thing to do is install the DropNet package, NuGet will automatically detect the type of project you are using and add the DropNet reference for that project type (eg. DropNet.WindowsPhone for Windows Phone 7 projects.)

Ok, now we can start with the App, for starters I created a global variable for my DropNetClient instance.

GlobalClient = new DropNetClient("API KEY", "API SECRET");

Now from that we will need to let the user login so my main page has a basic login form, 2 textboxes for Email and Password and a button to make it work.

private void Login_Click(object sender, RoutedEventArgs e)
{
    //try login
    App.GlobalClient.LoginAsync(_model.Email, _model.Password,
        (response) =&gt;
        {
            if (response.Data != null)
            {
                //DropNet automatically sets the result token inside the client
                NavigationService.Navigate(new Uri("/FilesPage.xaml", UriKind.Relative));
            }
        });
}

DropNets Login function automatically saves the user Token and Secret to its client instance so we dont have to set it. Then I just navigate to a new page where we will attempt to browse our Dropbox Folder.

This page has a basic view model with 1 property for the folders content.

private ObservableCollection&lt;MetaData&gt; _contents;
public ObservableCollection&lt;MetaData&gt; Contents
{
    get { return _contents; }
    set
    {
        _contents = value;
        NotifyPropertyChanged("Contents");
    }
}

Pretty easy, the page itself simply binds this collection to a listbox displaying the Name and an icon if its a folder.

Ok, now to actually get the data from Dropbox… We do this by calling our DropNetClient’s GetMetaDataAsync method. This method takes a path parameter so we can tell it which folder to get the metadata for.

App.GlobalClient.GetMetaDataAsync("/",
    (response) =&gt;
    {
        foreach (var c in response.Data.Contents.OrderBy(f =&gt; f.Name).OrderByDescending(f =&gt; f.Is_Dir))
        {
            _model.Contents.Add(c);
        }
    });

After getting the MetaData I then order it, folders first then alphabetically.

Wait, really? Thats it?

Yep! Thats my Dropbox folder.

Now to make it even better we can handle the listbox’s selection change event and if the selected item was a folder we can show its contents.

private void ListBox_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
    if (e.AddedItems.Count > 0)
    {
        var selected = (e.AddedItems[0] as MetaData);

        //if its a folder browse to it
        if (selected.Is_Dir)
        {
            _model.Contents = new ObservableCollection&lt;MetaData&gt;();
            App.GlobalClient.GetMetaDataAsync(selected.Path,
            (response) =&gt;
            {
                foreach (var c in response.Data.Contents.OrderBy(f =&gt; f.Name).OrderByDescending(f =&gt; f.Is_Dir))
                {
                    _model.Contents.Add(c);
                }
            });
        }
    }
}

There we go, thats the basis for a Dropbox app using DropNet, lets see what we can come up with!

DropNet Implements most of the API’s functions, including :

Uploading files
Downloading files
Creating folders
Creating an account
Getting account info
Deleting files/folders
Data usage counter

I’m always updating the project over at GitHub, drop by and let me know what you think or if you have any feature requests/bugs. GitHub Project.

Or check out the NuGet Package here.

DroppedBoxx v1.1 – Dropbox for Windows Mobile

2010-06-03T00:00:00+00:00

Update: I have now released DroppedBoxx as Open Source, the source and a downloadable cab are now available over at Github (https://github.com/dkarzon/DroppedBoxx)

I have been developing a Dropbox Client for Windows Mobile called DroppedBoxx and I thought I'd take some time to talk about how it works, my plans for its future and talk about some of the new features of the latest version v1.1 which has now been released to the Windows Phone Marketplace.

Firstly, the new features in v1.1 include: (Full Changelog)

Two-way Syncing of selected folders
Updated UI (Labeled buttons, Background Uploading, Sync Folders screen is updated so you know when its syncing)
Bug fixes for the Attach to Email and errors caused by loss of connection
Added settings for camera resolution

Login:

This screen is where the User Logs in user their dropbox account. Login button trys to login, keyboard button shows the Windows Mobile SIP keyboard. Exit button exits the app. Remember me saves your login details so next time you run the app your automatically logged in.

Sync Folders/Home Screen:

This is pretty much the Home screen for the application. From here you can add folders for Syncing by clicking New and browsing the phones file system and selecting a Folder to add. The Logout button on the top right obviously logs you out returning to the login screen.

The 5 Buttons down the bottom:

The Sync button starts the â€œSyncâ€ process syncing the folders in the list to your dropbox account into a folder called â€œDroppedboxxâ€ (Note: this feature is unavailable in the Beta versions, more on that later)
The Dropbox Button opens up the root folder of dropbox for you to browse.
The settings button opens the settings screen where you can change app settings (such as Clearing saved login, max file sizes and camera resolution.
The Info button is to show the dropbox User info, including quota and usage but also DroppedBoxx version information and data used by this DroppedBoxx session.
The Exit button closes the app.

Browse Dropbox:

This is where most of the functionality is, from this screen we can upload, download, delete, etc. files from Dropbox. Starting at the top, the Back Button takes you â€œupâ€ a directory in the Dropbox file system or, if your in the dropbox root, takes you back to the Home Screen. The Upload button lets you browse the phones file system and select a file to upload.

Here you have a list of Files and folders that are in the current folder on Dropbox selecting a folder opens up that folder.

The bottom button panel:

The Camera button opens up the Windows Mobile camera application and when you take a photo it uploads it to the folder you are currently in in the Dropbox browser.
The new folder button simply creates a new folder in the current folder, opening up a dialog to enter the Name.
The Delete folder button Deletes the current folder your in (asking for confirmation first)
The Paste button is for moving/copying files, if you have a file in the â€œclipboardâ€ pressing this button will ask if you want to copy or move the file to this folder. (More info in file menu)
The Back Button goes back to the sync folders screen (The Back button on the top left goes up a directory or back to sync folders if your in the dropbox root)

The File Menu:

This is the menu that comes up after selecting a dropbox file.

Save Button Downloads the selected file (opening a file system browser to set the download folder)
Email button, downloads the file to a temp folder and attaches it to a New email message in Pocket Outlook (assuming this is set up it firsts asks you to select the account)
The Copy button puts the selected file in the â€œclipboardâ€ so you can paste it somewhere else in the dropbox file system (giving you options to Copy or Move the file)
The bin button deletes the selected file (asking for confirmation first)
The â€“Menu button simply closes the file menu (to allow access to the Folder menu again)

Settings:

Here you can change the Settings of the application such as clearing saved login details, setting a max filesize for sycning and setting the camera resolution for camera uploads.

Information:

This screen displays application and user info. It shows the DroppedBoxx version number and data sent and received by the application for this session. As well as the users dropbox quota information.

DroppedBoxx can be downloaded from the Windows Phone Marketplace.

Also you can follow the discussion about this app by going to the thread on XDA.

Dropbox API, RestSharp and C# Part 2: The Revenge!

2010-05-25T00:00:00+00:00

Following on from my previous post where I showed you how to Login and get the Account Info for a Dropbox account. Today we dive into the Box full of files. Uploading, Downloading and Deleting!

A lot has changed since my last post in the way of RestSharp with OAuth. OAuth is now available Out-of-the-box (this can be downloaded from Github). Ok, Time for some code…

Download File:

Update: Fixed a bug in the code that only allowed for text based files to be downloaded. Using restClient.DownloadData now instead of Execute to get the response’s raw Data.

public byte[] DownloadFile(string path)
{
    var restClient = new RestClient("http://api-content.dropbox.com");
    //load the JsonDeserializer for all types
    restClient.ClearHandlers();
    restClient.AddHandler("*", new JsonDeserializer());
    if (!path.StartsWith("/")) path = "/" + path;

    restClient.Authenticator = new OAuthAuthenticator(restClient.BaseUrl, _apiKey, _appsecret, _userLogin.Token, _userLogin.Secret);

    var request = new RestRequest(Method.GET);
    request.Resource = "{version}/files/dropbox{path}";
    request.AddParameter("version", _version, ParameterType.UrlSegment);
    request.AddParameter("path", path, ParameterType.UrlSegment);

    var responseData = restClient.DownloadData(request);

    return responseData;
}

Note: This is assuming the user has already logged in and we have the token/secret (_userLogin).

Starting from the top, we create a new Instance of the RestSharp Client with the baseUrl then set the Json Deserializer for all requests. We then set the RestClient’s Authenticator to the OAuthAuthenticator and give it our baseUrl, all our secrets and that is all we need to do for OAuth (the rest is build into RestSharp, awesome?!). Now we create the Request up, its a GET method, set the version and path of the file to download call Execute and you have just downloaded your first Dropbox API file! I then converted this to a stream so save back to a local file.

Delete File:

public bool DeleteFile(string path)
{
    var restClient = new RestClient("http://api.dropbox.com");
    //load the JsonDeserializer for all types
    restClient.ClearHandlers();
    restClient.AddHandler("*", new JsonDeserializer());

    if (!path.StartsWith("/")) path = "/" + path;

    restClient.Authenticator = new OAuthAuthenticator(_restClient.BaseUrl, _apiKey, _appsecret, _userLogin.Token, _userLogin.Secret);

    var request = new RestRequest(Method.GET);
    request.Resource = "{version}/fileops/delete";
    request.AddParameter("version", _version, ParameterType.UrlSegment);

    request.AddParameter("path", path);
    request.AddParameter("root", "dropbox");

    var response = restClient.Execute(request);

    return response.StatusCode == System.Net.HttpStatusCode.OK;
}

Delete is pretty similar to Download, only differences is the Url, the response and this time the path is sent as a parameter instead of part of the Url. The “root” parameter is for applications that only have sandbox access (they would set this to sandbox) who only get access to a “sandbox” folder on the users dropbox account.

Upload File:

Now this is where I had the most difficulties, many “Forbidden” messages later I finally came up with the solution!

public bool UploadFile(string path, FileInfo localFile)
{
    var restClient = new RestClient("http://api-content.dropbox.com");
    //load the JsonDeserializer for all types
    restClient.ClearHandlers();
    restClient.AddHandler("*", new JsonDeserializer());

    if (!path.StartsWith("/")) path = "/" + path;

    //Get the file stream
    byte[] bytes = null;
    FileStream fs = new FileStream(localFile.FullName, FileMode.Open, FileAccess.Read);
    BinaryReader br = new BinaryReader(fs);
    long numBytes = localFile.Length;
    bytes = br.ReadBytes((int)numBytes);

    restClient.Authenticator = new OAuthAuthenticator(_restClient.BaseUrl, _apiKey, _appsecret, _userLogin.Token, _userLogin.Secret);

    var request = new RestRequest(Method.POST);
    request.Resource = "{version}/files/dropbox{path}";
    request.AddParameter("version", _version, ParameterType.UrlSegment);
    request.AddParameter("path", path, ParameterType.UrlSegment);
    //Need to add the "file" parameter with the file name
    request.AddParameter("file", localFile.Name);

    request.AddFile(new FileParameter { Data = bytes, FileName = localFile.Name, ParameterName = "file" });

    var response = restClient.Execute(request);

    return response.StatusCode == System.Net.HttpStatusCode.OK;
}

Ok to start with the “path” variable/parameter is the folder path (not the file).

Starts off the same with the RestClient, JsonDeserializer and the OAuthAuthenticator. We also need to read the file as a byte array. Now this request is a POST so we set that in the RestRequest object then add the version and path Url parameters. We also need to add the Filename as a “file” parameter for this request as well as adding the actual file to the Request. Execute that and: {\"result\": \"winner!\"} we just uploaded a file to dropbox!

This code was taken from my Dropbox open source .NET project called DropNet.

Dropbox API and RestSharp for a C# developer

2010-05-18T00:00:00+00:00

Update: The code in this post is out dated and the version of the API is no longer supported. To use the Dropbox API have a look at my open source projects DropNetRT or DropNet.

The Dropbox API has foiled my development of “Droppedboxx” for some time now. Mainly because the on site documentation is average for anyone not planning on developing for the iphone (dropbox, you used to be cool). Being a C# developer this was bad news for me but I decided to give it a go anyway and after a few weeks of failed attempts and a few emails to support about my issues I realised the API documentation on the dropbox website is slightly wrong.

So now that I have it working I thought i’d share this with my fellow .NET developers (and anyone else who will care to listen).

What you will need (What i used):

RestSharp (What would i do without you…)
Oauth Library for C# (this one seems the easiest to use with RestSharp)
Access to the Dropbox API and an APIKey/Secret for your app

I guess I should start with the Setup of it, I started this as a Windows Mobile application but I switched to a .NET library so I could test it easier and also use RestSharp (might open source the library if I get around to it).

Login, this is possibly the easiest method if you have the right URL (the API documentation give you the wrong URL). We should be using “https://api.getdropbox.com/0/token” Code you say?

Update: Got some helpful advice about using the request.Resource property with parameters instead of a string.format.

public UserLogin Login(string email, string password)
{
    var restClient = new RestClient("https://api.getdropbox.com");
    var request = new RestRequest(Method.GET);
    request.Resource = "{version}/token";
    request.AddParameter("version", _version, ParameterType.UrlSegment);

    request.AddParameter("oauth_consumer_key", _apiKey);

    request.AddParameter("email", email);
    request.AddParameter("password", password);

    var response = restClient.Execute<UserLogin>(request);

    _userLogin = response.Data;

    return response.Data;
}

Seems pretty easy right? Most of thats RestSharp (with the JSONDeserializer), I then have the UserLogin class which is returned by this function.

public class UserLogin
{
    public string Token { get; set; }
    public string Secret { get; set; }
}

And now your user is logged in, you will then want to store the Users Token and Secret (storing UserLogin object would probably be better) as its used for the rest of the requests. I’ll just show you how to get the User Info as the other requests differ from the login (that is where we’ll need the Oauth stuff).

Account/Info, I’ll start with the Response classes this time…

public class AccountInfo
{
    public string Country { get; set; }
    public string Display_Name { get; set; }
    public QuotaInfo Quota_Info { get; set; }
    public string Uid { get; set; }
}

public class QuotaInfo
{
    public string Shared { get; set; }
    public string Quota { get; set; }
    public string Normal { get; set; }
}

These are the classes for RestSharp to Deserialize the JSON to. Pretty simple, this is straight off the API Documentation site. Now for the actual request…

public AccountInfo Account_Info()
{
    var restClient = new RestClient("http://api.dropbox.com");
    OAuthBase oAuth = new OAuthBase();
    string nonce = oAuth.GenerateNonce();
    string timeStamp = oAuth.GenerateTimeStamp();
    string normalizedUrl;
    string normalizedRequestParameters;
    string sig = oAuth.GenerateSignature(new Uri(string.Format("{0}/{1}/account/info", restClient.BaseUrl, _version)),
        _apiKey, _appsecret,
        _userLogin.Token, _userLogin.Secret,
        "GET", timeStamp, nonce, out normalizedUrl, out normalizedRequestParameters);
    sig = HttpUtility.UrlEncode(sig);

    var request = new RestRequest(Method.GET);
    request.Resource = string.Format("{0}/account/info", _version);
    request.AddParameter("oauth_consumer_key", _apiKey);
    request.AddParameter("oauth_token", _userLogin.Token);
    request.AddParameter("oauth_nonce", nonce);
    request.AddParameter("oauth_timestamp", timeStamp);
    request.AddParameter("oauth_signature_method", "HMAC-SHA1");
    request.AddParameter("oauth_version", "1.0");
    request.AddParameter("oauth_signature", sig);

    var response = restClient.Execute<AccountInfo>(request);

    return response.Data;
}

Now, this request has a different Base Url to the Login function and this uses OAuth. So firstly we create an instance of the RestSharp client and the OAutheBase classes. The OAuthBase class then handles all of the oauth parameters that we need to make the Request (nonce, timestamp, etc.). GenerateSignature is the main 1 that rolls up the request path and the tokens/secrets into a hash for extra security. As for the dropbox part of this, we dont need any extra parameters as we are just getting the logged in users Account Info. Then its just a matter of adding these parameters to the RestRequest object, notice the oauth_token is actually the UserLogin.Token that we got from our Login method?

Stay tuned for more, Tales of interest!

Update: I have added a Part 2 to this post.

Parallel vs. Async Email performance

2010-04-23T00:00:00+00:00

Lately i have been doing some work with sending emails and I have chosen to use some of .NET4.0’s Parallel processing and the FluentEmail library.

I then got thinking about the Performance differences between using Parallel against Asynchronous so I decided to run some tests. Based of the C# Micro Performance Testing Class blog post I have written a simple app for testing this.

Firstly I created my base class for the performance tests, this will later be inherited by by different testers.

Pretty basic, methods to start and finish that set the stopwatch and the finished bool…

public abstract class PerformanceTester
{
    public TimeSpan TotalTime { get; private set; }
    public TimeSpan AverageTime { get; private set; }
    private Stopwatch _stopwatch;
    public int Iterations { get; private set; }
    public bool Finished { get; private set; }

    public PerformanceTester()
    {
        Finished = false;
    }
    public virtual void Run(int iterations)
    {
        Iterations = iterations;
        _stopwatch = Stopwatch.StartNew();
    }
    public void Finish()
    {
        _stopwatch.Stop();
        AverageTime = new TimeSpan(_stopwatch.Elapsed.Ticks / Iterations);
        TotalTime = _stopwatch.Elapsed;
        Finished = true;
    }
}

Now that we have the stone to build off we can create the classes for the tests we went to perform, in this case 1 for Async and 1 for Parallel (below) these 2 classes then just override the Run method and call Finish when its done. However the async class differs slightly as it has to wait for the async callback.

public class ParallelEmails : PerformanceTester
{
    public override void Run(int iterations)
    {
        base.Run(iterations);
        //do stuff here
        Parallel.For(0, iterations, i =&gt;
            {
                //send emails
                Email.From(Settings.FromAddress)
                    .To(Settings.ToAddress)
                    .Subject(Settings.Subject + "P" + i)
                    .Body(Settings.Body)
                    .UsingClient(new SmtpClient(Settings.HostAddress))
                    .Send();
            });
        //all done
        base.Finish();
    }
}
public class AsyncEmails : PerformanceTester
{
    private int _currentIteration;

    public override void Run(int iterations)
    {
        base.Run(iterations);
        //do stuff here
        for (int i = 0; i &lt; iterations; i++)
        {
            Email.From(Settings.FromAddress)
                        .To(Settings.ToAddress)
                        .Subject(Settings.Subject + "A" + i)
                        .Body(Settings.Body)
                        .UsingClient(new SmtpClient(Settings.HostAddress))
                        .SendAsync(emailCallback);
        }
    }
    private void emailCallback(object sender, EventArgs e)
    {
        _currentIteration = _currentIteration + 1;
        if (_currentIteration == Iterations) Finish();
    }
}

Now for some results, now I know the performance will differ depending on PC hardware so I'm testing this on 2 different PCs the first has a Core 2 Duo E6400 @ 2.13GHz and the 2nd has a Core 2 Quad Q6600 @ 2.4GHz.

Table represents my results of the tests (in milliseconds)

Emails Sent	Parallel (Dual Core)	Parallel (Quad Core)	Async (Dual Core)	Async (Quad Core)
1	6019	5716	6107	7039
8	26642	39571	34291	25638
15	59282	46897	58849	47730
20	70977	67488	62120	79164

Just a note, these tests were run from the 2 PCs on the same network with the same internet connection connecting to gmails smtp server. Of course there are other factors that would affect performance of these 2 methods but this is just to get an idea of the differences.

Read into that as much as you want but the main thing i got from it is parallel processing is better when you have more cores (which isn't really anything new at all). Good to see the difference in results though.

DK out…

Fluid.NET controls for Windows Mobile 6

2010-04-20T00:00:00+00:00

Lately I have been making an application for Windows mobile but I am pretty bad with design so I was looking for a control toolkit and came across the Fluid.NET controls, which is an open source control toolkit for Windows Mobile. Now there wasn't too much documentation on the site and it hadn't been updated for a while but they had a pretty decent looking example application which they offered the source for.

I based my project off their example, took me a while to figure out how to use some of their controls but now i have a bit more of an idea and i thought I'd share it.

Basically I'm trying to use the Fluid.NET listbox control to display the file system (so i can select a folder).

I started by using the ListBoxBase class from PasswordSafe, this class handles the general list type stuff, like changing the colour of selected list items etc.

Then I created a new Fluid Template this is the class used by the ListBox to populate the items in the list. Item layout goes in the InitControl() method then the actual content of the Item (In my case its based off a DirectoryInfo object) goes in the OnBindValue() method.

public class AddFolderTemplate : FluidTemplate
{
    private FluidLabel nameLabel;
    private FluidLabel secondaryLabel;

    protected override void InitControl()
    {
        base.InitControl();
        this.Bounds = new Rectangle(0, 0, 240, 64);
        nameLabel = new FluidLabel("", 3, 0, 228, 64 - 3);
        Controls.Add(l);
        secondaryLabel = new FluidLabel("", 8, 62 - 12, 224, 12);
        Controls.Add(l);
    }
    protected override void OnBindValue(object value)
    {
        var folder = value as DirectoryInfo;
        if (folder != null)
        {
            nameLabel.Text = folder.Name;
            secondaryLabel.Text = folder.FullName;
        }
    }
}

After I had the Template done I then created my listbox class (inheriting from the ListBoxBase) This class didnt need to do too much as most of the work is done in its base and the panel it goes in.

public class AddFolderListBox : ListBoxBase
{
    private NotifyList folders;
    public event EventHandler FolderSelected;

    protected override void InitControl()
    {
        base.InitControl();
        ItemHeight = 32;

        ItemTemplate = new AddFolderTemplate();
    }
    public NotifyList Folders
    {
        get { return folders; }
        set
        {
            if (folders != value)
            {
                folders = value;
                DataSource = value;
            }
        }
    }
    ...
}

Now that we’ve got the classes done, time to put them to use. I have created a panel for browsing through the file system. All we need to do here is create an instance of our Listbox control and add a list of folders to the Folders Property.

Controls.Add(lsbFolders);
CurrentDir = new DirectoryInfo("/");
lsbFolders.Folders = MakeDirList(CurrentDir.GetDirectories());

This then loads all the folders in the devices root into the listbox. I have also added to the OnItemClick event to go deeper into the file system and a back button to go back to the parent directory.

DK Development

The Rise of the Engineering Agent Manager

From Producer to Director

Architecture, Strategy, Vision: Now the Whole Job

Controlling Agents Through Context

Linear and the Agent-Friendly Backlog

The Review Layer Is the New Craft

The Leaders Who Are Struggling

Getting Started

Using Schema.org structured data to improve SEO

Why Use Structured Data?

How to Implement Structured Data

Which Format Should You Use?

Popular Schema Types

AI Agents and Structured Data

Testing Your Structured Data

A Real-World Blog Example

Recap

Further Reading

My Home Assistant Docker Compose file

Commons

home-assistant

postgres

nodered

mosquitto

tasmoadmin

chrony

influxdb

grafana

Bonus Content!

Basic remote PC monitoring through Home Assistant

Google Lighthouse CI Server Automation

Dockerfile

package.json

lighthouserc.json

Tips and tricks for Github Pages

Docker

For each loops

Combine and Minify CSS

Data files

Syntax Highlighting

Getting started with Singer and Docker

Working Remotely (and how)

Distractions

Cabin fever

Isolation

Work-life balance

Environment

Tools

Building a Discord voice bot with Discord.NET

Responsive xaml properties in Xamarin.Forms

Markup extension

Usage

Handling image paths in Xamarin.Forms on UWP

The solution?

What's the deal with cordova on WP

Converting ANID (WP7) to ANID2 (WP8)

Windows 8 sharing the right way

This is what you get in the share charm

This is what we get sharing to Facebook

This is what we get sharing to Mail

WinJS SearchBox - Suggestions, results, focus!

The Dropbox WinRT app that should have been

DropNet2 - async/await, WinRT and more!

supported API functions

platform support

future plans

TFS Builds for Octopus Deploys

YeahToast - WinJS Toast Library

Basic usage:

Options:

Where to get it

What they look like:

Post JSON data to web services in Windows 8

Lets have a look at a basic basic example: (GET)

A more advanced example: (POST)

Looking at the example above we have set a few other options here:

There you go, thats using WinJS to post JSON data to web services.

DroppedBoxx is now Open Source!

JabbrPhone: It's like JabbR on your Phone