This makes Flashlight 7 the only app on the market to support constant LED light under the lock screen as well as probably the most feature rich and handy app available.

So grab the update now, what ever language you may have set your phone to:

• In English: Flashlight 7
• In French: Lampe de Poche 7
• In German: Taschenlampe 7
• In Spanish: Linterna 7
• In Italian: Torcia Elettrica 7
• In Portuguese: Lanterna 7
• In Chinese: 闪光灯7
• In Czech: Svítilna 7
• In Danish: Lommelygte 7
• In Dutch: Zaklamp 7
• In Finnish: Taskulamppu 7
• In Greek: Φακός 7
• In Hungarian: Zseblámpa 7
• In Japanese: 懐中電灯7
• In Korean: 플래쉬라이트 7
• In Norwegian: Lommelykt 7
• In Polish: Latarka 7
• In Russian: Фонарик 7
• In Swedish: Ficklampa 7

And here’s a screenshot of the LED:

Enjoy!

And finally some pictures: the app running on a Samsung Omnia 7 and some screenshots of the application. Hope you enjoy the app, grab it from the Marketplace here, it’s free!

Main features of the application are:

• Find bus stops based on your location, by service number or by bus stop codes
• Mark stops as favorites and access them with a simple swipe on the main screen
• Acess the most recently viewed stops from the main screen
• Get automatic Lothian bus service alerts
• … all designed to blend perfectly with your Windows Phone with beautiful Metro design

(A note as to why I chose this name versus Edinburgh Bus Tracker or EdinBus: should you not pin the app to the start page it’s somewhat a drag to scroll all the way down to “E” to start the app. Changing the name to start with “B” seemed to put it at my fingertips in the long list app selector as well).

For more information and screenshots, visit the Bus Tracker Edinburgh home page.

If you’re an Edinburgh resident I hope you’ll find it useful on your everyday commute. (And if the lack of this application was stopping you getting a WP7 you can now reconsider it ) Enjoy!

I originally created the control so that I could dynamically configure ads appearing on Flashlight 7 based on ad culture. In the US I normally prefer using PubCenter as it usually has the highest eCPM, outside of the US I would switch between other providers (AdMob, InnerActive and AdDuplex for promoting of the app). The main reason for changing the ratios of ad providers was that I wanted to experiment how showing more AdDuplex ads impacts downloads of the app – with this little tool I can do so when eCPM has gone somewhat down (Note: I’ve actually found AdDuplex have a positive effect on app downloads and use it despite higher eCPMs as well).

The control allows setting up of ad probabilites based on culture, so its possible to configure (and update) such a configuration as this:

• US: 80% PubCenter, 10% InnerActive, 5% AdMob, 5% AdDuplex ads
• Germany: 80% AdMob, 10% PubCenter, 10% AdDuplex
• France: 100% AdMob
• Other: 25% PubCenter, 25% InnerActive, 25% AdMob, 25% AdDuplex

Read the project description and the WP7 ad rotator documentation on more details on how to integrate the control into projects.

Hope you find this tool useful!

• 18 May, Wednesday, Newcastle at NEBytes
• 24 May, Tuesday, London, Fulham at Tech.Days 2011

Some useful resources to get started with:

• Jeff Wilcox’s Metro Design Guide – an excellent, hands on design guide from the creator of the highly rated 4th and Mayor WP7 application
• Metro in Motion Effects by Colin Eberhardt- examples of creating animations that “feel” Metro
• Conceptual ‘Metro’ Application – USGA Golf, created by Microsoft

Slides of the talk:

The most important things we’ve added this update are the following:

• Valentine’s day cocktails – nearly 30 delicious, themed drinks are added to the application in the Valentine’s package
• Packages can be deactivated and activated. This means if you’ve downloaded one of the holiday packages, but aren’t interested in those cocktails during the summer, simply deactivate the package to hide its contents.
• Extended cabinet – we’ve added a few drinks to the cabinet and from now on the cabinet is dynamically growing based on ingredients in packages.
• Search by ingredients – simply start typing the name of an ingredient in the search field and cocktails containing ingredients with that name are also returned.
• Smarter cabinet – if you select dark rum, lime juice and coke in the cabinet, you’ll see that Cuba Libre is suggested as a cocktail that can be mixed, even though the official recipe suggests using white rum, not dark. However, we’ve introduced substitute ingredients, and in the case of Cuba Libre, both white rum and dark rum can be used to mix this drink.

And finally, here are a few screenshots of some of the new cocktails and new features:

Valentine’s Day package and the ability to deactivate (and activate) packages

Search now looks at cocktail ingredients, not just names

The structure of the article is as follows:

• Define data structures for storing and defining interfaces for fetching live and historical data.
• Implement fetching stock data using Google Finance
• Visualize fetched stock data using Visiblox Charts for Silverlight

Read the full article and download the source code on Codeproject: Visualizing Live and Historic Stock Data Using Silverlight

So here’s a summary of what’s new:

• We’ve added support for cocktail packages - these can be downloaded within the application for more cocktails.
• We’ve released a Christmas and New Years package with over 50 new, holiday themed cocktail recipes
• Cocktails can be browsed by color as well and we’ve added brandy and champagne to the base drinks category
• New settings: the lock screen can be configured not to turn the application off and the currency can be changed in the shopping assistant

