As you can imagine, there are different types of GeoCaches. Traditionals like described above, Mystery Caches for which you need to solve puzzles, NightCaches that can only be found at night and several more. However, recently an absolutely awesome idea popped into my mind. An idea for a new type of GeoCache.

The Augmented Reality Cache

Augmented Reality basically means that the reality is “extended” by virtual information (most commonly 3D Objects). But how does this work? Easy: You place a marker that can be recognized by a special software that runs on a device which has an integrated camera (or the ability to have a camera attached). The software then extends the real world image with the virtual object and displays the result on the display. What makes AR so damn fancy is that this all happens in real time. So if you turn or tilt your device, the virtual objects does the same just as if it exists in the real world.

More easy: On the display  it simply looks like as if the giant monster dwarf was really standing in front of you swinging his enormous warhammer. Only… that he’s of course not really there.

Look here to get an impression of what the heck I am talking about.

What does that mean for GeoCaching

So back to GeoCaching. GeoCaching means that you go to given GPS coordinates and then search for some sort of hidden treasure (the Cache). Sometimes you follow hints or need to solve puzzles.My vision now works like this: The coordinates lead you to a traffic sign for instance. You point your Windows Mobile cellphone with an integrated GPS device and camera to the sign and what you see on the display is a virtual three-dimensional arrow pointing to the right with a text on it saying 50m. Everyone else only sees that traffic sign. But you have a device that extends your sense of reality. You see more. You took the red pill!

So the AR Cache could incredibly increase the GeoCaching experience by adding hints, coordinates and visual clues to real world objects. Also, many cacher already use devices like Windows Mobile cellphones (for instance running CacheWolf) or the iPhone (running Groundspeaks own proprietary software). So there will be lots of people who can experience this new type of GeoCache.

Ideas

For this type of GeoCache to work, a couple of things need to be accomplished. First of all, applications need to be developed that are able to recognize either simple marker or even basic geometric forms (to be able to work with real objects like traffic signs instead of stickers that need to be attached to real world objects). This application needs to be able to import markers as well as 3D Objects, images or whatever, so that a Cache Owner can create an own set of extension for his specific AR Cache. Of course it would be awesome if this application also has an Owner-Tool that makes it possible for the owner to create markers from real world objects instantly with the integrated camera of his device for instance.

Next, this type of software needs to be made widely available for different platforms. The easiest would most certainly be Windows Mobile. Also, Groundspeak should be pretty interested in extending their own GC software with this feature. A Java based application should be interesting, too, so that it will work on basically every device that is able to run own applications. Maybe this is something, the CacheWolf community is looking for?

Speaking of Groundspeak: I sent an email to them with a suggestion to create this new type of GeoCache. I am curious if I get feedback.

Please comment on this if you like the idea.

Well… it’s a start.

So I implemented a little tray-application for her that she can use to put it to sleep and wake it up again whenever she wants:

The answer is easy but you will be less than thrilled.

One of the software developers of Acresso explained they were using the API function NetServerEnum. And if you look here you will find out that if it does not work, the reason might be that the ComputerBrowser service is not active.

In all test cases I tried, I was able to get the LogonInformation dialog to work with enabling the ComputerBrowser service. However, this solution has a major drawback: The ComputerBrowser service itself depends on File and Printersharing. All these services are disabled by default on a Windows Server 2008 for instance.

In most cases you won’t be able to tell your customers they need to enable and active several services only for your setup to work. So I guess the bad news is that you will need to find a work around.

What I did, by the way, is implementing a couple of own Custom Actions and replace the calls in InstallShields’ dialogs with my own ones. That works like a charm.

Well. Somebody did.

There used to be a sample called Microsoft.Win32.Security that was released for free on gotdotnet. When you are reading this, I bet you already know that and found out that GDN does not exist anymore and Microsoft somehow forgot to put the code up on MSDN.

Also you will almost certainly already have stumbled across this site, that newsgroup and in case you are actually searching for a way of playing with DCOM also across myITforum and maybe Acresso. 

If you also found out that the Assembly was built for .NET 1.1 and Microsoft already implemented an own (official) wrapper for .NET 2.0 and called it System.Security.AccessControl and if you also found out that it does not contain the features you needed, than read further.

Although you won’t find the official source of Microsoft.Win32.Security, there is at least one project still active that makes use of it and – fortunate for us – contains the complete sources. The project’s name is FlexWiki and you can download its sources easily with any Subversion Browser. Here is how:

1. Obtain and install the latest version of  TortoiseSVN from tigris
2. Create a folder on your harddrive and name it flexwiki
3. Right click that folder and use TortoiseSVN to check out the flexwiki source

For the last step you will have to enter the following URL: https://flexwiki.svn.sourceforge.net/svnroot/flexwiki and simply check out the main trunk.

You will find the sources for the Microsoft.Win32.Security assembly right under flexwikicore/trunk/lib/Win32Security. In the bin subfolder there already is a compiled dll you can use right away.

Hope that this information if useful for someone. If so, please comment.

Although there currently is no real native way of doing so, it is still virtually possible and I will show you how.

First of all you need to know that MSI does not support managed code custom actions by default. However, people of both Acresso (publisher of the famous jack-of-all-trades InstallShield) and Microsoft created a way of working around the limitations of the still unmanaged Windows Installer. They put a wrapper around a library that establishes a bidirectional way of communicating in and out the managed code from within a custom action.

If you don’t use (or can afford using) InstallShield 2009, simply download Windows Installer Xml (WiX), install it and have a look at its samples regarding managed custom actions (you might want to download the sources as well as it contains more sophisticated examples in its DTF subdirectory).

Now that you can actually build managed code custom actions and thus have full control of the MSI while it runs (such as accessing the MSIs’ logfile, all properties and virtually every table contained within the MSI), it’s an easy step of implementing code to eventually run PowerShell scripts in less than 20 lines of code.

This is pretty much it. Of course the code is only a sample and you will have to add some security to it as well as exception handling. You might want to try finding out how to send data to the MSI from within the PowerShell script so that you could update the progress bar with useful information about what’s hapening e.g.

Also you need to take care of the execution policy that might prevent you from actually executing a PowerShell script in the first place.

However, the article didnt actually contain anything of any interest. And the referers didn’t show how those people got to my blog. Today, I noticed that there are still visitors looking for Brian (did you notice, that I had a typo in the headline?). This time I got curious. Where did those people come from anyway. So I had a closer look into the stats.

And guess what: From Redmond. Microsoft Corp.

This is so typical. I post really interesting stuff about how to quit Microsoft Windows Live OneCare, why Microsoft Windows 7 will kick ass, the all new Microsoft Team Foundation Server 2008 Branching Guide 2.0, how to generate Release Notes with Microsoft Team Foundation Server 2008 Team Build and automate the incrementing of Assembly version numbers (thanks again, Chris!). And they come for looking at a youtube video about Brian the Build Bunny.

Time to get one and do something with it, they really find interesting.

Since I can safely assume, that you guys from Microsoft still visit my blog for Brian, could you please add comments about why and where you got the link from?

So this is what this article is about: Imagine you were doing nightly builds of your software. Sure enough you wouldn’t want to touch every AssemblyInfo.cs or .vb every day only for manually incrementing the version number. The Assembly version number basically looks like this:

MajorVersion.MinorVersion.BuildNumber.Revision.

What you want to achieve is that you can see the Assembly version in the file properties in explorer so that you know which release build it refers to.

To know which release build the Assembly refers to, you need the buildnumber Team Build assigned to the release. The naming convention looks like this: Buildname + Date + Revision. So if you built your FooBar application today already the third time, its buildnumber would be FooBar_20090128.3. Easy, huh?

While FooBar’s sources are labled with that buildnumber, the Assembly properties are not altered.

The settings you would want Team Build to alter are these:

// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the ‘*’ as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

Before I go into details about what Chris did to get things working, let me add the following:

My project consists of several solutions. I have libraries for example that are shared amongst several projects. This is why I only wanted to have build definitions that contained the main project and the referenced libraries. However, for automatically checking out and back in the AssemblyInfo files while editing them at build time, Chris uses the /recursive argument to recursively go through all subdirectories and touch all AssemblyInfo files. When having more than one workspace in your build definition that explicitly copy only specific projects to Team Builds’ local workspace, that does not work.

However, he also shows how to create a list of all AssemblyInfo files within the folder structure. And I changed his TFS tasks so that instead of the recursive argument the list generated earlier is used. That works like a charm!

And this is how you extend the build process to let Team Build automatically set the version information:

 1. Download and install AssemblyInfoTask

