There is however, still a way of getting this functionality on the Kindle 4 NT, but it is quite fiddly and requires you to have some knowledge of Linux file systems, basic networking and SSH. I achieved this using a Linux (Ubuntu) PC, there instructions are probably largely similar for MACs too. Windows users will have to install some extra software tools and the networking bit will be different too (Don’t ask – I won’t know).

Basically all we’re going to do is move the screensaver images folder to the part of the kindle that is accessible over USB and creating a symbolic link to this location. However, the route from here to there is a bit contrived. If you’re not sure what you’re doing it’s best to ask a techo-literate friend to help out. Oh, it should also go without saying that this probably invalidates your warranty too.

Diagnostic Mode

The first thing we need to do is put the Kindle in to Diagnostic Mode.

1. Connect the Kindle to your PC with the USB cable.
2. Create a file on the Kindle called ENABLE_DIAGS
3. Unmount the Kindle and disconnect the USB cable.
4. Restart the Kindle
   
   [MENU] Settings [MENU] Restart
   
   This will take a few minutes.
5. You should now be in Diagnostic Mode.

Gaining Root Access

Next we need to connect to the Kindle as root which will allow us to fiddle around with it.

1. Connect the Kindle to your PC with the USB cable. It should NOT mount.
2. Enable USB Networking from the menu.
   
   Misc individual diagnostics > Utilities > Enable USBNet
3. The Kindle should now be a network device on your PC.
   
   ifconfig
4. Configure a IP address for the device.
   
   ip addr add 192.168.15.241/24 dev usb0
5. You should now be able to SSH in to the Kindle as root.
   
   ssh root@192.168.15.244
   
   The password is “mario”.
   
   Edit: If “mario” doesn’t work try this tool.
6. You now have root access to your Kindle

Moving the Screen Savers

Now we’re going to move the screensavers from their existing location to a new folder in /mnt/us/, which is the folder accessible via USB.

1. First mount the required partition.
   
   mount /dev/mmcblk0p1 /mnt/base-mmc
2. Backup the existing screensavers.
   
   mv /mnt/base-mmc/opt/amazon/screen_saver/600x800 /mnt/base-mmc/opt/amazon/screen_saver/600x800.bak
3. Create a folder for custom screen savers.
   
   mkdir /mnt/us/screensaver
4. Create a link from the screen saver location to the new folder.
   
   ln -sfn /mnt/us/screensaver /mnt/base-mmc/opt/amazon/screen_saver/600x800
