Nathan and his Open Ideals

My raw thoughts on Google’s acquisition of Motorola Mobility

nathan — Tue, 16 Aug 2011 00:59:54 +0000

Overall, I am positive on the acquisition, with my main concern being that Google is clear and decisive about how they plan to proceed with the integration and operational side, and that they don’t unintentionally create confusion and concern in the consumer market.

ARMING UP FOR THE PATENT WAR
Obviously this acquisition is related to the ongoing patent wars between Apple and Google (with their hardware partners HTC and Samsung as the primary proxies for litigation). Motorola has a deep, broad collection of intellectual property. Not only did they invent the cellular telephone and have years of creating popular consumer mobile hardware (StarTAC!), but they also have created their own Linux+Java mobile OSes in the past, which could provide support for Google in the case vs. Oracle.

GOOD FOR DEVELOPERS FOR NOW
I don’t think this will change much for developers in the next few years, as Android has great momentum that won’t end anytime soon. It may be a boon ultimately, as Google must work harder to maintain the image of Android being open now. The more transparency and code they release, the better for all. I would also hope Google uses this to support and/or indemnify its app developers from worrying about being sued by patent trolls like LodSys.

PUTTING THE NAIL IN THE RIM COFFIN
Motorola has a “Pro” category of devices, with enhanced security in the OS to meet enterprise and gov requirements, as well as Blackberry style keyboards. This device could be a “Nexus Pro” sold bundled with Google Enterprise services to take on RIM directly as complete business tack. Google is having a lot more success in this space than people realize, taking on IBM, Microsoft and RIM all in one swoop. This is an area that Apple cannot compete in.

COMPETING WITH YOUR PARTNERS
It will be a tricky task to manage Android and Motorola business units of Google. While not entirely comparable, there are some good lessons to learn from Palm and Apple’s own failed attempts at licensing an OS while producing their own competitive hardware. I was at Palm when we had the PalmOne (Hardware) and PalmSource (OS) divisions, when there were still Palm licensees such as Handspring and Sony, and it was a really difficult mess. PalmSource had to treat us like a separate company, in order to appease partners, but at the same time, we didn’t have the freedom those partners would have to implement their solutions because we had to maintain unity with the Palm vision. Eventually, all the licensing ended, Palm bought Handspring, and the whole company unified again, and then ultimately failed, and was acquired by HP.

Redesigning the Camera Phone to Protect Privacy

nathan — Tue, 28 Jun 2011 04:49:54 +0000

Have you ever wanted to post a photo to Facebook from your mobile phone, but weren’t sure if someone in that photo would mind their face going online? Did you take a great picture of your kid at the playground that you want to tweet out to the world, but caught some other kid in the shot, and are worried about their parent freaking out about online predators? Maybe you are worried about all the data that is being logged in your photos, like the exact GPS coordinates of where you took the picture, and don’t know how to disable that feature. If any of these thoughts have ever crossed your mind, and you have an Android phone, then you should try out a new app my team at the Guardian Project just launched called ObscuraCam.

In short, the app integrates with your camera and gallery, to allow you to remove, pixelize or disguise faces of people in your photos, before you upload them to Facebook, Twitter or elsewhere. It also cleans out all the secret, hidden extra data that gets stored in your photos, like your GPS location, the make and model of the camera phone and sometimes even a unique serial number identifying your phone. While our original goal was to build an app that supported human rights activists in places like Iran and China, we really do think this app has broader relevance to everyday people (like YOU!) who want to have a bit more power of controlling what gets revealed, analyzed and indexed when they share their photos online.

Read the post on the Guardian Project blog, to get a more in-depth idea about what we’ve done, and where we are going with this project. This “v1″ release is just for still photos, but we are quickly moving on to support video, as well as additional obscura filters too!

ObscuraCam is pretty powerful, in that it can automatically detect multiple faces in a photo, and then allow you to selectively choose how to filter those faces. You can also filter out t-shirts, signs, sensitive documents on a desk or just about anything you don’t want a human or machine to be able to see.

