Vorbereitungen für App-Debugging auf einem Android Gerät

Möchte man seine App auf ein Smartphone über eine IDE installieren, so müssen vorher ein paar Einstellungen am Smartphone durchgeführt werden:

"Unbekannte Quellen" aktivieren:

• Damit wird die Installation von Apps erlaubt, die nicht über den Playstore installiert werden
• Einstellungen -> Optionen -> Sicherheit -> aktiviere "Unkebannte Quellen"

"USB-Debugging" aktivieren:

• Einstellungen -> Optionen -> Entwickleroptionen -> aktiviere "USB-Debugging"
• Falls ihr keine Entwickleroptionen angezeigt bekommt, so könnt ihr diese wie folgt aktivieren:

• Entwicklermodus aktivieren: Einstellungen -> Optionen -> Geräteinformationen -> Klicke 7mal auf "Buildnummer"

Wenn ihr unter Windows arbeitet, dann werdet ihr wahrscheinlich Treiber für Euer Smartphone brauchen.
Auf der OEM USB Drivers Seite findet ihr eine Anleitung für die Installation und
eine Liste mit den gängigsten Smartphoneanbietern.

Da ich selbst ein Samsung S4 habe, kann ich Samsung Android USB Treiber für Windows ohne Kies empfehlen.

Es kann sein, dass ihr den ADB Server neu starten müsst, bevor die IDE eurer Gerät erkennt.
Außerdem solltet ihr noch das USB-Debugging auf eurem Gerät zulassen:

Screenrecording with KitKat

Here is a short introduction how to use the new feature:

• connect your device
• open command line 
• go to adb directory (in AS: android-studio/sdk/platform-tools)
• with the following command you cann see all available options:
• adb shell screenrecord --help

• recording a video:
• adb shell screenrecord /sdcard/test.mp4
• recording video with special size:
• adb shell screenrecord /sdcard/test1.mp4 --size 1920x1080

Action Bar UI TAB NAVIGATON

Since Android 3.0 there was added a window feature to the API called "action bar"  (Design Patterns).
The action bar provides two navigation modes: tabs and drop-down-list.

Before you start to develop an app you make some basic decisions about the UI Design.
If you decide to use the action bar with "NAVIGATION_MODE_TABS" you have to make you familiar with the android system and how it handles this navigation mode:
Sometimes action bar tabs are showing as drop-down-list, this behaviour can be helpful to save space.
But it's also annoying if you expect tabs and the system shows a drop-down-list (this issue is tracked here; good explanation on SO by CommonsWare).

Now, how to solve this issue?

• first you have to think about your UI layout and if you really want to show always tabs you have to take a "ViewPager" with "PagerTabStrip".
• if you already developed an app there are some workarounds (described in this post ): one of this is very simple: just set the navigation mode of the action bar after you're adding the tabs.

MenuDrawer in Android

Usability ist ein wichtiger Aspekt von Apps. Je einfacher und intuitiver diese zu bedienen sind, desto größer ist die Akzeptanz des Users und damit desto größer der Erfolg einer App.

Mit dem sogenannten MenuDrawer lässt sich die Bedienbarkeit einer App enorm erhöhen, da dem Nutzer jederzeit eine Menü-Struktur angezeigt werden kann (ohne Back-/ Up-Button).

In diesem Beitrag möchte ich ein Besipiel vorstellen, wie ein MenuDrawer in Android mit Hilfe von Fragmenten realisiert werden kann:

• Das Hauptlayout (main.xml) besteht aus zwei Framelayouts: Ein Framelayout wird für den Inhalt der Fragmente, das andere wird für die Ansicht des Menüs verwendet.

• Um ein Menü anzuzeigen wird natürlich auch eine entsprechendes Menü-Layout benötigt (bspw. ListView, ExpandableListView). In diesem Bsp. wird ein LinearLayout verwendet, das aus einer ExpandableListView (-> für das Menü) und einer View (-> füllt den restlichen Screen, dies macht v.a. bei Tablets Sinn) besteht: 

• In der Activity, die das layout main.xml zugewiesen bekommtenhat und somit auch den MenüDrawer anzeigen soll, wird das Menü zunächst initialisiert. D.h. das Framelayout "main_menu" erhält nun das Layout menu_drawer_layout zugewiesen (desweiteren wird ein Objekt MyMenuDrawer angelegt, das von "FrameLayout" erbt und für die Ansicht des Menüs zuständig ist -> siehe Punkt 4. ):

