A nova versão do plug-in ADT r17 para Eclipse adicionou o recurso para configurar automaticamente as dependências JAR. Todos os arquivos .jar na pasta / libs são adicionados à configuração de compilação agora. Infelizmente, o contêiner do caminho de classe das Dependências do Android não é modificável.

Como anexar javadoc e fontes ao .jar inserido automaticamente (da pasta / libs)?

A melhor maneira de responder sua pergunta é resumir as respostas de Xavier , plastiv , VinceFR e Christopher .

Guia passo a passo

Para vincular as fontes e o javadoc a uma biblioteca .jar que é automaticamente vinculada pelo Eclipse, você deve fazer o seguinte:

1. Coloque o arquivo .jar da biblioteca na pasta libs e os arquivos .jar e doc .jar de origem associados em subpastas separadas, como libs / src e libs / docs . Você pode usar um nome que não seja src e docs, se quiser, mas é importante que os arquivos .jar não estejam diretamente na pasta libs .
2. Crie um .propertiesarquivo na pasta libs com o nome exato da biblioteca real .jar (veja o exemplo). Certifique-se de manter a parte .jar .
3. Especifique os caminhos relativos às fontes e javadoc .jar no .propertiesarquivo
4. Feche e abra novamente o projeto Eclipse! Opcionalmente, atualize o projeto pressionando F5.
5. Selecione um objeto da biblioteca vinculada no código-fonte.
6. Abra a visualização Javadoc no Eclipse para verificar a documentação (consulte a captura de tela).
7. Abra a declaração do código-fonte (atalho padrão:) F3do objeto selecionado.

Exemplo

O exemplo usa a biblioteca Gson .

Estrutura de diretório da pasta libs:

libs
├── docs
│   └── gson-2.2.2-javadoc.jar
├── gson-2.2.2.jar
├── gson-2.2.2.jar.properties
└── src
    └── gson-2.2.2-sources.jar

Conteúdo de gson-2.2.2.jar.properties

src=src/gson-2.2.2-sources.jar
doc=docs/gson-2.2.2-javadoc.jar

Informação adicional

Obviamente, você pode mover o javadoc e o arquivo .jar para outras pastas e especificar caminhos relativos. Isso é contigo. Colocar os jars de origem e javadoc diretamente na pasta lib é possível, mas não recomendado , pois isso faz com que a documentação e o código-fonte sejam incluídos no seu aplicativo .

Captura de tela do painel Eclipse JavaDoc:

Captura de tela de um projeto Eclipse usando Gson com Android 4.2.2 .:

Referenciando javadocs descompactados

Caso deseje fazer referência a javadocs que não são fornecidos como compactados, .jarmas simplesmente como arquivos e pastas, conforme solicitado pelo desenvolvedor do Android nos comentários, faça o seguinte:

1. Coloque a biblioteca .jarna libs/pasta

2. Crie um yourlibraryname.jar.propertiesarquivo ( não esqueça o.jar ) com o seguinte conteúdo:

    doc=docs

3. Adicione as pastas javadocs à libs/pasta.

Você deve criar a seguinte estrutura de pastas:

├── docs
│   ├── allclasses-frame.html
│   ├── allclasses-noframe.html
│   ├── com
│   │   └── google
│   │       └── ads
│   │           ├── Ad.html
│   │           │   ....
│   │           └── package-tree.html
│   │   ...
│   └── stylesheet.css
├── GoogleAdMobAdsSdk-6.4.1.jar
└── GoogleAdMobAdsSdk-6.4.1.jar.properties

Não se esqueça de fechar e reabrir o projeto Eclipse, como mencionado acima! Aqui está uma captura de tela de um exemplo de projeto de trabalho que faz referência à biblioteca AndroidAdMobAds Android .

Nas janelas, você precisa escapar da barra invertida para obter referências aos caminhos doc e src no arquivo de propriedades. Exemplo, para android-support-v4.jar, o conteúdo do arquivo de propriedades é algo como:

