Since I was now ready to paint, I started preparing my garage. I used a couple of 10'x20' plastic drop cloths to create a "paint booth". I also purchased a small space heater to help keep the garage warm. Winter is not the ideal time to be painting since the paint tends to need a temperature between 50 and 70 degrees Fahrenheit in order to dry properly. It's also very humid where I live in the Bay Area. We already had a dehumidifier which I moved to the garage to keep the humidity level down.

On painting day(a Sunday), I woke up early, removed the bumper cover, and moved it to the paint booth. I cleaned the entire surface with wax and grease remover. I then applied a few coats of adhesion promoter. This is a clear primer that is designed to help paint stick to different types of surfaces(including plastic). After letting the adhesion promoter dry for about 20 minutes, I started applying the primer. As I started priming, I noticed that the lighting in my garage isn't quite adequate for painting. In addition, I ran out of primer before finishing the second coat. The bumper cover had pretty good coverage, but there were still a few spots that definitely needed more primer. As it turns out, rubberized primer is not carried by any auto parts stores in my area, so I was out of luck trying to finish painting on the same day.

I recommend City Paints(in SF, near 7th and Folsom) if you live in the SF Bay Area and need auto paint. They carry a large variety of auto paint and auto care supplies. Prices were better than most of the online stores that I found. In addition, they will also fill aerosol cans with paint for around $11/can.

The following weekend, I cleaned the bumper cover again and started over with the painting. It turns out that wax & grease remover will eat through rubberized primer(and perhaps also regular primer), so be careful if you need to clean a primed surface. I applied three coats of primer and then wet-sanded with 400 grit paper.

First coat of primer

Setup for wet sanding outside

I started out with the bumper cover supported by saw horses and facing up. It turns out that it's much easier to paint a vertical surface than a horizontal surface, especially with aerosol paint. I ended up using a rope to suspend the bumper cover from the ceiling for the color and clear coats.

Hanging setup for painting

I then applied color coats which I let dry overnight. The final color coat should not be sanded, but earlier color coats can be sanded. One of the issues with metallic colors is that the thickness of the color coat affects the final color and appearance of the paint job. If I were redoing the process, I would sand between the second and third color coats since there are a few areas where the paint ended up uneven. One of the issues with metallic colors is that the thickness of the color coat affects the final color and appearance of the paint job.

The following morning I applied four clear coats, let the bumper cover dry, and then put it back on the car. The clear coat has to dry for several days before it can be polished. An additional thirty days are required for drying before the surface can be waxed. The bumper cover color matches the rest of the car very well. In the interest of potentially saving money in the future, I also bought a can of Dupli-color paint from my local auto store. Dupli-color paint is around $7/can, whereas the paint I purchased from paintscratch.com was around $20/can. The Dupli-color paint also matches the car reasonably well, but the match is not quite as good as the paintscratch.com paint. Most people would probably not notice the difference in color unless it was pointed out to them.

I was able to complete the job with two cans each of primer, color, and clear coat. I would recommend three cans since two leaves a pretty small margin for error and repainting.

Since I was saving a fair amount of money by repairing the bumper cover myself, I was able to buy a nice auto polisher and supplies from Griot's Garage. A week after painting, I first wet-sanded with 1000 grit paper. I then used some aggressive polishing compound with the polisher to polish the bumper cover. This leaves a shiny surface, although it doesn't quite match the rest of the car in terms of shininess. I'm hoping that the eventual sealant and wax will take care of this issue.

Part One

It all started with a bang. My car was involved in a minor accident and sustained some damage to the bumper. The initial repair quote was a minimum of $800($200 for a new bumper and the remainder for labor). Rather than paying someone else to have fun fixing my car, I decided to do the work myself. In addition, since I wasn't driving the car at the time of the accident, the driver gets to pay for my new tools, supplies, and fun…perfect!

Damage

Damage to foam and bent supports