• Das Objekt MyMenuDrawer benötigt lediglich drei Funktionen, um die entsprechenden Animationen zu setzen und das Menü ein-/ auszublenden:

Widgets

Neulich habe ich mich mit dem Thema Widget in Android auseinander gesetzt. Da ich bisher noch nichts mit Widgets gemacht hatte, schien es mir sinnvoll einen kurzen Post dazu zu schreiben:

Ein Widget in Android ist quasi ein Broadcast-Receiver, der im Manifest angemeldet wird. Das erwähne ich hier gleich als Erstes, da ich mir das Widget wie eine Art Fragment bzw. Activity vorgestellt hatte, also mit einem eigenen Lifecycle. Das ist aber nicht so! Ein BroadcastReceiver "lebt" quasi so lange, wie seine onReceive() Methode aufgerufen wird. D.h. konkret, dass keine Daten dauerhaft in meinem BroadcastReceiver gespeichert werden (das kann damit gelöst werden, indem die Daten entweder in einer DB, auf der Festplatte gespeichert werden oder einfach in den System Properties abgespeichert werden). Aber erst mal eins nachdem anderen:

• Damit ein App-Widget existieren kann, werden folgende Objekte benötigt:
• AppWidgetProviderInfo -> beschreibt die Meta-Daten für das Widget (Layout, Häufigkeit von Updates usw.)
• AppWidgetProvider -> das ist unser "BroadcastReceiver" (hier werden die Funktionen definiert, die ausgeführt werden, wenn ein Button im Widget angeklickt wurde)
• Widget Layout
• AppWidgetConfigure -> muss der User, bevor er das Widget nutzen kann, Einstellungen vornehmen, so können diese in einer gesonderten Activity durchgeführt werden. Werden keine Einstellungen benötigt, so kann dieser Teil ignoriert werden

• Eine gute Anleitung ist auf der Android-Developer Seite zu finden
• Hier möchte ich nur eine kleine Liste der wichtigen Punkte erwähnen, die für ein funktionsfähiges Widget benötigt werden
• zunächst sollte das Widget im Manifest deklariert werden (-> siehe Anleitung)

• als nächstes werden die AppWidgetProviderInfos in einem Unterordner der Resourcen erstellt (-> res/xml)

• dann wird das App-Widget Layout erstellt (-> hierzu auf jeden Fall den Widget-Layout Abschnitt in der Anleitung durchlesen, da nicht alle Elemente von einem Widget unterstützt werden, Bsp.: EditText)
• zum Schluß wird der Provider (-> also der BroadcastReceiver) erzeugt

• Optional kann am Ende die AppWidgetConfigure Activity initialisiert werden (diesen Punkt lasse ich aber vorerst mal weg)

Nachdem man nun weiß wie ein App-Widget erstellt wird wäre es noch schön zu wissen, wie die Kommunikation in so einem Widget aussieht. Grundsätzlich läuft die Kommunikation mit Hilfe von PendingIntents (grob: Kombination aus einem Intent und den entsprechenden Ziel, wobei Ziel eine Activity/ Fragment oder das Widget selbst sein kann) ab. Hierzu habe ich mir mal ein paar Fälle überlegt die eintreten könnten und wie dann die entsprechende Kommunikation aussieht:

• Kommunikation innerhalb des Widgets (es wird ein Button gedrückt und dieser aktualisiert den Inhalt des Widgets)

• Kommunikation zwischen Widget und App
• Widget initialisiert App

• App erzwingt ein Update des Widgets

Viel Spaß beim ausprobieren!

Get data over HTTPConnection

Bei Online-Apps bietet sich an, die Daten asynchron zu laden und damit die "User-Experience" zu erhöhen. Asynchron heißt, dass die App während die Anfrage an den Server geschickt wird bzw. auf eine Antwort vom Server gewartet wird, bereits Berechnung durchführt wie z.B. Vorbereitungen zur Aufbereitung der Daten.

Eine asynchrone Berechnung kann in Android mittels eines Async Tasks (kann von Vorteil sein v.a. in Kombination mit UI Threads) bzw. mit Hilfe eines Threads und einem Handler gelöst werden. Ein Post zu diesem konkreten Thema wird in Kürze folgen.

In diesem Beitrag möchte ich darauf eingehen wie man Daten über eine HTTPConnection erhalten kann.

Zunächst: Wie wird eine HTTPConnection zu einem Server hergestellt:


