Come faccio a creare l'SDK Android con API nascoste e interne disponibili?

Voglio ricostruire Android SDK (o meglio solo android.jar) per includere API nascoste e interne.

Non sono riuscito a trovare alcuna documentazione o discussione su come procedere. Ho già configurato un ambiente di build Ubuntu CyanogenMod che è in grado di costruire cm7.

Ora, ho letto che make SDK creerà l'SDK ma desidero creare un SDK che includa metodi e campi contrassegnati come nascosti utilizzando @hide. È possibile?

Quello che voglio fare è apportare modifiche a un'applicazione che utilizza API nascoste e per ricostruirla vorrei utilizzare l'SDK modificato.

Questo è quello che faccio sempre per usare l'API nascosta.

1. Crea il repository o scarica i jar da https://sites.google.com/site/hippunosource/home/android/androidnohide-apiwo-shi-yongsuru-rifurekushonha-wei-shi-yong
2. copia / target / common / obj / JAVA_LIBRARIES / framework_intermediates / classes.jar (meglio rinominarlo come qualcosa come framework_all.jar)
3. configura il percorso di compilazione del tuo progetto -> librerie -> aggiungi questi jars esterni. In Order and Export, spostalo verso l'alto e prima di android.jar

Ho svolto alcune indagini al riguardo e la mia conclusione è semplicemente: questo non può essere fatto senza un bel po 'di lavoro. Leggi il resto di questa risposta per i dettagli su ciò che ho trovato.

android.jarè in realtà costituito dall '"API pubblica" di framework.jare core.jarche si trova nel system/frameworks/dispositivo. android.jarè un tipo di ciò che chiamerei intestazione della libreria Java, tutte le implementazioni nel codice byte effettivo sono solo un throw new RuntimeException("stub");, questo ti permette di costruire contro android.jar(ad esempio in Eclipse), ma l'esecuzione deve essere eseguita su un dispositivo o un emulatore.

L'API pubblica di Android SDK è definita da classi / metodi / campi che non sono preceduti @{hide}dall'annotazione javadoc. Cioè tutto ciò che non è annotato è incluso nell'SDK.

android.jarè costruito dalle sorgenti situate in out/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediatescui è generato dallo strumento DroidDoc situato in build/tools/droiddoc.

DroidDoc è lo strumento (probabilmente adattato da javadoc, o utilizzando javadoc) che genera la documentazione effettiva di Android SDK. Come effetto collaterale, e probabilmente perché sta già analizzando tutto il javadoc, sputa anche gli stub Android che vengono quindi compilati in android.jarcui è distribuito nell'SDK.

Quindi, per includere gli elementi nascosti, potresti, se desideri includere solo parti specifiche, rimuovere l' @hideannotazione e ricostruire l'SDK.

Tuttavia, se vuoi includere tutte le parti nascoste, le cose diventano molto più complicate. È possibile modificare DroidDoc (la fonte pertinente è in build/tools/droiddoc/src/Stubs.java) in modo che nulla venga rilevato come nascosto. Questo è abbastanza banale e l'ho provato, tuttavia gli stub che vengono generati non si compilano affatto.

La mia conclusione a questo punto è che questo semplicemente non è fattibile. Gli stub generati se rimuovi la parte di DroidDoc che rileva le annotazioni nascoste, semplicemente non sono compilabili e richiederebbero un bel po 'di lavoro per essere compilati correttamente.

Quindi la mia risposta alle tue domande è: No, questo non può essere fatto senza fare molto lavoro. Scusate.

Una nota a margine sullo mkstubsstrumento. mkstubsvengono utilizzati quando crei un componente aggiuntivo SDK , ovvero i componenti aggiuntivi che puoi trovare nel gestore SDK di Android dai fornitori, ad esempio Samsung che ti fornisce un'API aggiuntiva per cose specifiche dei telefoni Samsung. mkstubsfa più o meno lo stesso del processo di generazione di stub DroidDoc, tuttavia non utilizza @hideannotazioni, utilizza un .defsfile che descrive quali pacchetti / classi / campi includere o escludere dal tuo componente aggiuntivo SDK.