5. You can optionally copy the existing screen savers to the new folder if you want to keep them.
   
   cp /mnt/base-mmc/opt/amazon/screen_saver/600x800.bak/* /mnt/us/screensaver/
6. End the SSH session.
   
   exit
7. Exit Diagnostic Mode
   
   Exit, Reboot or Disable Diags > Disable Diagnostics > To continue – FW LEFT
8. Wait a few minutes for the Kindle to reboot.
9. That’s the screen savers moved!

Setting Custom Screen Savers

Now you can copy your own screen saver images to your Kindle. All you need to do is connect your Kindle to your PC with the USB cable and copy the images you want in to the screensaver folder.

The images files must be 600×800 pixels. I think they also have to be PNG files and 72dpi in 32bit indexed greyscale. Some people on the forums have said that this isn’t necessary, others say it is. But this format works fine for me where others didn’t.

There are various sites out there with Kindle screen savers to download, you may or may not need to do some image conversion. I leave it to you to experiment.

You also have to researt the Kindle fully ([MENU] Settings [MENU] Restart) before the new screen savers will work.

Have fun!

Edit: Here’s the original Kindle 4 Screen Savers.

First up, use rails to generate a new plugin.

$ rails generate plugin HelloWorld

This will create a folder in /vendor/plugins/hello_world containing template files for the plugin. What it won’t do is create a test file for RSpec, so we’ll create it manually later. This is a known issue.

In the plugin folder there’s a few files, most of which are self-explanatory. We’re only going to be interested in hello_world/init.rb and hello_world/lib/hello_world.rb.

hello_world/init.rb tells Rails what to do with the plugin. We’re not going to do too much, so we just need to require the main class file.

# Include hook code here
require 'hello_world'

Next we create the main class in hello_world/lib/hello_world.rb.

# HelloWorld
class HelloWorld
end

Before we go any further we should set up a test, because we do things properly. RSpec tests live in /spec so we’ll create a folder for plugin tests and create a spec file for our plugin there.

$ mkdir /spec/plugins
$ touch /spec/plugins/hello_world_spec.rb

Lets define a simple test for our plugin in /spec/plugins/hello_world_spec.rb

require 'spec_helper'
describe HelloWorld do
  describe "should have method" do
    it "'hi'" do
      response = HelloWorld.instance_methods.include? :hi
      response.should == true
    end
  end
end

We’ve done a few things here, firstly we’ve required the RSpec helper file, all RSpec tests need this. The first describe block is defined with the name of the class we are testing. Then we’ve added a test to check that a method exists. If you run the test, it should fail.

$ rspec /spec/plugins/hello_world_spec.rb

Now we can add a method to the HelloWorld class, which should get the test to pass.

# HelloWorld
class HelloWorld
  def hi
    "Hello World!"
  end
end

That’s it!

Now you have a working plugin, you can use it in your Rails application. You can create objects in controllers and call functions from views, there’s no need to explicitly require the plugin anywhere.

# app/controllers/pages_controller.rb
class PagesController < ApplicationController
  def hello
    @hw = HelloWorld.new
  end
end

<!-- app/views/pages/hello.html.erb -->
<p><%= @hw.hi %></p>

Here’s what you need to do to get going.

1. Root the phone (this is very easy). Follow the instructions on Lifehacker.
2. Download ES File Explorer from the market
3. Enable these settings
   
   • Settings>Root Explorer
   • Settings>Mount File System

This will give you writeable access to the file system, now you can fix those annoyances.

Disable the Start Up Sound

1. Rename /etc/PowerOn.wav to /etc/PowerOn.wav.old

Disable Camera Shutter Sound

1. Create a text file /data/local.prop
2. Add this line ro.camera.sound.forced=0
3. Restart your phone

Disable Battery Full Sound

1. Rename /system/media/audio/ui/LowBattery.ogg to /system/media/audio/ui/LowBattery.ogg.bak

More Tips

If you know of any other tweaks, let me know. I’ll be keeping this list updated.

There’s also lots of power user features built in, so check them out too.

Here’s another bit of Gitty loveliness for you: Custom Config Parameters.

The primary configuration file in Git is found in .git/config. In here are the configuration parameters for your repository. Git provides a tool to manage this file – git config. Handily this tool lets you store your own configuration parameters too.

How to do it

If you have a look inside .git/config you’ll see that data is structured in key-value pairs grouped in to sections.

[branch "master"]
	remote = origin
	merge = refs/heads/master

Which is accessed by running a command like this…

-> git config branch.master.remote
origin

And modified like this…

-> git config branch.master.remote newValue

You can define a new section to store your own data like this…

-> git config mydata.mykey valueA

You can store multiple values too…

-> git config --add mydata.mykey valueB

And fetch them all like this…

-> git config --get-all mydata.mykey
valueA
valueB

Delete a single value like this…

-> git config --unset mydata.mykey valueB

Delete all key values like this…

-> git config --unset-all mydata.mykey

And to remove a whole section…

-> git config --remove-section mydata

What to do with it

That’s great, but what can you do with it?

Why not use it to store parameters for your workflow scripts? Here’s some ideas.

• The locations of CSS and JS files to be minified
• Compilation output directory
• The latest version release number (if your not a tag fan)
• Feature branch meta data (owner, decription, etc.)
• A list of deployment servers

If you use this feature in your scripts, drop a comment below.

"Unable to mount SAMSUNG_Android Error initialising camera: -60: Could not lock the device"

Samsung uses it’s own software to sync and update the phone called Kies. Kies is only available for Windows (naturally), not Mac or Linux. But you can still use the USB storage and USB tethering, you just have to enable USB debug mode.

Settings > Applications > Development > USB Debugging

Now when you connect the phone with the USB cable, you can choose to mount the USB storage from the status bar.
Alternatively, you can use the USB tethering.

Settings > Wireless and Network > Tethering and Portable Hotspot Settings > USB Tethering.

Edit also check out my post on Galaxy S2 tweaks.

$ myprogram -i /input/file.txt -o /output/file.txt

This is easy enough to achieve in Java, the snippet of code below shows you how.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class getArgs {
 
    public static void main(String[] args) {
 
        // Set defaults
        Integer i = 0;
        Double  d = 0.0;
        String  s = "";
 
        // Get input arguments from command line
        for(int j=0; j<args.length; j++){
            try{
                if ( args[j].equals("-i") ) i  = Integer.parseInt(args[j+1]);
                if ( args[j].equals("-d") ) d  = Double.parseDouble(args[j+1]);
                if ( args[j].equals("-s") ) s  = args[j+1];
            }catch(Exception e){
                System.out.println("Usage: getArgs <options>");
                System.out.println("Options:");
                System.out.println(" -i  An Integer Value");
                System.out.println(" -d  A Double Value");
                System.out.println(" -s  A String Value");
                System.exit(1); // Exit with error code 1
            }
        }
 
        // Print arguments
        System.out.println("Integer " + i.toString());
        System.out.println("Double  " + d.toString());
        System.out.println("String  " + s);
 
    }
 
}

This program has three parameters for an integer, a double and a string. If the value provided is incompatible, the help message is displayed.

Spaces in strings can be handled with backslash escape characters or by enclosing the whole string in quotes.

$ java getArgs -i 4 -d 3.14 -s 'Hello World'
Integer 4
Double  3.14
String  Hello World

When using a grid based layout for a WordPress theme that has a horizontal row of widgets (perhaps in the footer) you’ll want to be able to apply alpha and omega classes to the first and last widgets. The problem is that register_sidebar function only allows you to specify classes that are applied to all widgets in the sidebar. Fortunately a filter exists at just the right place to make this happen.

The WordPress filter dynamic_sidebar_params (which is oddly undocumented in the Codex) is called before each widget is drawn. It allows you to modify the parameters used to draw the widget, for example adding targeted classes, which is what the function below does.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

add_filter('dynamic_sidebar_params','widget_alpha_omega');
function widget_alpha_omega($params){
    /* Get the ids of this sidebar and widget*/
    $sidebar = $params[0]['id'];
    $widget   = $params[0]['widget_id'];
 
    /* Get number of widgets in this sidebar */
    $num_widgets = $params[1]['number'];
 
    /* Get data for all registered widgets */
    $all_widgets = wp_get_sidebars_widgets();
 
    /* Finish if no widgets set in this sidebar */
    if ( !isset($all_widgets[$sidebar]) || !is_array($all_widgets[$sidebar]) ) { return $params; }
 
    /* Set alpha class for first widget */
    if ( $all_widgets[$sidebar][0] == $widget ) {
        $params[0]['before_widget'] = preg_replace( '/class="/', 'class="alpha ', $params[0]['before_widget'] );
    }
 
    /* Set omega class for last widget */
    if ( $all_widgets[$sidebar][$num_widgets-1] == $widget ) {
        $params[0]['before_widget'] = preg_replace( '/class="/', 'class="omega ', $params[0]['before_widget'] );
    }
 
    /* Return modified params */   
    return $params;
}

