error fixing

tommytomatoe · tommytomatoe · commit 9ddcc8bb2c84 · 2011-07-10T15:40:15.000-04:00
diff --git a/resources/clean/adb.txt b/resources/clean/adb.txt
@@ -0,0 +1,75 @@
+### Android Debug Bridge :more information from: 
+http://developer.android.com/guide/developing/tools/adb.html
+
+[Press ENTER to continue reading, or Control+C to Quit]
+
+Android Debug Bridge (adb) is a versatile command line tool that
+lets you communicate with an emulator instance or connected
+Android-powered device. It is a client-server program that includes
+three components:
+-	A client, which runs on your development machine. You can 
+	invoke a client from a shell by issuing an adb command. Other
+	Android tools such as the ADT plugin and DDMS also create
+	adb clients.
+-	A server, which runs as a background process on your
+	development machine. The server manages communication
+	between the client and the adb daemon running on an emulator
+	or device.
+-	A daemon, which runs as a background process on each
+	emulator or device instance.
+
+### Issuing adb Commands
+
+You can issue adb commands from a command line on your development machine or from a script. The usage is:
+
+	adb [-d|-e|-s <serialNumber>] <command>
+
+### Commands
+
+adb devices     
+	-    Prints a list of all attached emulator/device instances.
+
+adb help        
+	-    Prints a list of supported adb commands.
+
+adb version     
+	-    Prints the adb version number.
+
+adb logcat      
+	-    Prints log data to the screen.
+
+adb bugreport   
+	-    Prints dumpsys, dumpstate, and logcat data to the screen, for
+                     the purposes of bug reporting.
+
+adb jdwp        
+	-    Prints a list of available JDWP processes on a given device.
+
+adb install <path-to-apk>
+        -    Pushes an Android application (specified as a full path to 
+		     an .apk file) to the data file of an emulator/device.
+
+adb pull <remote> <local>
+	-    Copies a specified file from an emulator/device instance to your 
+		     development computer.
+
+adb push <local> <remote>
+	-    Copies a specified file from your development computer to an 
+		     emulator/device instance.
+
+adb start-server
+	-    Checks whether the adb server process is running and starts it, 
+		     if not.
+
+adb kill-server
+	-    Terminates the adb server process.
+
+adb shell
+	-    Starts a remote shell in the target emulator/device instance.
+
+adb shell stop
+	-    Stops execution of an emulator/device instance.
+
+adb shell start 
+	-    Starts (restarts) an emulator/device instance.
+
diff --git a/resources/clean/zipalign.pdf b/resources/clean/zipalign.pdf
diff --git a/resources/clean/zipalign.txt b/resources/clean/zipalign.txt
@@ -0,0 +1,36 @@
+Zipalign: an Easy Optimization :more info here:
+http://developer.android.com/resources/articles/zipalign.html
+
+[Press ENTER to continue reading, or Control+C to quit]
+
+The Android SDK includes a tool called zipalign that optimizes the way an application is packaged. Running zipalign against your application enables Android to interact it more efficiently at run time and thus has the potential to make it and the overall system run faster. We strongly encourage you to use zipalign on both new and already published applications and to make the optimized version available - even if your application targets a previous version of Android. This article describes how zipalign helps performance and how to use it to optimize your app.
+
+In Android, data files stored in each application's apk are accessed by multiple processes: the installer reads the manifest to handle the permissions associated with that application; the Home application reads resources to get the application's name and icon; the system server reads resources for a variety of reasons (e.g. to display that application's notifications); and last but not least, the resource files are obviously used by the application itself.
+
+The resource-handling code in Android can efficiently access resources when they're aligned on 4-byte boundaries by memory-mapping them. But for resources that are not aligned (that is, when zipalign hasn't been run on an apk), it has to fall back to explicitly reading them - which is slower and consumes additional memory.
+
+For an application developer, this fallback mechanism is very convenient. It provides a lot of flexibility by allowing for several different development methods, including those that don't include aligning resources as part of their normal flow.
+
+Unfortunately, for users the situation is reversed - reading resources from unaligned apks is slow and takes a lot of memory. In the best case, the only visible result is that both the Home application and the unaligned application launch slower than they otherwise should. In the worst case, installing several applications with unaligned resources increases memory pressure, thus causing the system to thrash around by having to constantly start and kill processes. The user ends up with a slow device with a poor battery life.
+
+Luckily, it's very easy for you to align the resources in your application:
+
+>Using ADT:
+*The ADT plugin for Eclipse (starting from version 0.9.3) will automatically align release application packages if the export wizard is used to create them. To use the wizard, right click the project and choose "Android Tools"
+>> "Export Signed Application Package..." It can also be accessed from the first page of the AndroidManifest.xml editor.
+
+>Using Ant:
+*The Ant build script (starting from Android 1.6) can align application packages. Targets for older versions of the Android platform are not aligned by the Ant build script and need to be manually aligned.
+*Starting from the Android 1.6 SDK, Ant aligns and signs packages automatically, when building in debug mode. 
+*In release mode, Ant aligns packages only if it has enough information to sign the packages, since aligning has to happen after signing. In order to be able to sign packages, and therefore to align them, Ant needs to know the location of the keystore and the name of the key in build.properties. The name of the properties are key.store and key.alias respectively. If those properties are present, the signing tool will prompt to enter the store/key passwords during the build, and the script will sign and then align the apk file. If the properties are missing, the release package will not be signed, and therefore will not get aligned either.
+
+>Manually:
+*In order to manually align a package, zipalign is in the tools/ folder of Android 1.6 and later SDKs. You can use it to align application packages targeting any version of Android. You should run it only after signing the apk file, using the following command:
+
+	zipalign -v 4 source.apk destination.apk
+
+>Verifying alignment:
+*The following command verifies that a package is aligned:
+	zipalign -c -v 4 application.apk
+
+We encourage you manually run zipalign on your currently published applications and to make the newly aligned versions available to users. Also, don't forget to align any new applications going forward!
diff --git a/utility/apk_compress b/utility/apk_compress
@@ -67,7 +67,7 @@ COMP=5
 d=$HOME/android-utility/working-folder/mod-here-multi
 e=$d/original_apps
 cd $d
-ECHO "Welcome to Apk Compression Manager"
+echo "Welcome to Apk Compression Manager"
 echo
 echo "Compression Level set to $COMP"
 echo "[0 = no compression | 9 = high compression]"
diff --git a/utility/zipped_up b/utility/zipped_up
@@ -114,7 +114,7 @@ read num
 case $num in
  1) clear; zip_it; zipped_up;;
  2) clear; check_it; zipped_up;;
- 3) open $HOME/android-utility/resources/clean/zipalign.pdf; enter; zipped_up;; 
+ 3) cat $HOME/android-utility/resources/clean/zipalign.txt | more; enter; zipped_up;; 
  q) clear; exit;;
  *) echo; echo "Not a Valid Option" ; echo; enter; zipped_up;;
 esac