Tuttavia, questo è tutto irrilevante per la domanda, poiché la build di Android SDK non utilizza lo mkstubsstrumento. (Sfortunatamente.)

Potremmo ricostruire i file * .jar dalla piattaforma Android.

Innanzitutto, collega ADB al tuo dispositivo. Quindi esegui:

adb pull /system/framework/core.jar .
adb pull /system/framework/framework.jar .

L' core.jarcontengono le librerie standard di Java ( java.*) e la framework.jarcontengono le librerie Android ( android.*). Non è ancora utilizzabile, poiché i file effettivi sono in formato DEX, non in formato JAR.

Potremmo convertire questi * .jar formattati in DEX in JAR reali utilizzando strumenti come dex2jar :

dex2jar core.jar
dex2jar framework.jar

Quindi inserisci questi barattoli usando "Aggiungi JAR esterni ..." (supponendo che tu stia utilizzando Eclipse ADT)

• fare clic con il tasto destro del mouse su Project → Properties → Java Build Path → Libraries → Add External JARs... → (Scegli core-dex2jar.jare framework-dex2jar.jardall'alto).

Ciò ti consentirà di utilizzare le API interne e alcune API di Java 7. (L'APK generato, per quanto posso vedere, non contiene alcun codice effettivo dai JAR.)

Per Lollipop il flusso è leggermente diverso:

1. Ottieni /system/framework/arm/boot.oat dal dispositivo lollipop

2. Usa "java -jar oat2dex.jar boot boot.oat"

3. Otterrai due cartelle: dex e odex. Vai a dex e crea 'java -jar dex2jar.jar framework.dex'
4. Rinomina framework.jar risultante in .zip, estrai e trova le classi di cui hai bisogno
5. Vai a [sdk_path] / piattaforme / [target_platform] ed estrai android.jar (prima rinominalo in zip).
6. Copia i file dal framework estratto in android.jar estratto. Quindi comprimi in zip e rinomina in .jar :)

ps: probabilmente dovrai ripetere i passaggi 4-6 per "framework_classes2.dex"

È possibile scaricare le modifiche android.jarda utilizzare come API nascoste da questo repository . Segui le istruzioni lì.

DroidCon 2011

Qui Erik Hellman di Sony Ericson spiega come accedere alle API Android nascoste:

http://vimeo.com/30180393 (il collegamento Hmm non sembra funzionare).

Vai alla pagina web DroidCon Giorno 2 scorri verso il basso fino a Utilizzo delle API nascoste 10:15 e puoi guardarlo lì.

I link stanno morendo!

Ho trovato questo: http://skillsmatter.com/podcast/os-mobile-server/hidden-api non so quanto durerà

Le API ufficiali nell'SDK Android sono generalmente sufficienti per la maggior parte delle normali applicazioni. Tuttavia, a volte ci sono situazioni in cui uno sviluppatore ha bisogno di accedere ai servizi di sistema interni, alle API e alle risorse che non sono pubblicate nelle API ufficiali. Fortunatamente, queste API sono ancora disponibili attraverso alcuni trucchi intelligenti e spesso possono essere utili quando si sviluppa una soluzione nuova e innovativa su Android. In questa sessione imparerai come accedere e utilizzare queste API nascoste e protette, i limiti del loro utilizzo e alcuni suggerimenti su come usarle in modo sicuro e controllato su dispositivi di più fornitori e versioni Android. Il pubblico vedrà diverse demo avanzate che normalmente non puoi fare con Android. Aspettatevi una sessione abbastanza avanzata con molti approfondimenti sugli interni della piattaforma Android.

Prova a guardare questo :

L'obiettivo finale di questi articoli è fornire agli sviluppatori la potenza delle API interne e nascoste senza utilizzare la riflessione. Se completi tutti i passaggi descritti nelle diverse parti successive, sarai in grado di utilizzare API interne e nascoste come se fossero API pubbliche aperte. Non ci sarà bisogno di riflettere.

Ma se stai usando queste API non pubbliche, dovresti essere consapevole che la tua applicazione è a grande rischio. Fondamentalmente non ci sono garanzie che le API non verranno interrotte con il prossimo aggiornamento del sistema operativo Android. Non ci sono nemmeno garanzie sul comportamento coerente tra i dispositivi di diversi fornitori. Sei completamente da solo.

Ci sono tre scenari che potresti voler seguire:

1. Abilita API interne e nascoste (scenario A)
2. Abilita solo API nascoste (scenario B)
3. Abilita solo API interna (scenario C)

Lo scenario A è una somma di B e C. Lo scenario B è il più semplice (non richiede modifiche al plugin ADT di eclipse).

Scenario A : leggi le parti 1 , 2 , 3 , 4 , 5

Scenario B : leggi le parti 1 , 2 , 3 , 5

Scenario C : leggi le parti 1 , 2 , 3 , 4 , 5

Una volta ho scritto alcuni script Groovy per estrarre i file java da un repository checkout da http://source.android.com/ e quindi compilarli senza la necessità di una toolchain completa per la compilazione di tutte le fonti Android, inclusi gli altri passaggi necessari ( packaging, generazione di risorse, ecc.).

Possono essere trovati qui:

https://github.com/thoutbeckers/CollectAndroid

Ma sicuramente questo dovrà essere aggiornato per qualsiasi cosa dopo Gingerbread, principalmente impostando le directory corrette in "rootdirs" nel file di configurazione (CollectConfig.groovy).

All'epoca lo usavo regolarmente per lo sviluppo con tutte le API nascoste e le fonti (anche problematiche al momento) disponibili.

Come accennato altrove, com / android / internal / ** sarà ancora nascosto nelle versioni recenti di ADT a causa della regola di accesso aggiunta.

La risposta di Long ha funzionato per me, ma mi mancavano ancora alcune classi di cui avevo bisogno, in particolare android.provider.Telephony. Sono stato in grado di aggiungerlo in questo modo:

1. Estrai il file framework.jar

   mkdir /tmp/framework
   cp framework.jar /tmp
   cd /tmp/framework
   jar xvf ../framework.jar
   mv android classes
   

2. Costruisci il repository Android, che creerà la directory out / target / common / obj / JAVA_LIBRARIES

3. Trova dove sono le classi mancanti

   $ cd /path/to/out/target/common/obj/JAVA_LIBRARIES
   $ find . | grep "/Telephony.class"
   ./telephony-common_intermediates/classes/android/provider/Telephony.class
   ./android_stubs_current_intermediates/classes/android/provider/Telephony.class
   

4. Aggiungi le nuove classi e ricostruisci il file JAR del framework

   cd /tmp/framework
   cp -r /path/to/out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/classes .
   cp -r /path/to/out/target/common/obj/JAVA_LIBRARIES/telephony-common_intermediates/classes .
   cd classes
   jar cvf ../framework.jar .
   

Oppure puoi semplicemente essere pigro e includere tutte le classi in un unico file jar gigante:

cd /tmp/framework
cp -r /path/to/out/target/common/obj/JAVA_LIBRARIES/*/classes .
cd classes
jar cvf ../framework.jar .

Non posso commentare ma questo è fondamentalmente un commento alla risposta eccellente di @ KennyTM ( https://stackoverflow.com/a/13550030/2923406 ):

Se ti trovi con il seguente errore in Eclipse:

The type com.android.internal.util.Predicate cannot be resolved. It is indirectly referenced from required .class   files

(ovvero, android.internal. * non è disponibile)

Quindi una possibile soluzione è applicare lo stesso metodo per /system/framework/framework2.jar. Usando l'emulatore Android per SDK19 ho questo jar extra. Sul mio HTC One c'è persino un framework3.jar.