You can even have some fun putting on a silly disguise, which may still allow a human to recognize the person in the photo, but would most likely stop Facebook or Google’s current recognition software from figuring out who you are.

So, please – try it out, have some fun, and post some pictures.

Just search for “Obscura” in the Android Market or install it directly from the web.

Amazing GPS Tracking Map from my Android phone!

nathan — Tue, 26 Apr 2011 02:44:54 +0000

I sure have an interesting life, well at least that is what the location data recorded on my phone tells me!

My Quick Guide to a Less Risky Dropbox

nathan — Wed, 20 Apr 2011 15:54:00 +0000

While there are definitely many security-related holes and privacy concerns to be had about the free (but not open-source) Dropbox file sharing service, it has taken the world by storm, including many activist and human rights groups, mostly due to the simplicity and effectiveness of its user experience. As we have seen many times before, software and services that “just work”, will always win out over more secure options with the majority of the population. This post is a quick attempt to share some simple steps you can take to ensure your use of Dropbox, or any similar cloud-based file storage and sharing system, is more properly protected, obscured or otherwise mitigated as a direct threat to the security of your information.

1. Use Dropbox over Tor to stop local network monitors from knowing you are using Dropbox to begin with. This also is a good configuration to use with people who live in places where Dropbox might be blocked, but Tor is not.

Install Tor and use Vidalia (the GUI controller) to connect to the Tor network.

Set Dropbox->Preferences->Network->Proxy Settings to use Tor’s secure SOCKS proxy on localhost, port 9050

2. Set Bandwidth Usage to a low value to avoid creating large spikes in network traffic. This will reduce the likelihood your particular use will be singled out if you are syncing large media files or other transfers.

Set Dropbox->Preferences->Network->Bandwidth Usage to a low value such as 50KB/s for upload and download

3. Use Truecrypt to create encrypted disk volume files inside of Dropbox, and then store your files inside of that. This can still be shared by multiple users, if you use a password based volume.

Download, install and configure the free, open-source TrueCrypt software: http://www.truecrypt.org/

Create a new TrueCrypt volume, stored within a Dropbox folder

All in all, there are more secure ways to share sensitive information, such as using GPG file encryption or another OpenPGP solution, but if you absolutely must use Dropbox, and you are under any sort of threat at all to having the information you store on it used against you, then please follow this advice I have shared.

If you have additional tips, warnings or configurations along these lines, please add them to the comments below.

Another small step for a Tibetan keyboard on Android

nathan — Fri, 26 Nov 2010 16:54:48 +0000

There has been a lot of excitement this week about the robust support for the Tibetan written language in Apple’s iOS 4.2 for iPhone and iPad. This is a fantastic achievement that many contributed to, and that Apple should be loudly applauded for.

Unfortunately, the state of Tibetan on Android is still poor, but not hopeless. While Tom Meyer has provided a great starting point for rendering text properly, I still am not aware of any means for inputing Tibetan characters. With that in mind, I set out to investigate the ability to create a new Tibetan “Input Method” (as Google calls it) for Android, and quickly realized that one could just write a Language Pack add-on for the open-source AnySoftKeyboard project. This solution still requires you to root your phone and install the Dzongkha”རྫོང་ཁ font, but is still a step in the right direction!

You can find the open-source code for my new project, the Tibetan AnySoftKeyboard Language Pack on Github. If you would like to try it out, you must have a rooted device with the Dzongkha”རྫོང་ཁ font installed, then install the “AnySoftKeyboard” from the Android Market, then you can install the first test Add-on APK file, and the Tibetan option should come up in keyboard settings.

Below you can see a screenshot of the initial keyboard writing text into the OI Notepad app. It appears to be properly stacking characters as well, but I may be wrong. Also the current implementation does not yet support the SHIFT key or other modifiers. I would love to have some help setting up the rest of the QWERTY mappings in this XML file. Otherwise, any other comments, feedback, advice or pointers to other Android Tibetan keyboard work would be much appreciated!

Technologists Wanted: Join the New York State Senate Developers Network

