https://github.com/shaftekbiz/android-language-settings-app

—————-

One of the interesting aspects of the new Kindle Fire is how much Amazon had customized or simply overrode the default UI, including some of the settings pages. One issue that has come up recently is how to enable ability to use languages other than English. A fellow Kindle Fire in Germany, named Gero Zahn, managed to figure out how to do that by using two separate apps which trick the Kindle Fire to opening the input language settings UI page which while hidden still remains on the device. His approach is described in detail in the following blog post and the credit for discovering this goes to him:

http://blog.gerozahn.de/2011/11/kindle-fire-keyboard-layouts-solved/

I was looking for a simpler way to do this and came up with a very simple Android app using Google’s AppInventor that does just that – gives you access to the input language settings. This approach does not require installing outside applications other than this app itself. If you already have Android Market sideloaded into the Kindle, you can find the app here.

If you do not have the Market installed, you can download the app here:

http://goo.gl/NfEqO

This app is also available on the Amazon’s AppStore but it has not yet been approved for the Kindle Fire. To see this app on Amazon.com, click here.

Make sure to enable ability to load outside apps into your Kindle by tapping the top right corner of the screen to enter the settings section, then click on “Device” and check off “Allow installation” for non approved applications. I have submitted the app to the Amazon AppStore for approval as well, and hopefully it will be available directly from it.

For the technically inclined, here is a short explanation of what is happening:

Actions on Android that cross application boundaries are triggering using something called “Intents“. There are two of those that trigger language settings, of which the first (com.android.settings.LanguageSettings) has been customized by Amazon to show their own keyboard options. The second is the one that actually triggers the language selection menu and is called “com.android.inputmethod.latin.InputLanguageSelection“. The action for it is called “android.intent.action.VIEW“.

UPDATE #1:

In my testing, only the following languages work:

• Danish
• English UK
• English US
• French
• German
• Hebrew
• Norwegian
• Russian
• Serbian
• Swedish

UPDATE #2 – January 22nd, 2012

The app has been updated to v1.3 and it is now a fully native Android app and no longer uses App Inventor. The size has been brought down from 1.4 MBs to 22 KBs. I also added support for Android 4 (ICS). The code will be open sourced shortly. You can use Google Market to update, or the same link above.

First of all, about versioning: there are two current versions of Eclipse – 3.5 aka Ganymede and 3.6 aka Helios. Ubuntu 10.10 which I use on home box comes with the 3.5 version. Visual Editor also has two versions, 1.4 dating from 2009 and a more recent 1.5 release from late 2010. Because I wanted the 1.5 version with Eclipse 3.6, and after reading multiple posts describing issues with the Ubuntu packaged Eclipse, I installed the default packages and installed Eclipse 3.6 manually as follows:

1. Download the Eclipse IDE for Java developers, 32 bit or 64 bit Linux version from here.
2. I setup up Eclipse on my machine in the /opt/eclipse folder as root, however you can also do it on a per user basis in the home directory as described here.
3. Create a shortcut to the Eclipse application itself and put it anywhere you want (I stuck mine directly on a panel).

To install Visual Editor 1.5:

1. Click on “Help”, “Install New Software”, “Add” to add the Visual Editor repository. Use the follow URL: http://download.eclipse.org/tools/ve/updates/1.5.0/
2. When you try to install VE, you will get an error about a package called org.eclipse.jem. This package is part of Eclipse’s GEF tools, so go ahead and add a repository for GEF wit hthe following URL: http://download.eclipse.org/tools/gef/updates/releases/
3. Install the GEF SDK itself or Draw2D.
4. Go back and install Visual Editor, then restart Eclipse.

1. Transform PlayList.com’s ASX playlist into Podcast RSS via this link:

http://www.w3.org/2005/08/online_xslt/xslt?xslfile=http://www.shaftek.org/code/asx2rss/asx2rss.xsl&xmlfile=http://www.playlist.com/playlist/XXXXXXXX/asx

Where XXXXXXX is the Playlist.com user ID.

2. Use the resulting postcast with your podcatcher, or mobile phone. Or even cooler, use PodLinez.com or FoneShow to listen over a regular phone.

DISCLAIMER: I am not responsible for any illegal behavior that results. You should keep in mind that PlayList.com may be indexing illegal music which you will end up downloading via the podcast RSS. It is your responsiblity to check.

#!/usr/bin/perl

use Net::Amazon::S3;

my $s3 = Net::Amazon::S3->new(
{   aws_access_key_id     => 'ACCESS_ID',
aws_secret_access_key => 'ACCESS_KEY',
retry                 => 1,
}
);

my $bucket = $s3->bucket("BUCKET") or die $s3->err . ": " . $s3->errstr;
my $response = $bucket->list or die $s3->err . ": " . $s3->errstr;

foreach my $key (@{$response->{keys}}) {
my $key_name = $key->{key};
print "Deleting '$key_name'\n";
$bucket->delete_key($key_name) or die $s3->err . ": " . $s3->errstr;
}
exit;