doc=C:\\Program Files (x86)\\Android\\android-sdk\\extras\\android\\support\\v4\\docs
src=C:\\Program Files (x86)\\Android\\android-sdk\\extras\\android\\support\\v4\\src

Uma resposta vem de http://code.google.com/p/android/issues/detail?id=27490#c21

Na sua pasta libs, você deve ter:

doc(folder)
    foo_doc(folder)
        index.html
        ...
        ...
foo.jar
foo.jar.properties

E no seu foo.jar.properties, basta colocardoc=./doc/foo_doc

Talvez você precise atualizar seu projeto, limpá-lo, fechá-lo e reabri-lo.

Funciona para mim!

Eu tentei todas as opções acima e nenhuma delas funcionou para mim. Eu descobri um método que sempre funcionará. Basicamente, o culpado é a maneira como o ADT trata a pasta "libs", então parei de usar a pasta "libs". Em vez disso, criei uma pasta "bibliotecas" e a usei.

Você pode fazer o seguinte e sempre funcionará - mesmo que o ADT mude como muda a maneira como lida com a pasta "libs" no futuro:

1. Crie uma pasta "bibliotecas".
2. Crie uma subpasta para cada biblioteca.
3. Coloque todos os arquivos de cada biblioteca na pasta apropriada (arquivo java jar, arquivo jar de origem, arquivo javadoc, etc).
4. Adicione o arquivo java jar para cada projeto na guia "Bibliotecas" do Java Build Path, clicando no Add Jars...botão para adicionar o jar da subpasta da biblioteca na pasta "libraries".
5. Anexe o source / javadocs a cada projeto, abrindo o projeto na guia "Bibliotecas", selecionando o item desejado e clicando no Edit...botão para adicionar o source / javadocs da subpasta biblioteca na pasta "libraries".
6. Marque a caixa de seleção para cada projeto na guia "Order and Export" para o Java Build Path.
7. Após verificar se todas as bibliotecas foram movidas, exclua a pasta "libs".

Seguindo o procedimento acima, seu projeto terá pastas parecidas com esta:

Seu Java Build Path será parecido com este:

Em Order and Export, as bibliotecas estão marcadas:

Por enquanto, mova a biblioteca para a qual você deseja Javadoc lib. Eles adicionam essa biblioteca ao Build PathJavadoc e o adicionam.

Verifique este comentário nas questões do Android.

No ADT 22, não consegui acessar o Javadoc para o commons-io-2.4.jar e o android-support-v4.jar

Foi assim que eu consertei:

1. Pré-condição: as duas bibliotecas estão listadas em "Bibliotecas referenciadas".

2. Clique com o botão direito do mouse em commons-io-2.4.jar e selecione Propriedades. Esta janela aparece:

commons-io-2.4.jar é fornecido com commons-io-2.4-javadoc.jar, portanto, especifiquei o Javadoc no caminho do arquivo externo do archive.

Fiz a mesma coisa na biblioteca de suporte: clique com o botão direito do mouse em android-support-v4.jar e selecione Propriedades. Esta tela aparece:

Desta vez, especifiquei o caminho para o diretório de origem.

A referência da biblioteca ao commons-io-2.0.1.jar foi interrompida quando atualizei para o SDK Tools e a revisão 17 do ADT.

Para resolver o problema, usei Projeto -> Propriedades -> Caminho de compilação Java e selecionei a guia Bibliotecas. Excluí qualquer referência ao commons-io-2.0.1.jar e, em seguida, usei Add Jar para adicionar novamente o commons-io-2.0.1.jar ao projeto. Em seguida, clico na seta '>' ao lado do nome da biblioteca para expandir a referência da biblioteca e usei os botões de edição para definir o anexo de origem e o local do Javadoc.

Desculpe, não posso postar uma imagem porque não tenho representante suficiente (por favor ...).

Parece ser um alvo em movimento, mas, depois de coletar pedaços de vários lugares (incluindo respostas a essa pergunta que ajudou, mas não conseguiu descrever todos os detalhes necessários, ou talvez o sistema tenha mudado um pouco nesse meio tempo), isso parece ser a solução, pelo menos a partir de agora (28 de agosto de 2013).