You need to get this custom build task. Chris references the original source at gotdotnet.com which does not exist anymore. Either search for the text AssemblyInfoTaskvers with google or try this link. It should redirect you to the download area on MSDN where you can get the lates setup release.

2. Import the task into your build project

Open Source Control in Visual Studio and make sure you have a local copy of the build project in your workspace. Then check out the TFSBuild.proj file (Unchanged, keep any existing lock) and open it. Add the following line right after the import of Microsoft.TeamFoundation.Build.targets: 

3. Use a custom task for retrieving the revision number

Each buildnumber contains a revision: FooBar_20090128.3 What we want to do is using this revision number also as revision in our Assembly version. So we need to implement a custom build task that is able to extract the revision number from the buildnumber so that we can assign it to the Assemblys’ revision number. At the end of this article, I will post the sources you will need.

Right after the import statement from above, register this custom build task by adding the following line: 

 4. Add a property group for setting the assembly information

To configure all assembly properties and format the number formats respectively, add the following lines to your project file:

5. Set the revision number

By altering the target CheckSettingsForEndToEndIteration, you can use the custom build task you have yet to implement for extracting the revision number from the buildnumber and add it to the assembly version:

  <!– Use the ExtractRevionTask to get the RevionNumber out of the BuildNumber.

       Update the AssemblyInfoTask Properties with the result BuildRevision. –>

  <Target Name=“CheckSettingsForEndToEndIteration“>

    <!–for 2008 use the GetBuildProperties Task to get the BuildNumber –>

    <GetBuildProperties TeamFoundationServerUrl=“$(TeamFoundationServerUrl)“ BuildUri=“$(BuildUri)“>

      <Output TaskParameter=“BuildNumber“ PropertyName=“BuildNumber“></Output>

    </GetBuildProperties>

    <!–  extract the BuildRevision –>

    <ExtractRevisionTask BuildNumber=“$(BuildNumber)“>

      <Output TaskParameter=“BuildRevision“ PropertyName=“BuildRevision“ />

    </ExtractRevisionTask>

    <!–  update the AssemblyInfo Props –>

    <CreateProperty Value=“$(BuildRevision)“>

      <Output TaskParameter=“Value“ PropertyName=“AssemblyRevision“/>

    </CreateProperty>

    <CreateProperty Value=“$(BuildRevision)“>

      <Output TaskParameter=“Value“ PropertyName=“AssemblyFileRevision“/>

    </CreateProperty>

    <!–  just needed if you populate the AssemblyDescription  too like in the sample  –>

    <CreateProperty Value=“$(BuildNumber)“>

      <Output TaskParameter=“Value“ PropertyName=“AssemblyDescription“/>

    </CreateProperty>

  </Target>

6. Check out and back in all AssemblyInfo.[cs|vb] files from your workspaces

Before you can alter the AssemblyInfo files, you need to let Team Build check them out:

 Right after the altered files have been compiled, you can check them back in:

Just in case anything bad happens, there is a way of undoing the changes:

  <!– In case of Build failure, the AfterCompile target is not executed. Undo the changes –>

  <Target Name=“BeforeOnBuildBreak“ Condition=“‘$(IsDesktopBuild)’!=’true’“>

    <Exec WorkingDirectory=“$(SolutionRoot)“

    Command=“$(TF) undo /noprompt &quot;@(AssemblyInfoFiles, ‘&quot; &quot;‘)&quot;“/>

  </Target>

 7. Implement the ExtractRevision custom build task

Simply create a new C# library project with the following class (and add a strong name to it by signing it in the project properties):

This basically goes something like this:

1. Download and install the MS Build Community Tasks from tigris
2. Download and install the MSXSL.exe tool from Microsoft
3. Extend the build.proj file

This process involves the WebDownload build tasks that retrieves the buildlog.xml file from the respective TFS webservice after the build is done. Nex step is transforming the xml file to generate a releasenotes.txt file.

Everything you need to know to get things done is very well documented on Hollidays blog.

However, there are two things to notice: First, you need to download the Community Tasks msi file directly from tigris. The link, Holliday provides, leads to an outdated version that does not include the UseDefaultCredentials property. The result ist, that the process will terminate with a 401 error due to missing authorization.

Second, Holliday does not provide an example xsl file for transformation of the xml file.

To achieve the same result as Holliday does (and shows on the blurry screenshot), you can try using the following xsl file: ReleaseNotes.xsl

Learn everything about it here: TFS Branching Guide 2.0 – Home .