My bumper cover paint had been scraped down to bare plastic in a few places. The impact also forced the license plate into the bumper cover causing some deformation. It's also noticeable in the pictures that the bumper had been pushed in and no longer lined up with the headlights. I removed and cleaned the bumper cover and took a look at the supporting structures. On my car(2003 Camry), there is a horizontal metal support that runs between the headlights and under the top of the bumper cover. This support was clearly bent out of shape. There is an additional vertical support that runs up the center of radiator. This support also appeared to be bent in some way, but I was unable to determine how much. I attempted to straighten the horizontal support, but without a reference I was unable to make much progress. The first step then was to order a new horizontal support and grille. I was able to purchase the support and grille from autopartswarehouse.com for $58(including shipping).

New support and old support

I ordered a couple of books on auto restoration and painting and started doing some research. I wanted to determine if it would be possible to paint the bumper cover at home. Professionals use an air compressor and spray gun for paint jobs, but the average home air compressor can't do the job properly. However, it is possible to get matched auto paint in aerosol spray cans(paintscratch.com), which makes painting more feasible. As a result, I decided that I would repair and paint the bumper cover myself. As with any paint job, the secret to success(and the bulk of the effort) is in the preparation

Since the bumper cover is plastic, hammering out the dents wasn't an option. I would have to use a specially designed bumper filler(two-part epoxy) by 3M/Bondo to create a smooth surface. Many traditional auto repair fillers and primers cannot be used with bumper covers because these products are firm and bumper covers are flexible. If normal filler is used, it's possible that the entire repaired area may separate from the bumper cover when it flexes.

The filler only adheres adheres to plastic, so I used a random orbital sander with 100-grit sand paper to strip away the paint. As it turns out, It's slightly liberating the first time you take a sander to your car. Whether the car will look good at the end is something else entirely. I used an automotive wax + grease remover(smells like super rubbing alcohol) to prepare the surface for filling. There were a few areas that needed a fair amount of filler, so I ended up making the repairs over a few weekends and probably spent between 5 and 10 hours on this part of the project. The filler has a working time of a few minutes and is sandable after 20-30 minutes. I used a long, flexible sanding board to ensure that the filler that I was building up would match the overall curve of the bumper.

Eventually, I reached a point where the bumper was starting to look pretty good. There were still small holes in some places in the filler. I switched to using two-part glazing putty. This is initially much more fluid than the filler and can be spread to a much smoother finish. After a few rounds of putty + sanding, I was done with most of the repair work. I then wet-sanded with 220 grit paper to take out any leftover imperfections in the filled areas. I also wet-sanded the rest of the bumper cover, since new paint adheres better to a surface that has been scuffed.

Initial round of filling and sanding

Done filling and sanding

Part Two

Some of the NDK samples include this setting, which will cause your Java code to be left out of the final APK.

The warnings are harmless, but a clean build is a happy build, so we might as well try and get rid of them. The ProGuard Manual actually describes what needs to be done, but it only provides a solution for the case where input jars are specified individually:

-injars  in1.jar
-injars  in2.jar(!META-INF/MANIFEST.MF)
-injars  in3.jar(!META-INF/MANIFEST.MF)

When using ProGuard in the Android build process, the default behavior is to pass in all input jars in a giant delimited(semi-colon on Windows) blob. I have done some experimentation, but was unable to determine how an input filter can be used when multiple jars(having absolute paths) are passed in this way. Fortunately, it's not too difficult to change the build process to pass in a list of input jars individually and with individual filters.

This is the relevant section of the standard Android build.xml(starting around line 700):

<!-- Build a path object with all the jar files that must be obfuscated.
	 This include the project compiled source code and any 3rd party jar
	 files. -->
<path id="project.jars.ref">
	<pathelement location="${preobfuscate.jar.file}" />
	<path refid="jar.libs.ref" />
</path>
<!-- Set the project jar files Path object into a single property. It'll be
	 all the jar files separated by a platform path-separator.
	 Each path must be quoted if it contains spaces.