Of course the updates don’t stop with this; new cocktail packages planned to be released continuously. Should you miss some recipes, just send your suggestion on Twitter @cocktailflow.

Here are some screenshots of some of the new, holiday cocktails, the packages and the new start screen. Enjoy and Happy Holidays!

This can be fustrating when querying against RSS feeds or JSON/XML web APIs that don’t define any of these files. The workaround for this issue is to use some sort of proxying service. In this article I’ll be showing how to use Google App Engine to create a simple proxy that will forward these requests for free – within a reasonable daily load.

Google App Engine Overview

The reason I’ve chose to implement the proxy using Google App Engine is because it has a free daily quota and getting started using it is really simple: all you need is a Google account and to download and install the Google App Engine SDK.

Google App Engine supports developing in both Java and Python. In my example I’ll be using Python. In order to use and deploy the code yourself as well, follow these steps:

• If you don’t yet have a Google account, register for one.
• Download and install Python from python.org
• Download and install the Google App Engine Python SDK
• Register an application on Google App Engine (click on Create Application). When done, run the Google App Engine Launcher and create an application with the same name you’ve just created.

Creating the Proxy In Python

Creating a simple proxy is pretty straightforward by using the urlfetch library:

try:
	response = urlfetch.fetch(url)
except (urlfetch.Error, apiproxy_errors.Error):
	# an error occured

In order to make the proxy a bit smarter, I’ll implement some caching using the App Engine’s memcache:

proxiedContent = memcache.get(memcacheKey)
proxiedContentInMemcache = True
if proxiedContent is None:
   # not in memcache: execute request
   # ...
   # add the result content to memcache for CACHE_TIME minutes
   memcache.add(memcacheKey,proxiedContent,CACHE_TIME)
else:
   # use the content from memcache

Using these snipplets, here’s how the main file of the proxy webapp will look like:

import datetime
import hashlib
import logging
import pickle
import urllib
import re
import time
import urllib
import wsgiref.handlers
 
from google.appengine.api import memcache
from google.appengine.api import urlfetch
from google.appengine.ext import db
from google.appengine.ext import webapp
from google.appengine.ext.webapp import template
from google.appengine.runtime import apiproxy_errors
 
CACHE_TIME = 1 # number of minutes to cache content for
 
URL_PREFIXES = ["http://www.google.com/finance"] # only allow URLs to be queried from certain domain(s)
 
def getMemcacheKey(url):
  url_hash = hashlib.sha256()
  url_hash.update(url)
  return "hash_" + url_hash.hexdigest()
 
class ProxyHandler(webapp.RequestHandler):
  def get(self):
    url = self.request.get('url')
    url = urllib.unquote(url)
    # only allow urls that start with prefixes defined in URL_PREFIXES to be used
    if not self.isUrlAllowed(url):
      self.response.out.write("The URL passed can not be proxied due to security reasons.")
      return
    memcacheKey = getMemcacheKey(url) 
 
    # Use memcache to store the request for CACHE_TIME
    proxiedContent = memcache.get(memcacheKey)
    proxiedContentInMemcache = True
    if proxiedContent is None:
      proxiedContentInMemcache = False
      try:
        response = urlfetch.fetch(url)
      except (urlfetch.Error, apiproxy_errors.Error):
        return self.error(404)
      proxiedContent = response.content
    if proxiedContent is None:
      return self.error(404)
 
    # Add the fetched content to memcache
    if (not proxiedContentInMemcache):
      memcache.add(memcacheKey,proxiedContent,CACHE_TIME)
    self.response.out.write(proxiedContent)
 
def isUrlAllowed(self, url):
  for urlPrefix in URL_PREFIXES:
    if url.startswith(urlPrefix):
      return True
  return False
 
app = webapp.WSGIApplication([
  ("/proxy", ProxyHandler),
], debug=True)
 
def main():
  wsgiref.handlers.CGIHandler().run(app)
 
if __name__ == "__main__":
  main()

The proxy can now be called by passing the URL to be proxied via the url parameter. So to proxy e.g. http://google.com, the following request should be made: http://myapplication.appspot.com/proxy?url=http://google.com.

Adding crossdomain.xml to the Application

Now that the proxy class is ready, all we need to do is wire it into the web application and include a crossdomain.xml static file which will allow requests from all hosts (it is advisable to change this to the URL the requests are actually made). Based on this, here is how the crossdomain.xml would look like:

<!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd"> 
<cross-domain-policy> 
  <allow-access-from domain="*" /> 
</cross-domain-policy>

And here is how the modified app.yaml descriptior will look like:

application: yourappname
version: proxyv1
runtime: python
api_version: 1

handlers:
- url: /crossdomain.xml
  static_files: crossdomain.xml
  upload: crossdomain.xml
- url: /.*
  script: proxy.py
  secure: optional

Download the Code

The code for the application can be downloaded here: Proxy Using Google App Engine.zip. After unzipping be sure to change the “yourappname” name in app.yaml in order to be able to deploy it on Google App Engine.

Update: Security Issues

Andrew noted in the comment that the original solution raised security concerns as it would have been easy for someone to hijack this proxy and use it for their purpose as no authentication or authorization is done. I’ve added a small fix where the proxy only forwards to URLs that start from a list of prefixes. This is probably a sufficient solution for common cases, however more sophisticated authorization methods may be needed in other cases.