Wie erhält man nun die Antwort des Servers, nachdem die Verbindung steht und der Server die Anfrage erhalten hat?
Hier die Lösung:


Wie kann nun so eine Konvertierung von einem InputStream aussehen? Ich habe nun drei Beispiele:

• Bei der Server-Response handelt es sich um einen String (z.B. JSONResponse - das Schöne hier: mit dem result-String der readIt Funktion kann ganz einfach ein JSONObject erzeugt werden: JSONObject data = new JSONObject(responseString))

•  Bei der Server-Response handelt es sich um ein Image (wobei die Eingabe der Funktion die Request-URL ist)

• Bei der Server-Response handelt es sich um eine PDF 

One device to test almost every device

Mit dem Samsung Nexus 10 wird dem Drama der scheinbar endlosen Anzahl an Geräte bei Android endlich entgegen gewirkt.
Mit dem Nexus 10 lassen sich Geräte, die eine geringere Auflösung bzw. Bildschirmgröße haben imitieren.

Das funktioniert wie folgt:

1. öffne die Konsole und gebe den Pfad zur adb.exe an (diese befindet sich bei Windows Nutzern meistens unter C:\Users\<your name>\android-sdk\platform-tools)
2. um die Bildschirmgröße bzw. die Auflösung eines Gerätes herauszufinden können folgende Befehle eingegeben werden:
• adb shell getprop (allgemeiner Aufruf - hier werden alle Properties angezeigt)
• es gibt auch eine Möglichkeit die Eigenschaften eines Gerätes zu filtern:
• adb shell getprop | grep density
• adb shell getprop | grep display
3. Folgende Befehle ermöglichen eine Darstellung der entsprechenden Werte auf dem Nexus 10:
•  wichtig: bevor ein Befehl in der Konsole ausgeführt wird, muss der Bildschirm des Nexus 10 ausgemacht werden
• vor android 4.3
• adb shell am display-density <ppi to simulate>
• adb shell am display-size <your size e.g. 320x480>
• seit android 4.3
• adb shell wm density <ppi to simulate>
• adb shell wm size <your size e.g. 320x480>
• mit "reset" lassen sich die Einstellungen auch wieder zurück setzen, z.B.:
•  adb shell wm density reset
• (e.g. adb shell am display-size reset)

Hilfreiche Links:

• http://stackoverflow.com/questions/7527459/android-device-screen-size
• http://stackoverflow.com/questions/14322572/android-using-a-tablet-to-emulate-other-devices 
• Wikipedia Auflistung Display + Density  
• Roman Nurik Tip on G+ 

Import ZBar-lib into your Project via Eclipse

1. Lade die ZBar-Android-Lib als zip-Datei runter
2. entpacke die zip-Datei
3. Füge die Library deinem eigenen Projekt hinzu:
1. rechter Mausklick auf dein Projekt
2. wähle -> Select -> Import -> File-System
3. wähle über Browse den Pfad zurm zBar-Projekt/libs
4. wähle die Checkbox neben "libs"  und die Checkbox neben "Create top-level folder"
5. wähle Finish
4. Nun muss die lib noch dem Build-Path hinzugefügt werden:
1. wähle mit der rechten Maustaste zbar.jar (im libs Ordner deines Projektes zu finden) aus
2. wähle "Build-Path" -> "Add to Build-Path"

Google Maps Android v2 SupportMapFragment

Anders als die Android Fragmente, können die MapFragmente NICHT mehrfach initialisiert werden.
Korrigiert mich, falls ich falsch liege, aber ich hatte es so verstanden, dass MapFragmente einmalig als eine View initialisiert werden und diese auch explizit wieder entfernt werden müssen (so zumindest wird es in der API von SupportMapFragment beschrieben).

Nun hatte ich das Vergnügen zum ersten Mal Google Maps in eine App zu integrieren. Meine Anforderung an eine App sind grundsätzlich, dass diese Android Versionen bis Froyo (2.2) unterstützen sollten. Also muss in diesem Fall das SupportMapFragment verwendet werden (ich verwende bei meinen Projekten auch grundsätzlich die Sherlock-Library, damit die älteren Android Versionen die aktuellen Features nutzen können (wie diese in ein Projekt eingefügt werden kann, wird in diesem Post erklärt)).

In dem Beitrag habe ich bereits erklärt wie die Google Maps API v2 (und der entsprechende API Key) in das Projekt eingebunden werden kann. In diesem Beitrag möchte ich erläutern wie ein MapFragment hinzugefügt werden kann.

