Como faço para construir o Android SDK com APIs ocultas e internas disponíveis?

Quero reconstruir o Android SDK (ou melhor, apenas o android.jar) para incluir APIs ocultas e internas.

Não consegui encontrar nenhuma documentação ou discussão sobre como fazer isso. Eu tenho um ambiente de construção Ubuntu CyanogenMod já configurado que é capaz de construir cm7.

Agora, eu li que make SDK irá construir o SDK, mas eu quero construir um SDK que inclui métodos e campos que são marcados como ocultos usando @hide. Isso é possível?

O que eu quero fazer é fazer alterações em um aplicativo que usa API oculta e, para reconstruí-lo, gostaria de usar o SDK modificado.

Isso é o que sempre faço para usar a API oculta.

1. Crie o repo ou baixe os jars em https://sites.google.com/site/hippunosource/home/android/androidnohide-apiwo-shi-yongsuru-rifurekushonha-wei-shi-yong
2. copie / target / common / obj / JAVA_LIBRARIES / framework_intermediates / classes.jar (melhor renomear como algo como framework_all.jar)
3. configure o caminho de construção do seu projeto -> bibliotecas -> adicione estes jars externos. Em Order and Export, mova-o para cima e antes de android.jar

Eu fiz algumas investigações sobre isso e minha conclusão é simples: isso não pode ser feito sem um pouco de trabalho. Leia o restante desta resposta para obter detalhes sobre o que descobri.

android.jaré, na verdade, composto pela "API pública" de framework.jare core.jarque é encontrada no system/frameworks/dispositivo. android.jaré um tipo do que eu chamaria de cabeçalho da biblioteca Java, todas as implementações no código de bytes real são apenas um throw new RuntimeException("stub");, isso permite que você construa android.jar(por exemplo, no Eclipse), mas a execução deve ser realizada em um dispositivo ou emulador.

A API pública do Android SDK é definida por classes / métodos / campos que não são prefixados com a @{hide}anotação javadoc. Ou seja, tudo o que não é anotado está incluído no SDK.

android.jaré construído a partir de fontes localizadas nas out/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediatesquais ele próprio é gerado pela ferramenta DroidDoc localizada em build/tools/droiddoc.

DroidDoc é a ferramenta (provavelmente adaptada do javadoc ou usando o javadoc) que gera a documentação real do Android SDK. Como efeito colateral, e provavelmente porque já está analisando todo o javadoc, ele também expele os stubs do Android que são compilados no android.jarque é distribuído no SDK.

Portanto, para incluir o que está oculto, você pode, se quiser incluir apenas partes específicas, apenas remover a @hideanotação e reconstruir o SDK.

No entanto, se você quiser incluir todas as partes ocultas, as coisas ficam muito mais complicadas. Você pode modificar o DroidDoc (a fonte relevante está em build/tools/droiddoc/src/Stubs.java) de forma que nada seja detectado como oculto. Isso é bastante trivial e eu tentei fazer isso, no entanto, os stubs que são gerados não compilam de todo.

Minha conclusão agora é que isso simplesmente não é viável. Os stubs gerados se você remover a parte do DroidDoc que detecta anotações ocultas, simplesmente não é compilável e exigiria um pouco de trabalho para compilar corretamente.

Portanto, minha resposta às suas perguntas é: Não, isso não pode ser feito sem muito trabalho. Desculpa.

Uma observação lateral sobre a mkstubsferramenta. mkstubssão usados ​​quando você constrói um complemento SDK , ou seja, os complementos que você pode encontrar no gerenciador do Android SDK de fornecedores, por exemplo, a Samsung fornecendo a você uma API adicional para coisas específicas para telefones Samsung. mkstubsfaz quase o mesmo que o processo de geração de stubs do DroidDoc; no entanto, não usa @hideanotações, ele usa um .defsarquivo que descreve quais pacotes / classes / campos incluir ou excluir do seu complemento SDK.

No entanto, tudo isso é irrelevante para a questão, já que o Android SDK build não usa a mkstubsferramenta. (Infelizmente.)

Podemos reconstruir os arquivos * .jar da plataforma Android.

Primeiro, conecte o ADB ao seu dispositivo. Então corra:

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

O core.jarcontém as bibliotecas Java padrão ( java.*) e framework.jarcontém as bibliotecas do Android ( android.*). Isso ainda não pode ser usado, pois os arquivos reais estão no formato DEX, não no formato JAR.

Poderíamos converter esses * .jars formatados em DEX em JARs reais usando ferramentas como dex2jar :

dex2jar core.jar
dex2jar framework.jar

Em seguida, coloque esses jars usando "Adicionar JARs externos ..." (presumindo que você esteja usando Eclipse ADT)

• clique com o botão direito em Project → Properties → Java Build Path → Libraries → Add External JARs... → (Escolha core-dex2jar.jare framework-dex2jar.jaracima).

Isso permitirá que você use as APIs internas e algumas APIs Java 7. (O APK gerado, pelo que posso ver, não contém nenhum código real dos JARs.)

Você pode baixar o modificado android.jarpara ser usado como APIs ocultas deste repositório . Siga as instruções aqui.

Para o Lollipop, o fluxo é um pouco diferente:

1. Obtenha /system/framework/arm/boot.oat do dispositivo lollipop

2. Use 'java -jar oat2dex.jar boot boot.oat'

3. Você receberá duas pastas: dex e odex. Vá para dex e faça 'java -jar dex2jar.jar framework.dex'
4. Renomeie framework.jar resultante para .zip, extraia e encontre as classes que você precisa
5. Vá para [sdk_path] / plataformas / [target_platform] e extraia android.jar (primeiro renomeie-o para zip).
6. Copie os arquivos da estrutura extraída para o android.jar extraído. Em seguida, comprima para compactar e renomeie para .jar :)

ps: provavelmente você precisa repetir os passos 4-6 para 'framework_classes2.dex'

DroidCon 2011

Aqui, Erik Hellman, da Sony Ericson, explica como acessar as APIs ocultas do Android:

http://vimeo.com/30180393 (Hmm, o link não parece funcionar).

Vá para a página da Web do DroidCon. Dia 2, role para baixo até Using Hidden APIs 10:15 e você pode assisti-lo lá.

Links estão morrendo!

Eu encontrei este: http://skillsmatter.com/podcast/os-mobile-server/hidden-api não sei quanto tempo vai ficar

As APIs oficiais no Android SDK geralmente são suficientes para a maioria dos aplicativos normais. No entanto, às vezes há situações em que um desenvolvedor precisa acessar os serviços internos do sistema, APIs e recursos que não são publicados nas APIs oficiais. Felizmente, essas APIs ainda estão disponíveis por meio de alguns truques inteligentes e muitas vezes podem ser úteis no desenvolvimento de soluções novas e inovadoras no Android. Nesta sessão, você aprenderá como acessar e usar essas APIs ocultas e protegidas, as limitações de seu uso e algumas dicas e truques sobre como usá-las de maneira segura e controlada em dispositivos de vários fornecedores e versões do Android. O público verá várias demonstrações avançadas que você normalmente não pode fazer com o Android. Espere uma sessão bastante avançada com muitos insights sobre as partes internas da plataforma Android.

Tente olhar para isto :

O objetivo final desses artigos é dar aos desenvolvedores o poder das APIs internas e ocultas sem usar reflexão. Se você concluir todas as etapas descritas nas próximas partes, poderá usar APIs internas e ocultas como se fossem APIs abertas ao público. Não haverá necessidade de reflexão.

Mas se você estiver usando essas APIs não públicas, deve estar ciente de que seu aplicativo corre um grande risco. Basicamente, não há garantias de que as APIs não serão quebradas com a próxima atualização do sistema operacional Android. Não há nem mesmo garantias sobre o comportamento consistente em dispositivos de diferentes fornecedores. Você está completamente sozinho.

Existem três cenários que você pode querer seguir:

1. Habilite APIs internas e ocultas (cenário A)
2. Habilite apenas API oculta (cenário B)
3. Habilite apenas API interna (cenário C)

O cenário A é uma soma de B e C. O cenário B é o mais fácil (não requer modificações do plugin Eclipse ADT).

Cenário A : leia as partes 1 , 2 , 3 , 4 , 5

Cenário B : leia as partes 1 , 2 , 3 , 5

Cenário C : leia as partes 1 , 2 , 3 , 4 , 5

Certa vez, escrevi alguns scripts do Groovy para extrair os arquivos java de uma verificação de repositório de http://source.android.com/ e, em seguida, compilá-los sem a necessidade de um conjunto de ferramentas completo para compilar todas as fontes do Android, incluindo as outras etapas necessárias ( embalagem, geração de recursos etc).

Eles podem ser achados aqui:

https://github.com/thoutbeckers/CollectAndroid

Mas com certeza isso precisará ser atualizado para qualquer coisa após o Gingerbread, principalmente definindo os diretórios corretos em "rootdirs" no arquivo de configuração (CollectConfig.groovy).

Na época, eu costumava usar isso regularmente para desenvolvimento com todas as APIs e fontes ocultas (também problemáticas na época) disponíveis.

Conforme mencionado em outro lugar, com / android / internal / ** ainda estará oculto nas versões recentes do ADT devido à regra de acesso anunciada.

A resposta de Long funcionou para mim, mas eu ainda estava perdendo algumas aulas de que precisava, em particular android.provider.Telephony. Consegui adicionar assim:

1. Extraia o arquivo framework.jar

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

2. Construir o repositório Android, que criará o diretório out / target / common / obj / JAVA_LIBRARIES

3. Descubra onde estão as aulas que faltam

   $ 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. Adicione as novas classes e reconstrua o arquivo JAR da estrutura

   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 .
   

Ou você pode ser preguiçoso e incluir todas as classes em um arquivo jar gigante:

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

Não posso comentar, mas este é basicamente um comentário para a excelente resposta de @ KennyTM ( https://stackoverflow.com/a/13550030/2923406 ):

Se você encontrar o seguinte erro no Eclipse:

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

(ou seja, android.internal. * não está disponível)

Então, uma solução possível é aplicar o mesmo método para /system/framework/framework2.jar. Usando o emulador Android para SDK19, tenho este jar extra. No meu HTC One, existe até um framework3.jar.