• Abra uma pasta para os javadocs em algum lugar não dentro de seu projeto.
• Coloque seus javadocs descompactados, cada um em sua própria pasta.
• Dentro da sua libpasta, adicione um xxx.jar.propertiesarquivo para cada lib à qual você deseja associar um javadoc.
• Nesse arquivo de propriedades, consulte a pasta na qual você descompactou o javadoc apropriado (no Windows, escape das barras invertidas):

doc=d:\\Android\\javadoc\\libGoogleAnalyticsServices

• Feche e reabra seu projeto no Eclipse (a atualização não é suficiente). Agora você deve ver as dicas de ferramentas ao passar o mouse sobre as classes apropriadas.

Deixar de observar qualquer uma dessas etapas (sem descompactar o javadoc, referenciar um arquivo em vez de uma pasta etc.) parece quebrá-lo.

Eu sei que essa pergunta é bastante antiga, mas quando eu estava enfrentando o mesmo problema ontem e a solução postada acima era muito chata para mim, descobri que é possível adicionar facilmente uma definição de caminho de origem ao arquivo .classpath do projeto. O Eclipse irá adaptá-lo e você poderá navegar pela fonte.

entrada do caminho de classe antes:

<classpathentry kind="lib" path="[PATH_TO_MY_JAR]"/>

Depois de adicionar o caminho à fonte

<classpathentry kind="lib" path="[PATH_TO_MY_JAR]" sourcepath="[PATH_TO_MY_SOURCE_JAR]"/>

Espero que isto ajude

basta atualizar o plug-in ADT. Isso funcionou para mim !!

1. Inicie o Eclipse e selecione Ajuda> Instalar Novo Software.
2. Clique em Adicionar, no canto superior direito.
3. Na caixa de diálogo Adicionar repositório exibida, digite "ADT Plugin" para o Nome e o seguinte URL para o local: https://dl-ssl.google.com/android/eclipse/ Nota: o site de atualização das Ferramentas para Desenvolvedor do Android requer um Conexão segura. Verifique se o URL do site de atualização digitado começa com HTTPS.
4. Clique OK. Na caixa de diálogo Software disponível, marque a caixa de seleção ao lado de Ferramentas do desenvolvedor e clique em Avançar.
5. Na próxima janela, você verá uma lista das ferramentas a serem baixadas. Clique em Avançar.
6. Leia e aceite os contratos de licença e clique em Concluir.
7. Se você receber um aviso de segurança dizendo que a autenticidade ou validade do software não pode ser estabelecida, clique em OK.
8. Quando a instalação estiver concluída, reinicie o Eclipse

Espero que ajude!

Para qualquer jar especificado, se você desejar ver a ajuda do Javadoc na dica de ferramenta durante a codificação, faça o seguinte: Clique com o botão direito do mouse em seu projeto> Propriedades> Caminho de Construção Java> Guia Bibliotecas. Clique na seta ao lado do seu jar para expandir.

O anexo de origem deve apontar para o local do jar real (provavelmente na sua pasta java).

Localização Javadoc : Você tem duas opções aqui: URL e arquivo morto. Se seus javadocs para este jar estiverem no formato de uma pasta que contém um arquivo index.html no primeiro nível, escolha 'Javadoc URL' e aponte para essa pasta. Se seus javadocs estiverem em um jar, escolha 'Javadoc in archive' e aponte para o jar. Não se esqueça de reiniciar seu espaço de trabalho / fechar e reabrir seu projeto para atualizar a dica de ferramenta com as informações do Javadoc.

Espero que isso ajude a dar uma resposta simples para o que acredito ser uma tarefa muito simples.

Minha solução:

Faça o download de um plug-in do eclipse chamado: "Java Source Attacher Feature".

Mais tarde, selecione um jar e anexe o código-fonte usando este plugin. Clique no arquivo jar para selecioná-lo, clique com o botão direito do mouse e selecione "anexar fonte java".

Quando você possui o código-fonte, possui automaticamente o javadoc.

Agora você pode usar F2 nas classes para visualizar o javadoc associado.

Aproveitar