• erzeuge ein neues Android-Projekt
• Als erstes sollte ein Layout für die MainActivity-Klasse (diese erbt von SherlockFragmentActivity) erzeugt werden 
• in den meisten Fällen reicht es, wenn das Layout aus einem einfachen FrameLayout besteht, dann können die Fragmente an dieser Stelle ausgetauscht werden
• Als nächstes wird ein Layout für das Map-Fragment angelegt, das sieht wie folgt aus:

<fragment xmlns:android="http://schemas.android.com/apk/res/android"
         android:id="@+id/map"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         android:name="com.google.android.gms.maps.SupportMapFragment"/>

• Dann wird eine weitere Klasse "FragmentMap" erzeugt, die von SupportMapFragment erbt 
• Hierbei ist zu beachten, dass Fragmente immer einen leeren Konstruktor benötigen, sonst kann das in speziellen Fällen zu Fehlermeldungen führen. Dazu reicht es aus wenn man eine Funktion (z.B. newInstance()) schreibt, die einfach eine neue Instanz des entsprechenden Fragments zurückliefert

• Nun zur MainActivity:
• in der onCreate() Methode wird der FragmentManager (in meinem Fall handelt es sich um den SupportFragmentManager) aufgerufen und eine neue Instanz vom Fragment "FragmentMap" an die Stelle des FrameLayouts hinzugefügt:

        FragmentMap fragment = FragmentMap.newInstance();
        FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
        transaction.replace(R.id.fragment_content, fragment);
        transaction.addToBackStack(null);
        transaction.commit();

• Das ist eigentlich schon alles, was in der MainActivity passiert. Sobald diese aufgerufen wird, wird einfach an die Stelle des FrameLayouts das Map-Fragment hinzugefügt.

• Und jetzt noch zu "Fragment-Map":
• Es sollte folgender Code in der onCreateView() Methode stehen:

       View v = super.onCreateView(inflater, parent, savedInstanceState);
       return v;

• noch ein Link, den ich sehr hilfreich fand

• Das wars :) und viel Spaß beim ausprobieren

 

Google Maps Android API v2 zu einem Andoid-Projekt hinzufügen

Um eine Google Map in der eigenen App anzuzeigen, müssen zunächst einige Vorkehrungen getroffen werden:

1. Installiere mit Hilfe des SDK-Managers die Google Play Service library
2. Google Play Services sollte nun als Android library Projekt hinzugefügt werden (hierzu sollten die ersten zwei Punkte unter "Sample Code" beachtet werden: https://developers.google.com/maps/documentation/android/intro )
3. Bevor ein neues Projekt angelegt wird, sollte man sich seinen Google API Key holen, dazu sollten folgende Punkte beachtet werden:
• Hole dir den "Fingerabdruck" deines Zertifikates (Anmerkung: Android liefert bereits einen debug.keystore mit, damit können die ersten Testprojekte angelegt werden. Soll die App in den Play Store, so muss natürlich der entsprechene keystore verwendet werden mit dem die auch signiert wird)
• Get fingerprint of your debug certificate: http://stackoverflow.com/questions/2997348/cant-find-the-android-keytool (4step answer helped me)
• funktioniert analog mit dem "richtigen" keystore (Verzeichnisse und Befehle müssen angepasst werden) 
•  als nächstes wird in der Google API Console ein neues Projekt angelegt
•  Mit dem "Fingerabdruck" kann nun ein neuer Google API Key angelegt werden (dies wird unter folgendem Link ganz gut erklärt: https://developers.google.com/maps/documentation/android/start)
4. Lege ein neues GoogleMapsTest-Projekt an
5. Kopiere aus dem libprojekt der google-play-service library den /libs Ordner (liegt normalerweise hier: C:\Users\your_name\android-sdk\extras\google\google_play_services\libproject\google-play-services_lib\libs) in dein Projekt 
6. Auch dien android-support-v4.jar sollte in dem libs Ordner des GoogleMapsTest-Projekts liegen (sollte beim Anlegen eines neuen Projektes bereits im libs-Ordner enthalten sein, falls nicht, so muss dies manuell erledigt werden. Pfad zur support-library: C:\Users\your_name\android-sdk\extras\android\support\v4)
7. Der libs-Ordner im GoogleMapsTestProjekt sollte nun folgende Dateien enthalten:
• android-support-v4.jar
• google-play-services.jar
• google-play-services.jar.properties
8. Die beiden jar-Dateien im libs-Ordner müssen nun dem Build-Path des GooglemapsTest-Projektes hinzugefügt werden:
• rechte Maustaste auf die entsprechenden jar-Dateien 
• Build-Path
• Add to build path
9.  Füge deinen GoogleMapsTest-Projekt die Android library des Google Play Services hinzu (diese wurde in Punkt 2 erstellt):
• rechte Maustaste auf das Projekt
• Properties
• Wähle links "Android" aus
• Füge rechts unten eine library hinzu (Add -> wähle die library aus)
10. Nun kann das Manifest bearbeitet werden, indem alle entsprechenden permissions/features... hinzugefügt werden
• die entsprechenden Änderungen im Manifest werden ab dem Punkt "Adding the API Key to your application" unter folgenden folgendem Link https://developers.google.com/maps/documentation/android/start erklärt

Weitere hilfreiche Links zu diesem Thema:

• Kurz-Anleitung aller Schritte: https://docs.google.com/document/pub?id=19nQzvKP-CVLd7_VrpwnHfl-AE9fjbJySowONZZtNHzw

Installing ADT in Eclipse

[EDIT 12.03.2013:]
--------------------------
Eine gute Alternative für den Einstieg wäre das ADT-Bundle von Android. Es ist wirklich kinderleicht und gerade für Anfänger sehr hilfreich (manchmal aber auch für Fortgeschrittene :)).
--------------------------

Nachdem es doch nicht so einfach ist Eclipse mit den richtigen Packages für Android zu installieren, hier nun ein Weg, der bei mir funktioniert hat:

1. Für Windows-Nutzer: installiere eclipse mit 32-bit, denn mit der 64-bit Version ist es nicht möglich das ADT Plugin zu installieren!

2. Installiere das SDK (download: http://developer.android.com/sdk/index.html#download) unter dem Punkt USE AN EXISTING IDE (da ja Eclipse bereits in Schritt 1 installiert wurde)

Nachdem Eclipse installiert wurde:

3. Überprüfe deine Proxy-Einstellung --> Windows > Preference > General > Network Connection

• falls eine Firewall aktiv ist, so setze setze die Proxy-Einstellungen (Active Provider: Manual, Host: proxy, Port: 8080)

4. Installiere das ADT Plugin: Help > Install New Software > Add

• Name: ADT Plugin
• Location: https://dl-ssl.google.com/android/eclipse/
• Wenn an dieser Stelle Fehlermeldungen kommen, dass Komponenten noch fehlen, so kann dieser Link helfen: http://stackoverflow.com/questions/4249695/adt-requires-org-eclipse-wst-sse-core-0-0-0-but-it-could-not-be-found

5. Starte Eclipse neu nachdem die Software installiert wurde

6. Teile eclipse mit wo dein SDK liegt, dass im vorraus runtergeladen wurde --> Windows > Preference > Android > SDK Location
7. Fertig!

Was ich sonst noch brauche:

• Installation des kindle fire (http://g-ecx.images-amazon.com/images/G/01/sdk/Connecting_your_Kindle_Fire_to_ADB.pdf)
• Subversion (http://subversion.tigris.org/) 
• > Help > Install Software > ADD
• Name: Subclipse
• Location http://subclipse.tigris.org/update_1.8x
• SDK Installation über command line (http://bugsnpieces.blogspot.de/2011/10/installing-specific-android-sdk.html):
• öffne den Ordner <your path>/android-sdk/tools
• gebe folgendes ein:
• android help --> Liste möglicher Funktionen
• android list sdk --> Liste aller möglichen Updates sollte angezeigt werden
• Probleme bei der Installation über den SDK-Manager: Eine mögliche Lösung könnte die Proxy-Einstellung im SDK-Manager sein (Tools/Optionen)

OBB Pfad ändert sich mit android 4.2

Hat man eine App, die größer als 50MB ist, so hat man beim Google Play-Store ein Problem. Denn hier wird die Größe der Apps immer noch auf 50MB limitiert.
Trotz der Einschränkung gibt es dennoch Möglichkeiten, eine App mit mehr als 50MB in den Play-Store einzustellen.
Dazu werden Expansion-Files benötigt, in denen z.B. die Bilddaten ausgelagert werden können.

Es gibt zwei Möglichkeiten für die Expansion-Files:

• main-Datei
• patch-Dateien

Für beide Möglichkeiten werden zusätzliche Activities in der App benötigt, die quasi den Download der Zusatzdateien managen (DownloaderClient, DownloaderService, BroadcastReceiver).
Eine Anleitung mit Beispielcode kann bei Google nachgelesehn werden (http://developer.android.com/guide/google/play/expansion-files.html).

Hier möchte ich nun kurz den Weg beschreiben (-> main-Datei), wie man seine App im Vorfeld (bevor die App in den Play-Store gestellt wird), trotz der zusätzlichen Expansion Files zur APK, testen kann.

1. Zippe die auszulagernden Dateien
2. Bennene die gepackte Datei wie folgt um:
• main.{versionNumber}.{packageName}.obb

Diese obb-Datei kann nun über DDMS auf das Smartphone kopiert werden. Wichtig dabei ist es den richtigen Speicherort zu finden, denn dieser variiert je nach Version (und auch nach Endgerät). Habt ihr den falschen Speicherort für eurer Datei gewählt, so werdet ihr das sehr schnell merken, denn dann bekommt ihr die Fehlermeldung, dass die entsprechende Datei nicht gefunden werden konnten.

Für mein Galaxy Nexus galt folgendes:

• Pfad über DDMS (nach Version 4.1):

• storage/Android/obb ...

• jetziger Pfad über DDMS (nach Version 4.2):

• mnt/shell/emulated/obb

Für frühere Versionen (z.B. mit HTC Desire Version 2.3.5) galt

• mnt/sdcard/Android/obb

SQLDroid Error "Class Not Found"

Mit sqldroid-0.3.0.jar lässt sich eine Verbindung in Android zu einer Datenbank herstellen.
Dazu wird zunächst die Klasse "org.sqldroid.SQLDroidDriver" initialisiert, um dann mit Hilfe des DriverManagers die Verbindung aufzubauen.

try{
     Class.forName("org.sqldroid.SQLDroidDriver");
     File file = new File(pfad, filename);
     String url = "jdbc:sqlite:" + file.getAbsolutePath();
     Connection connection = DriverManager.getConnection(url);
}catch(Exception e){
     e.printStackTrace();
}

Wichtig dabei ist der richtige import der sqldroid-0.3.0.jar, damit diese Verbindung aufgebaut werden kann. Die jar Datei wird über den Build-Path dem Projekt hinzugefügt.
Jedoch kann es sein, dass der Treiber immer noch nicht gefunden wird und man die Fehlermeldung "Class Not Found" erhält.
Eine Möglichkeit, um dieses Problem zu beheben, ist es die .classpath Datei zu bearbeiten (Diese findet man im Projektordner).

Dort müsste eine Zeile wie folgt enthalten sein:
<classpathentry exported="true" kind="lib" path="sqldroid-0.3.0.jar"/>

Wichtig ist dabei, dass diese Zeile noch vor dem Eintrag vom src- und gen-Ordner steht.
Das hat zumindest bei mir geholfen.

import ActionBarSherlock

ActionBarSherlock unterstützt  die ActionBar für Versionen < 3.0 (Honeycrumb).
Damit man auf die library zugreifen kann sollte man folgende Schritte befolgen:

1. erstelle ein neues Projekt
2. wähle "Android Project from Existing Code"
3. wähle "Browse" und suche den Pfad an dem das ActionBarProject gespeichert wurde
4. wähle den Ordner library der ActionBarSherlock aus und klicke auf "OK"

Nun muss noch diese ActionBarSherlock-library deinem eigenen Projekt hinzugefügt werden:

1. Klicke mit der rechten Maustaste auf dein Projekt
2. wähle Properties
3. wähle im linken Teil-Fenster "Android"
4. klicke im rechten Teil-Fenster auf "Add" und suche das im oberen Schritt hinzugefügte ActionBarSherlock Projekt
5. Wenn dieser Schritt nicht funktionieren sollte, dann gibt es noch folgende Möglichkeit:
•  füge die actionbarsherlock.jar deinem Build-Path hinzu
• die jar findet sich im ActionBarSherlock-Projekt im Ordner bin

Mögliche Fehlermeldung beim anlegen des Projektes: jar mismatch.
Dein eigenes Projekt sollte eigentlich auf die android-support-v4.jar zugreifen, beim anlegen eines Projektes wird in den lib Ordner eine andere jar-Datei hinzugefügt. Die Lösung des Problems: einfach die jar-Datei im lib Ordner löschen bzw. wenn keine andere library benötigt wird kann auch der ganze lib Ordner gelöscht werden.