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.
android
android-sdk-2.3
android-source
Thomas Hofmann
fonte
fonte
@Hidden
rótulo da API que deseja acessar e, em seguida, executarmake update-api
emake SDK
construir seu próprio SDK.Respostas:
Isso é o que sempre faço para usar a API oculta.
fonte
.iml
arquivo do módulo e trazer suas bibliotecas desejadas<orderEntry>
antes do Android SDK . Infelizmente, essa técnica não é persistente, pois o arquivo será sobrescrito assim que o botão gradle-sync for pressionado.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" deframework.jar
ecore.jar
que é encontrada nosystem/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 umthrow new RuntimeException("stub");
, isso permite que você construaandroid.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 nasout/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediates
quais ele próprio é gerado pela ferramenta DroidDoc localizada embuild/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.jar
que é distribuído no SDK.Portanto, para incluir o que está oculto, você pode, se quiser incluir apenas partes específicas, apenas remover a
@hide
anotaçã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
mkstubs
ferramenta.mkstubs
sã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.mkstubs
faz quase o mesmo que o processo de geração de stubs do DroidDoc; no entanto, não usa@hide
anotações, ele usa um.defs
arquivo 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
mkstubs
ferramenta. (Infelizmente.)fonte
@hide
anotações, ele "apenas" usa um.defs
arquivo que descreve quais pacotes / classes / campos devem ser incluídos na API do complemento.$(hide)
, você está se confundindo.$(hide)
é simplesmente um prefixo nos makefiles para ocultar a linha de comando real do programa sendo executado, nada mais, e é usado em quase todos os lugares. Não tem nada a ver com o Android SDK ou a@hide
anotação no código-fonte.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.jar
contém as bibliotecas Java padrão (java.*
) eframework.jar
conté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)
Project → Properties → Java Build Path → Libraries → Add External JARs
... → (Escolhacore-dex2jar.jar
eframework-dex2jar.jar
acima).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.)
fonte
/system/framework/core.odex
,/system/framework/framework.odex
e provavelmente mais. Eles podem ser desodexados (java -jar baksmali-2.0.3.jar -d system.framework -x system.framework/core.odex -o core
) e reodexados (java -jar smali-2.0.3.jar -x -o core.dex core
), e somente depois dissodex2jar core.dex
faz o seu trabalho.Você pode baixar o modificado
android.jar
para ser usado como APIs ocultas deste repositório . Siga as instruções aqui.fonte
Para o Lollipop, o fluxo é um pouco diferente:
Obtenha /system/framework/arm/boot.oat do dispositivo lollipop
Use 'java -jar oat2dex.jar boot boot.oat'
ps: provavelmente você precisa repetir os passos 4-6 para 'framework_classes2.dex'
fonte
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
fonte
Tente olhar para isto :
fonte
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.
fonte
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:
Extraia o arquivo framework.jar
mkdir /tmp/framework cp framework.jar /tmp cd /tmp/framework jar xvf ../framework.jar mv android classes
Construir o repositório Android, que criará o diretório out / target / common / obj / JAVA_LIBRARIES
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
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 .
fonte
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.
fonte