nathan — Mon, 01 Nov 2010 13:45:03 +0000

Reposted from here: http://www.nysenate.gov/blogs/2010/oct/27/technologists-wanted-join-new-york-state-senate-developers-network

Over the past year and a half, the Office of the Chief Information Officer at the New York State Senate has worked to promote openness and transparency through the use of technology. Our goal is both to serve the needs of the Senate as an institution and also develop examples that other government bodies in New York and around the country can use, adapt and implement to further open up our government. Today, we’re taking the next step that effort by introducing the New York State Senate Developers Network.

The purpose of the network is to help any technologist interested in how technology is used in the Senate to easily find what they’re looking for, and to be able to interact directly with Senate technology staff. We hope that such a network of developers will leverage the work that the Senate is already doing, both to serve their own needs and also to create more public benefit, at no additional cost to taxpayers. We have created a Google Group Mailing List as well as an Internet Really Chat (IRC) at irc.freenode.net #NYSSDev to help and facilitate the discussion between our staff and all that are interested in talking with us.

In addition to the mailing lists and IRC room, we are also proud to announce the alpha release of our NYSenate.gov Application Programing Interface (API). We hope that by providing a developer API to the treasure trove of information we have available on our website that technologists throughout New York State and the country will be able to create new and interesting tools for the public.

Along with our discussion groups and API, the New York State Senate Developers Network also provides a listing of RSS feeds available on our website as well as links to the Source Code that we have made available for our various projects, along with as our existing Open Legislation API.

Click Here to go to the New York State Senate Developers Network.

Searching and Playing YouTube Videos using Appcelerator Titanium

nathan — Thu, 30 Sep 2010 05:30:46 +0000

This tutorial is part of content I am developed for the NYU ITP course I am teaching this semester, “Social Activism using Mobile Technology”. You can find the original document posted here. This code comes from the open-source project (of which I am the lead developer) located here: http://github.com/nysenatecio/NYSenateMobileApp. If you want to see this code “in action”, download the NYSenate Mobile app for iPhone, iPad or Android.

This tutorial will demonstrate using the Appcelerator Titanium Mobile API, a Javascript-based cross-mobile-platform toolkit, how to accomplish the following feats in a mobile app:

Search for video by channel name or keyword from the YouTube API
Use the Titanium HTTP client for async XML requests and response handling
Retrieve video results from YouTube and display thumbnail & text in a table
Create a WebView window and use it to display YouTube video player
Hand-off YouTube video links to the OS for external playback

All in all, following this tutorial, you should be able to perform the basic functions you would need to build an app that front-ended video content stored on YouTube.

First, we declare our variables:

//this is the main app window

var win = Titanium.UI.currentWindow;
//this creates a spinning widget we can display while the user waits

var toolActInd = Titanium.UI.createActivityIndicator();
//this is the table we will load videos into

var tableview;
//and the data array for the table

var data = [];
//the window and webview for displaying youtube player (iOS only)

var webModal;

var webModalView;
//stores the current link being displayed in the web view

var currentLink;
//this is the network request object

var xhr = Ti.Network.createHTTPClient();

Now you need to declare a function that knows how to play YouTube videos on iOS and Android. Every YouTube video has a GUID (globally unique id – or at least unique for YouTube) and a title. You pass those two values to this function and it will either launch the YouTube player directly (Android) or display a thumbnail with playbutton that the user can launch (iOS).