Here is another way to cleanup bad HTML with Perl, and convert to XML:

use HTML::DOMbo;
use HTML::TreeBuilder;
use XML::LibXML;

$html_code = '';

// Parse HTML
my $builder = HTML::TreeBuilder->new();
$xml_source = $builder->parse($html_code);

// Convert to XML DOM
$xml_source1 = $xml_source->to_XML_DOM;

// Extract XML and encode UTF-8
$xml_source2 = (encode("utf-8", $xml_source1);

This approach relies on the HTML::DOMbo module to do the actual conversion between HTML and XML, and HTML::TreeBuilder for parsing.

An easy Perl hack to get around this is as following (assuming you are using MIME::Base64 module):

if($var =~ m/^\=\?UTF-8\?B\?(.*)\?=/) {
    $results = decode_base64($var);
}

• QuickBase stores Unicode data natively on the backend
• Unicode encoding must be set as default in the browser
• Any QuickBase functionality that relies on Javascript or AJAX support, DOES NOT work with Unicode

The last point is due to the two issues:

1. The bug with UTF-8 encoding in my previous post.

2. The fact the UTF-8 is not decoded properly as described here.

Same applies to the QuickBase Javascript client library. Of course, adding cross browser XML support and proper decoding would fix it.

:1: parser error : Input is not proper UTF-8, indicate encoding !
Bytes: 0xA0 0x20 0xA0 0x3C

Use this command:

use Encode:
$string1 = decode("UTF-8", $input);

use HTML::TreeBuilder;
use XML::LibXML;

$html_code = '';

my $builder = HTML::TreeBuilder->new();
$xml_source = $builder->parse($html_code);
$xml_source->elementify();
$xml_source1 = $xml_source->as_XML();

my $parser = XML::LibXML->new();
$parser->recover(1);
my $doc = $parser->parse_string($xml_source1);
$xml_source2 = $doc->toString();

1. Saxon XSLT processor supports “streaming mode” which allows processing of files upto 20 Gbs. BUT this feature is only available in the commercial version.

2. An alternative to XSLT is something called STX or “Streaming Transformations for XML”, which is specifically designed to address this issue. HOWEVER, it is not a standard of any sort like XSLT and there are only two implementations.

3. There is a streaming XSLT processor released by a team at a national laboratory but I currently misplaced the link.

4. Apache Xalan XSLT Processor in incremental mode (note this is NOT true streaming since the entire original file is eventually loaded into memory).

For my project I choose #4 – Apache Xalan because (a) I wanted an open source solution and (b) I wanted to stick to the XSLT standard as opposed to STX. I might look into STX in the future to reduce the original XML file in size, and then further process it using standard XSLT tools.

Now the good news is that the next step in the XSLT standardization process at W3C is streaming with something called XSLT2++. Take a look at this O’Reilly news article and a blog post from Michael Kay (the editor of the XSLT WG at W3C). The bad news that it will take at least 18 months for the standards process and who knows how long for the actual implementations.

The short answer is no – JSON does not work in a pure client side environment without callbacks. This is due to the fact that JSON objects come back anonymous and when you include them in your page via SCRIPT tags, they do not initialize to anything. They must be passed to eval or to a function in order to become true Javascript objects. For example, this delicious feed is raw JSON. If you include it via a SCRIPT tag, it will not work.

An alternative is to use a callback, a proxy, something like Google’s Feeds API, XML HTTP Request if you are on the same domain or Flash if crossdomain.xml is defined properly.

After a look at the Gadget API, I whipped up a very small hack for this problem. It is an iGoogle gadget which embeds the mobile version of Google Reader (which fits perfectly inside iGoogle). It is a very simple gadget with Content Type = url and is basically just a glorified iFrame. As long as you are logged into Google Reader, it should work. I tested it under Firefox 3 and Opera 9.5 under Ubuntu 8.

To install this gadget, click here. For full source, click here. Comments are welcome to code /at/ shaftek [dot] org.

——- What follows is a somewhat technical discussion of some of the gory aspects of this gadget, if you are not a techy, feel free to skip it ——-

My initial goal was to make a notifier just like the Bloglines one, that simply shows how many unread items there are and a link to Google Reader. Unfortunatly, there is not official API, but there is an unofficial one which has been documented here. There is an API call called “unread-count” which returns the exact data I needed in either XML and JSON. However, in order to obtain it, you must be logged into Google Reader.

Here is where I ran into cross domain security issues with Javascript. In order to get the XML output of that API call, my code needs to share the same domain as Google itself. There is no service that Google offers that can do that probably for the security reasons. Flash via crossdomain.xml isn’t helpful either. Using a proxy wouldn’t help since I do not have access to the cookies for Google Reader. And to top it off, the content on iGoogle is not served from a Google.com subomain.

So the next obvious step would be JSON. HOWEVER, the unofficial reader API does not offer ability to have a callback function for the JSON format. The raw JSON format is useless since the browser does not offer access to it via innerHTML, and it by itself is not parsed.

The next alternative after that would be to use the Gadget API Fetch functions to request the XML or JSON directly. HOWEVER, we run into the same cookie problem as before – they are served via a server side proxy which is not on the same domain. To get around that problem one could use the Account Authentication API which does return the correct tokens. BUT, the Gadget API’s fetch functions do not support cookies which is the only way to use the security tokens once they have been obtained.

As a last alternative, I was planning on using the Fetch functions to do the account authentication and then a server side proxy via something like AppEngine or my own server, that can be passed the SID and then pass it on as a cookie. However, that would involve more time than necessary so I leave that exercise to the reader.

The end result is a hack that simply embeds the mobile version of Google Reader in iGoogle. It might not be very innovative but hey, it works.

1. For Subversion, I basically followed this guide written by Joe Maller. For 1&1 there are two important notes – you need to specify –without-neon in order to avoid errors with svn/python bindings, AND if you install everything into a single directory, it helps too.

2. For Trac, you need to download and extract Python 2.5. Then you can install it with ./configure –prefix=SOME DIRECTORY. After installation, just update your PATH in bashprofile and relogin. KEEP IN MIND: Subversion will only be available via SSH and only to a single user. 1&1 does not allow multiple SSH users on one account AND they do not have the SSH module installed in Apache. IF you are looking for a multiuser Subversion, try a different provider.

3. After Trac is installed, you can use trac.cgi or trac.fcgi for the web based stuff. HOWEVER, do change the shebang line to point to the Python 2.5 executable in your home directory.

4.  SQL Lite does not work on 1&1. Use MySQL instead.

Unfortunately, after spending a sizable amount of my day on this, I realized that I need multiuser access. 1&1 does not allow more than one SSH user so I wasted my time with this. Instead, I just got an account with DreamHost which will host SVN and Trac. While DreamHost isn’t the most reliable host in the world, it looks like I will be using 1&1 for the more reliable stuff like websites and Dreamhost for development.

This is a typical set-up on a cheap host, for more details check out the SVN and Trac Installation wiki.

It seems that when VBA is compiled, other libraries may import their own functions into the
global VBA namespace. What that means is if there is another Left function function that is global in some library, it would override the VBA built in function since the VBA native stuff is resolved last. A better description of this problem can be found at this DLL Hell site hosted by Walker Software.

In my wife’s instance, it turned out that the MSHTML library was the culprit, in particular the IMarkupPointer.Left function which for some reason was exposed globally. Microsoft has an article describing a similar problem with the Devshl.dll library.

What is the solution? To fully qualify the function name adding the namespace which would mean calling VBA.Left instead of plain Left. Of course, if you have millions lines of code that uses the plain function, you are in trouble. Being that is in VBA 6 which is not .NET and is not really being supported by Microsoft, tough luck.

Maybe it is time to try out Java or PHP?

1. First convert the incoming PDF to PostScript using XPDF‘s pdftops. This will flatten the transparencies. GhostScript’s pdf2ps tool DOES NOT do that.

2. Then convert the PostScript back to PDF using GhostScript‘s ps2pdf tool.

Both tools are open source and free (although watch out for GhostScript’s GPL license). One important point – pdftops requires a paper width and height unless you want to end up with 8×11 paper for everything. The width/height is specified in PostScript points which are 72 per inch.

BookChaser.Net

The old Amazon project had stopped working and I had taken it offline.

Comments are welcome to code /at/ shaftek [dot] org.

However, in the printing business DjVu is not used – rather everything needs to be in PDF. So in this post I will outline how I was able to sucessfully convert DjVu files to PDF using freely available tools. But first, here are some things that DID NOT work:
1. Converting DjVu to Postscript and then to PDF – takes too long.
2. Converting only the foreground layer or the mask layer in DjVu – loses some of the data.

Here is the software that is needed for the conversion to take place:
1. DjVuLibre .
2. LibTiff .

If you are running Windows, then you will need Cygwin and a Cygwin version of DjVuLibre. The compiled Windows version does not include TIFF support (although you can get this package from a site in Russia which included the TIFF support). LibTiff comes in a native Windows version.

Here are the conversion steps:
1. Convert DjVu file to TIFF using ddjvu.
2. Convert TIFF to PDF using tiff2pdf.

Assuming the input DJVU file is called “input.djvu” here are the steps:

djvu -verbose -format=tif input.djvu output.tif
tiff2pdf output.tif -o output.pdf

The ddjvu utility has an option to convert specific layers. One common mistake is to convert only the mask layer or the foreground layer . Technically speaking, the mask layer is the one that should have the actual text but in practice I have seen that the the DjVu encoder occasionally puts portions of the text in the background layer. Thus, if you only take the foreground or mask layers, you will lose those bits in the background. If your specific files don’t have that issue, that you should use the layer switch since it reduces file size and increases readibility.

The engine is called “ShafTag” and can be found at www.shaftag.com.

Comments are welcome at code /at/ shaftek [dot] org.