I am a C# developer and getting started with Android. I am attempting to duplicate a couple applications I already have in VS. The project is made of 2 executables and 1 common assembly. The 2 executables contain the application specific logic while the common contains centralized forms and logic (such as login form). I am using Eclipse. So how can I accomplish this layout?
Thanks
In Eclipse, with your project selected in the Navigation or Package Explorer view:
Project -> Properties -> Java Build Path
Here you can add references to Libraries (jar files which I believe are similar in concept to C# assemblies) or other projects you have open in Eclipse.
So create as many projects in Eclipse as you want for your application's layout, and in the main Android project (the one where your application's Manifest file exists) reference those other projects, or the jar files you exported from those projects, in the Java Build Path.
Related
While create an Android project in eclipse, it created 2 projects.
appcompat_v7
MasterCopy <- This is the name of my project
I understand that appcompat_v7 is a library project that android automatically created for me.
Once the above projects are created I got an error message 'The container 'Android Dependencies' references non existing library'. To address this I just build the appcompat_v7 project and that clears the error.
Basically I don't want appcompat_v7 as a separate project. This is how looks like.
If I delete the appcompat_v7 project I got the 'Error retrieving parent for item: No resource found that matches the given name 'Theme.AppCompat.Light.DarkActionBar' in styles.xml file.
Is there a way I add appcompat as external library or JAR file into the MasterCopy project and keep one project as whole without loosing the functionality?
I am not sure whether I am making any sense here... But this is how I asked to create the project.
Explanation
The issue you're going to have is that resources, such as styles like Theme.AppCompat.Light.DarkActionBar, cannot be packaged simply in a jar file. As Google's documentation explains:
Some Support Libraries contain resources beyond compiled code classes,
such as images or XML files. For example, the v7 appcompat and v7
gridlayout libraries include resources.
Google has specific documentation for how to include libraries that contain resources, which it appears you've followed:
https://developer.android.com/tools/support-library/setup.html#libs-with-res
The reason why it's a good idea to keep this in a separate project, is that it allows you to easily upgrade, build, and otherwise manage that project separate from your own as the compatibility library changes.
(Unrecommended) Solution
That said, if you really want to have a single project, you could manually copy everything from the sample project for the app compat library (located in <sdk>/extras/android/support/v7/appcompat/) into your project. Notably, you'll need to copy everything from the res/ folder and merge it with your own resources, or rename google's XML files such as res/values/strings.xml to strings-appcompat.xml, and of course the appcompat jar file itself.
Again though, you'll have to go through this process every single time you want to update the version of the compatibility library that you use.
(Good) Alternative Solution
Google has specifically created the AAR format, which bundles resources with a jar file. If you transition to a Gradle build system (easy if you're using Android Studio), then all you have to do is refer to this app-compat-v7 aar artifact (also explained at the link above), and you can maintain a single project.
I'm switching from Elcipse to Android Studio. In Eclipse I have some "library projects" (no jar files, but Android projects marked as "library") that are used by several apps. In Eclipse I used to have this library project in only one place, and I liked to modifiy the library only once, and see the effect on all the other projects depending on it.
In Android Studio, when I add a library module, all the code is copied inside the app. I don't like it, because it's easier to maintain having it only in one place. Is there any way to reference the original library instead of copy it inside the project?
I've been reading a lot of about this, but I can't find the right solution. These are the ways I'm thinking to do it:
a) Aar files and local maven repository: I would compile the library module into an aar file, and I'll save in an local maven repository, so I can reference it on my projects. But this has a drawback: every time I want to modify the library, I need to recompile to an aar file before I can test the changes in my project.
b) Symbolic links: Instead of copy all the library module inside the app folder, I'm thinking in creating symbolic links to the original folder. So the library will stay in only one folder. But I think this approach is so tricky, and there must be a better way to do it.
I'm trying to learn android development and I am initially confused by the different project structures between Eclipse and Android Studio. This makes it difficult to follow tutorials designed for Eclipse. Could anyone let me know why these differences exist? Should they exist?
For instance, if I were to locate the R.java file in the two different IDEs, the paths would look like this:
Eclipse: app\gen\com.example.app\R.java
Android Studio: app\build\source\r\debug\com.example.app\R.java
Why are these paths different? Why is my R.java located in a debug folder in Android Studio? This lead to some errors early on, and if anyone has any insight into these differences I would appreciate them.
The mystery: Android Studio's Project Structure and Build System
I don't know if this is because of the Gradle Build System (I'd wager it is), but I'll tell you what I've understood so far.
Update 4: 2014/09/11 Added Cheat Sheet for BuildTypes, Flavors and Variants(I finally feel confident to write this :D)
Update 3: 2014/09/11 Updated the comparison workspaces and projects to be precise
Update 2: 2014/04/17 Added more detail to AS project structure
Update 1: 2013/07/29 Added IntelliJ Project Structure
The IntelliJ's Project structure (shown at the end) is for IntelliJ with the android plugin. The Android Studio, however, has a project structure divided like so:
Structure: Projects and Modules
module in Android Studio is like a project in Eclipse
project in Android Studio is like a workspace in Eclipse (to be precise, a workspace with interdependent projects)
From the documentation (Android Studio is based on Intellij IDEA) :
Whatever you do in IntelliJ IDEA, you do that in the context of a
project. A project is an organizational unit that represents a
complete software solution.
Your finished product may be decomposed into a series of discrete,
isolated modules, but it's a project definition that brings them
together and ties them into a greater whole.
For Android, it means one project per app, and one module per library and per test app.
There are multiple issues if you try to build multiple apps within the same project. It's possible, but if you try (like I did), you will see that almost everything is designed to work with a single app per project.
For example, there is an option to "rebuild the project", which makes no sense with multiple apps, many other project settings would be useless, and the built-in VCS system isn't great when you have multiple repositories.
Structure: Folder Structure
Top Level Folders
1. Main Project
This would be entire project context (Eclipse Land: Like your workspace but limited to what's relevant to your project). Ex: HelloWorldProject if the name of the application you gave was HelloWorld
2. .idea
This where project specific metadata is stored by Android Studio (AS). (Eclipse Land: project.properties file)
3. Project Module
This is the actual project. ex: HelloWorld if your application name you gave was HelloWorld
4. gradle
This is where the gradle build system's jar wrapper i.e. this jar is how AS communicates with gradle installed in Windows (the OS in my case).
5. External Libraries
This is not actually a folder but a place where Referenced Libraries (Eclipse Land: Referenced Libraries) are shown. Here's where the Targeted Platform is shown etc.
[Side note: This where many of us in Eclipse Land used to delete the referenced libraries and Fix Project Properties to fix reference errors, remember?]
Project Folder in Detail
This is number #3 in the above list. Has the following sub dirs
1. build
This has all the complete output of the make process i.e. classes.dex, compiled classes and resources, etc.
In the Android Studio GUI, only a few folders are shown. The important part is that your R.java is found here under build/source/<flavor>/r/<build type(optional)>/<package>/R.java
2. libs
This is the standard libs folder that you see in eclipse land too
3. src
Here, you only see the java and res folder which correspond to the src folder and res folder in Eclipse Land. This is much welcomed simplification IMHO.
Note on Modules:
Modules are like Eclipse Land projects. Here the idea is that you have one application project (Module #3 in the list above) and several library projects(as separate Modules under the global project folder (#1 in the above list)) which the application project depends on. How these library projects can be re-used in other applications, I still haven't found out.
[Side note: The whole re-organization has some benefits like simplifications in src folder, but so many complications. The complications are mainly due VERY VERY thin documentation on this new project layout.]
The New Build System
User Guide for the new Build System
Explanation of flavors and buildTypes, etc - What is the hullabaloo about?
CheatSheet for flavors and buildTypes
BuildType: debug and release are buildTypes available by default on all projects. They are for building/compiling the SAME CODE to generate different APKs. For example on release APKs you would want to run proguard(for obfuscation), sign it with your key (as against the debug key), run optimizations (maybe via proguard or other tools), use slightly different packageNames (we use com.company.product for release and com.company.product.debug for debug), etc. We also use a debug flag (BuildConfig.DEBUG) to turn off logging to logcat (since it makes the app slow) on release builds. This makes for a faster debug build during development but also an optimized release build to put on play store.
Product Flavor: There are no default flavors available (or to be precise, the default flavor is blank/nameless). Flavors could be free version or paid version where they have DIFFERENT CODE. They share the same Main Code but different versions(or no versions) of a few source code files or resources.
BuildVariant: A buildVariant is what a generated APK actually corresponds to. They are named like so (in order) Product Flavor + Build Type = Build Variant.
Example 1: if you have free and paid as two flavors. The build variants you would get are:
Free - debug
Free - release
Paid - debug
Paid - release
So that is 4 possible APK configurations. A few configurations may not make sense in a particular project, but they are available.
Example 2: (for new projects/ no flavors) You have 2 buildVariants or APKs available, since the default flavor is nameless/blank:
debug
release
Compare this with Intellij's Project Structure if that helps:
The .idea (1) folder contains a number of subfolders, mainly with internal IntelliJ IDEA information.
The src (2) folder contains the MyActivity.java (3) file source code that implements the functionality of your application. The file belongs to the com.example package.
The res (4) folder contains various visual resources.
The layout/main.xml file (5) defines the appearance of the application constituted of resources of various types.
The values folder (6) is intended for storing .xml files that describe resources of various types. Presently, the folder contains a strings.xml file with String resources definitions. As you will see from the Adding a Color section, the layout folder can also contain, for example, a descriptor of colors.
The drawable folder (7) contains images.
The gen (8) folder contains the R.java (9) file that links the visual resources and the Java source code. As you will see from the sections below, IntelliJ IDEA supports tight integration between static resources and R.java. As soon as any resources are added or removed, the corresponding classes and class fields in R.java are automatically generated or removed accordingly. The R.java file also belongs to the com.example package.
Android Studio: app\build\source\r\debug\com.example.app\R.java
Why are these paths different? Why is my R.java located in a debug folder in Android Studio? This lead to some errors early on, and if anyone has any insight into these differences I would appreciate them.
Simply put, Android Studio is configured to build a debug Build Type on your system.
Eclipse/ADT is designed to support a single build at a time (from what I can tell). One of the primary goals of the new build system (from the user guide):
Make it easy to create several variants of an application,
either for multi-apk distribution or for different flavors of an application
So where as Eclipse/ADT could generate one R.java file, Android Studio supports multiple. The generated R.java is located in the debug folder because by default the new build system supports debug and release build types off the bat. If you changed your build variant (button, lower left hand corner of AS) to release AS will generate R.java in the release directory.
This might not mean anything for simple projects, but the support of Build Variants means a drastic simplification of the build process for many developers, including the project I'm working on.
Our project supports 4 flavors with 2 build types (debug and release), to support a total of 8 different APK combinations. And each of those combinations have slightly different configurations, so this build system really worked out for us. My android studio is installed on a different machine, but if memory serves my correctly the R.java file exists in build/source/<flavor>/r/<build type>/package/R.java. When our CI server builds the APK files it uses each of these R.java files to generate separate packages.
Google Discontinue the support for the Android Developer Tools
(ADT) in Eclipse is ending, per our announcement. You should migrate
your app development projects to Android Studio as soon as possible.
For more information on transitioning to Android Studio, see Migrating
to Android Studio.
So best for Android development tool for Android Studio only for all future support of Android M ---
For android Studio 3.0.1 and selected all features:
Android O latest
Android Auto
Android things
Android wear
Android TV
C++ support
Kotlin support
The structure in version 3.0.1 does not look at all like all other answers.
Recent structure is as displayed in 2018, Android Studio 3.0.1 01/2018.
Newbie kinda found something resembling to usable in feature sub-folder:
Update your Android Studio 3.0.1 01_2018:
ToolTip:
I have an Android project that depends on a non-Android JAR that contains resources (Java resources, not Android resources), which classes within the JAR need to load. When running the application, these resources are not found (i.e., ClassLoader.getResourceAsStream() fails), apparently because the resources are not being included in the APK.
I found some discussion here:
http://code.google.com/p/android/issues/detail?id=10076#c7
But I need to build the APK in Eclipse. Short of doing a command-line build with a deprecated tool (ugh), or duplicating all the resources (ugh), how can I make it work?
Create your jar file with the classes you need and save it your computer. Then in the project explorer right click the project and go to properties -> Java Build Path -> Libraries. Now import the jar file.
You should now have full access to the classes and methods in your code and the jar file will be installed with your APK. My guess is you have utility classes and when you are calling them in your source Eclipse is importing them from another project.
The solution I have given works for sure (I do it myself).
I noticed that when I convert an existing Android Application project to an Android Library project by checking the "is Library" checkbox, nothing changes in the project's source code or XML files.
So what really happens when the "is Library" checkbox is checked? What changes internally, in the package and/or project files? Where can I learn more about this?
To better explain my question:
What I am interested to know (mainly
for troubleshooting purposes) is
what differentiates an Application package from a Library
package "under the cover"?
Is the fact that a project is
"Library Project" marked
somewhere? If so, where does it
mark it (obviously not in the source
files and not even in the res XML
files)
From the Managing Projects from the Command Line page:
The create lib-project command creates
a standard project structure that
includes preset property that
indicates to the build system that the
project is a library. It does this by
adding this line to the project's
default.properties file:
android.library=true
In other words, it's a property that is utilized by the build system and not by the operating system.
UPDATE: I'm on my iPhone so I won't type out a whole paraphrase, but here's a pretty good blog article discussing the differences between a Java JAR and an Android Library Project, including how the dex tools add the resources and dex code to the .apk:
http://devmaze.wordpress.com/2011/05/22/android-application-android-libraries-and-jar-libraries/
From the devsite: http://developer.android.com/guide/developing/projects/projects-eclipse.html
You can also designate an Android
project as a library project, which
allows it to be shared with other
projects that depend on it. Once an
Android project is designated as a
library project, it cannot be
installed onto a device.
A library project isn't packaged as a seperate redistributable file as you're used to with a jar. It's merged with the the apk file of your application.
The page you linked to mentions it in the Referencing a library project section.
As soon as the Properties dialog closes, Eclipse rebuilds the project, including the contents of the library project.