function playYouTube (vtitle, vguid)
{
if (Titanium.Platform.name == ‘iPhone OS’)
{
var ytVideoSrc = “http://www.youtube.com/v/” + vguid;
var thumbPlayer = ‘

’;

showHTMLContent(vtitle,’http://www.youtube.com/watch?v=’ + vguid,thumbPlayer);
}
else //on android
{
//this call to openURL hands off the link to the operating
//system, and starts any player that supports youtube.com
Titanium.Platform.openURL(‘http://www.youtube.com/watch?v=’ + vguid);
}
}

The reason you show an embedded YouTube thumbnail player on iOS, is that it will allow the video to play inside of the app without leaving the context of the app. This was more a problem on the non-multitasking iOS 3.x, and is still an issue on the iPad until iOS 4.2.

In the function above, there is a showHTMLContent() function call. This function is not built-in, and is just a way to simplify the common need to show some bits of HTML markup within your app. The arguments for the function are a title of the page, an optional URL to the source content of the page, and the direct HTML markup content to display.

function showHTMLContent(wTitle, wUrl, wHTMLContent)
{

//store the link for later use
currentLink = wUrl;

//create the window to hold the web view
webModal = Ti.UI.createWindow({});

//set the orientation modes for basically any which way
webModal.orientationModes = [
Titanium.UI.PORTRAIT,
Titanium.UI.LANDSCAPE_LEFT,
Titanium.UI.LANDSCAPE_RIGHT
];

//create the webview aka the embedded web browser (webkit/safari)
webModalView = Ti.UI.createWebView();
webModalView.scalesPageToFit = true;

//add the web video to the modal window
webModal.add(webModalView);

//set the title of the window
webModal.title = wTitle;

//if you are using a tab UI in the app, this will open the window
Titanium.UI.currentTab.open(webModal,{animated:true});

//set the HTML to display to the markup passed into the function
webModalView.html = wHTMLContent;

};

Great, so now we have the ability to display a YouTube player within our app using an embedded WebView. Pretty awesome so far, and hopefully you see how might use components like WebView for other mashups of native and web content in your apps.

Now we need to demonstrate how to get the data from YouTube on what videos are available. For this, we create another function called “doYouTubeSearch()”. This function takes two parameters: you can specify the channel name to retrieve videos from, or you can specify a search term, and you can combine these as well, to search videos from a specific channel only.

function doYouTubeSearch (channel, searchTerm)
{

//first show a “loading” spinning indicator to the user
toolActInd.message = ‘Loading videos…’;

win.setToolbar([toolActInd],{animated:true});

toolActInd.show();
//create the YouTube API search URL from the function parameters
var searchUrl = ‘http://gdata.youtube.com/feeds/api/videos?alt=rss&author=’ + escape(channel) + ‘&q=’ + escape(searchTerm) + “&orderby=published&max-results=25&v=2″;

//use the xhr http client object to do an HTTP GET request to the URL
xhr.open(“GET”,searchUrl);
xhr.send();
}

That was all pretty straightforward, right? You build up a URL, and you make the request using it for data from YouTube. Now, how you receive the response to that request is our next step. To do this, you must define an “onload” function for the ‘xhr’ object.

It is in this function that you will receive the data back from YouTube (usually in JSON or XML format), and you can process it to display in your app.

xhr.onload = function()
{
try
{

//the doc object holds the response structure

var doc;

//check whether the data coming back is in XML format or not

if (!this.responseXML)
{
//if not XML you have to convert it to XML
doc = Titanium.XML.parseString(this.responseText).documentElement;
}
else
{
//if it is XML, then just set the doc variable
doc = this.responseXML.documentElement;
}

//now we can easily get a list of items from teh results
var items = doc.getElementsByTagName(“item”);

//some simple variables for tracking the loop
var x = 0;
var c;

//now just loop through the response array to see what videos we have

for (c=0;c {
//get the current item
var item = items.item(c);

//get the text for the video title tag using standard DOM XML calls
var title = item.getElementsByTagName(“title”).item(0).text;

//build up a summary string to display below the title
var summary = “”;
if (item.getElementsByTagName(“pubDate”))
{
summary = item.getElementsByTagName(“pubDate”).item(0).text;
}

//get the link to the youtube video
var link = “”;

if (item.getElementsByTagName(“link”))
{
link = item.getElementsByTagName(“link”).item(0).text;
}

//now here is where we perform a trick
//we find the GUID code from within the link b/c we know the link format
var guid = link.substring(link.indexOf(“?v=”)+3);
guid = guid.substring(0,guid.indexOf(“&”));

//now we can use that guid to load up a thumbnail image
var thumbnail = “http://i.ytimg.com/vi/” + guid + “/2.jpg”;

//okay we have all the data we need for that item
//now we need to create a row to add to the table in order to display it

//create the row item and set the height to 80 pixels
var row = Ti.UI.createTableViewRow({height:80});

//set parameters for the row so we can get the youtube data out later
row.url = link;
row.guid = guid;
row.videotitle = title;

//create a label for displaying the title and add it to the row
var labelTitle = Ti.UI.createLabel({
text:title,
left:105,
top:10,
height:40,
font:{fontSize:16}
});
row.add(labelTitle);

//create a label for the summary and add it to the row
var labelSummary = Ti.UI.createLabel({
text:summary,
left:105,
top:45,
font:{fontSize:12}
});
row.add(labelSummary);

//create an image from the thumbnail, and add it to the row
var img = Ti.UI.createImageView({
url:thumbnail,
left:0,
height:80,
width:100
});
row.add(img);

//add the row to the data array
data[x++] = row;

}

//if tableview has been created, reset the data on the table
//you can update data on the table multiple times
if (tableview)
{
tableview.setData(data);
}
else
{

//if table has not been created, build it up with the data array
tableview = Titanium.UI.createTableView({
data:data
});

//add the table to the current window for display
Titanium.UI.currentWindow.add(tableview);

//add a ‘click’ listener so that when someone taps on a row
//the video will be played using the function we defined earlier
tableview.addEventListener(‘click’,function(e)
{
playYouTube(e.row.videotitle,e.row.guid);
});

}
}
catch(E)
{
//if anything bad happens, show the error to the user and log it
Titanium.API.debug(E);
Titanium.UI.createAlertDialog({title:’NY Senate’, message:’No videos were found for this search.’}).show();

}

//hide the spinning ‘loading’ widget
toolActInd.hide();
win.setToolbar(null,{animated:true});
};

Okay, so that was a lot I know, but go back through it a few times, and you will see it is not so hard. First, we get XML back from YouTube. Then, we turn that XML into an array of items. Them we loop through those items and build up an array of rows. Then, we set the table with that array, and display the table. Finally, we handle the ‘click’ or touch events on the row, and display the YouTube player in the embedded webview. Ta-da! You now have a customizable YouTube search and player app.

Now here are three examples how you might kick off all this activity.

First, in this case, we are doing a search for any video in the ‘NYSenate’ YouTube channel.

doYouTubeSearch(‘NYSenate’,”);

In this example, we are searching all of YouTube for a “skateboard dog”.

doYouTubeSearch(”,’skateboard dog’);

Finally, in this example, we are

doYouTubeSearch(‘NYSenate’,'Brooklyn’);

In review, this lesson has showed you how to display HTML web content, how to create YouTube players embedded in that content, how to make HTTP requests to web services and APIs, how to parse the XML returned from those services, and how to display data in a Table format.

This example was built upon code that comes from the open-source project located here: http://github.com/nysenatecio/NYSenateMobileApp so go grab the code there and use it as a basis of your own app!

Another Excellent Event: Open Video Conference, This Week in NYC

nathan — Thu, 30 Sep 2010 03:52:52 +0000

News from my work on The Guardian Project:

Nathan Freitas will be on a panel at the 2nd annual Open Video Conference in New York this Friday and Saturday. He will be on the panel entitled “Cameras Everywhere” led by our partners at Witness, on Saturday at 3pm.

Summary: Cameras Everywhere: Human Rights and Web Video - (2:45 PM – 3:30 PM)

Description: Once upon a time, video cameras were rare. Now they are ubiquitous—as are the opportunities to share, use, and re-use video. What are the limits and possibilities of an ethics of openness when it comes to human rights footage?

Videos (particularly mobile and online video) make it possible to document and publicize human rights struggles – from monks marching for freedom in Rangoon and Lhasa, and the election protestors in Tehran, to individual voices speaking out against injustice on YouTube and other online spaces. But despite the growing circulation of images of human rights violations, of victims and survivors, there is limited discussion of crucial safety, consent and ethical concerns – particularly for people who are filmed.

Issues around consent, representation and re-victimization and retaliation have emerged even more clearly in an open and networked online environment, as have concerns about intentionality and authenticity. Video is being reworked, remixed and recirculated by many more people. New possibilities for action by a global citizenry have arisen, but these carry with them substantial challenges, opportunities and dangers.

Presenters:
Sam Gregory — WITNESS
Gabriella Coleman — NYU
Nathan Freitas — The Guardian Project
Steve Grove – News and Politics, YouTube

Following the panel, there will be an open workshop, to continue the discussion and brainstorm new approaches and tools to address the issues raised. This feedback will be gathered and fed into the OVC Hackday, held at NYU ITP on Sunday. Team Guardian will join in with whoever shows up at the hackday, take the ideas from the previous day, and build prototyped mobile video solutions in response to them.

You can get more information and register for the hackday here: http://www.openvideoconference.org/hacklabs/

OVC hack labs: Sunday, October 3

Join us at NYU’s Interactive Telecommunications Program for an all-day open space gathering for innovators of all stripes. Meet and collaborate with conference attendees, HTML5 developers, transmedia storytelling experts, and more. Among the planned activities:

Make interactive HTML5 video using WebMadeMovies technology like popcorn.js
Map out a transmedia strategy for your content
Build a custom HTML5 player for your site
Create robust video sites using the free+open source Kaltura CE 2.0 self-hosted software stack
or just grab a room and hack on your project!

OVC hack labs are free and open to the public.

I’m on a Panel… October 6: the “(NY)TimesOpen 2.0: Open Government Event”

nathan — Fri, 24 Sep 2010 16:45:23 +0000

Personal note: It has been a little while since I’ve updated this blog, mostly because I seem to spend my blogging energy updating my beautiful 4-month old daughter’s blog (yay!). Now back to business…

I am excited to be a participating in this series of “Times Open” events hosted by the New York Times. I was invited to join by Derek Willis, The Times’s government API guru, who I met through my work as part of the New York Senate’s CIO Team and our Open Senate effort. Derek is doing brilliant work there, turning the venerable news organization into a true data platform, and helping them redefine what it means to “cover a story”.

Next up in our TimesOpen 2.0 series is an evening about Open Government. Open Government allows for great governmental efficiency, transparency and citizen participation.

We’ve pulled together a lineup that will showcase government data from multiple angles — from the people who are opening up the data, to the developers who are putting the data to use, to how the data is being used in the Times newsroom.

TO2.0: Open Gov will be held Wednesday, October 6 from6:30–10 p.m. at The New York Times.Registration is now open.

Read the full post here: http://open.blogs.nytimes.com/2010/09/24/timesopen-2-0-open-government-event/?emc=eta1

The “Took”: Tibetan-enabled Nook eReader

nathan — Sat, 07 Aug 2010 05:01:54 +0000

Thanks to amazing work by Tibetan font experts Tom Meyer and Chris Fynn, as well as the Barnes and Noble Nook eInk reader device hackers at NookDevs.com, I have modified my $199 Nook ($149 if you get the wifi only model!) to support proper rendering of Tibetan characters. This is dynamic rendering of Unicode text, and not just static pre-rendered images.

You might have seen an earlier post I wrote about this here, and I’ve essentially done the same thing this time, but with an important addition of code from Tom that properly stacks the characters (a critical feature often not available in an OS font library), and a new Tibetan font (actually Bhutanese) from Chris which is small, lightweight and efficient enough to be used on Android. All together this provides support for reading Tibetan text on web pages, and within full application user interfaces, eBooks and more.

With up to 32gb of storage possible via the tiny micro SD Card, this one device could probably store and serve up the majority of Tibetan Buddhist texts, not to mention literary, poetic and historic works, that exist, all in a lightweight, energy-efficient device. Since the device is also networked, you can use it to pull down the latest Tibetan language online news and blogs.

And yes, this is all possible because the Nook is based on the free, open-source Android operating system. Yay for freedom in all forms!

This is support for both web pages, as well as full applications on the device.