The function takes an array of parameters as input. This is mostly the parameters defined in register_sidebar (or the defaults) plus a few bits and bobs.

The first thing the filter function does is get the ids of the widget that is being created and the sidebar it is being created in. You could use this information to apply different filters to different sidebars and widgets. I haven’t done that here.

Next it gets the total number of widgets in the sidebar, it’ll need this later. Then it gets an array of all the sidebars and the registered widgets in each. A quick sanity check makes sure that the sidebar actually contains some widgets, before continuing.

Then the before_widget strings are modified to add the alpha and omega classes to the first and last widgets in the sidebar. Note the use of $all_widgets[$sidebar][0] for the first and $all_widgets[$sidebar][$num_widgets-1] for the last.

Finally the modified parameters array is returned back to WordPress.

One of the points to consider when making changes to cached files, is that the browser won’t know to download the modified file without being prompted to re-fetch the manifest file.

A common workaround is to make some change to the manifest file to force an update, typically using a version number. This works fine in most instances, but Firefox stubbornly ignores this. The usual workaround for Firefox is to set the manifest file to expire by using the following rule in the .htaccess file.

1
2
3
4

<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType text/cache-manifest "access plus 0 seconds"
</IfModule>

While this works, it’s not much good if your’re not using Apache, or if your host has blocked .htaccess usage.

However, you can achieve the same effect by setting the HTTP headers in PHP. Put the following lines in to top of your manifest file, and change the extension to .php.

1
2
3
4
5

<?php
header("Content-type: text/cache-manifest");
header("Cache-Control: no-cache, must-revalidate");
header("Expires: ".date(DATE_RFC1123));
?>

The first line sets the content type to text/cache-manifest, this is a requirement for manifest caching to function. The second tells the browser not to cache the file. And in case the browser ignores that, the third line expires the file immediately.

Now the browser will keep the manifest cache up-to-date, but still cache the files you want.