-->
<pathconvert property="project.jars" refid="project.jars.ref">
	<firstmatchmapper>
		<regexpmapper from='^([^ ]*)( .*)$$' to='"\1\2"'/>
		<identitymapper/>
	</firstmatchmapper>
</pathconvert>

<mkdir   dir="${obfuscate.absolute.dir}" />
<delete file="${preobfuscate.jar.file}"/>
<delete file="${obfuscated.jar.file}"/>
<jar basedir="${out.classes.absolute.dir}"
	destfile="${preobfuscate.jar.file}" />
<proguard>
	@${proguard.config}
	-injars       ${project.jars}
	-outjars      "${obfuscated.jar.file}"
	-libraryjars  ${android.libraryjars}
	-dump         "${obfuscate.absolute.dir}/dump.txt"
	-printseeds   "${obfuscate.absolute.dir}/seeds.txt"
	-printusage   "${obfuscate.absolute.dir}/usage.txt"
	-printmapping "${obfuscate.absolute.dir}/mapping.txt"
</proguard>

The directives above create a new object that combines the location of the compiled jar along with other jars that were used during compilation. These locations are then joined into a string by the pathconvert task, which also does some transformation to ensure that paths containing spaces are quoted properly. Finally, the string from pathconvert(stored in project.jars) is passed into proguard via the statement: "-injars ${project.jars}"

This is the same section of my updated build.xml:

<!-- Set the project jar files Path object into a single property. It'll be
	 all the jar files separated by a platform path-separator.
	 Each path must be quoted if it contains spaces.
-->
<pathconvert property="project.jars" refid="jar.libs.ref" pathsep=" ">
	<firstmatchmapper>
		<regexpmapper from='^([^ ]*)( .*)$$' to='-injars "\1\2"(!META-INF/MANIFEST.MF)'/>
		<regexpmapper from='(.*)' to='-injars \1(!META-INF/MANIFEST.MF)'/>
	</firstmatchmapper>
</pathconvert>

<mkdir   dir="${obfuscate.absolute.dir}" />
<delete file="${preobfuscate.jar.file}"/>
<delete file="${obfuscated.jar.file}"/>
<jar basedir="${out.classes.absolute.dir}"
	destfile="${preobfuscate.jar.file}" />
<proguard>
	@${proguard.config}
	 -injars       ${preobfuscate.jar.file}
	 ${project.jars}
	-outjars      "${obfuscated.jar.file}"
	-libraryjars  ${android.libraryjars}
	-dump         "${obfuscate.absolute.dir}/dump.txt"
	-printseeds   "${obfuscate.absolute.dir}/seeds.txt"
	-printusage   "${obfuscate.absolute.dir}/usage.txt"
	-printmapping "${obfuscate.absolute.dir}/mapping.txt"
</proguard>

The goal of my changes is to preserve the manifest files from the original jar("preobfuscate.jar.file") and ignore(filter) the manifest files from the remaining input jar files. Since I haven't figured out how to filter input jars when passed in as a blob, I instead use the pathconvert task to transform each input jar location into a separate "-injars" statement with its own manifest filter. The property containing these locations is then passed into ProGuard directly via: "${project.jars}"

The solution isn't as clean as I would have liked, but it does fix the warnings.

# Simple demonstration of an 'implicit' return
def implicitReturn()
  "implicit return\n"
end

# Simple demonstration of an 'explicit' return.  Using an explicit return,
# even within a block, will exit the function. 
def explicitReturn()
  examples = ["pangolin", "cat", "macgyver"]

  largerExamples = examples.map { |item|
    # Explicit return will return the first item in uppercase, rather than
    # allowing us to map our array 
    return item.upcase
  }

  #This line will not be executed
  largerExamples
end

print implicitReturn() # Output: implicit return
print explicitReturn() # Output: PANGOLIN

On a semi-related note, Martin Hsu provided my Pangolin inspiration: http://www.martinhsu.com/pangolin-rider-p-50.html