I added some npm packages to my ASP.NET Core 2 project in Visual Studio 2017. Now I want to use css and js files from these packages, but VS doesn't see them because node_modules folder is outside wwwroot. What is the common practice here, how to make Visual Studio working with node_modules?
As soon as you add the desired npm packages to your project, either through:
npm install command
or
typing the package name and its version in the npm configuration file
or
searching the package in the Library Dialog, indicated in the following image for instance,
they will be downloaded and restored in the node_modules folder. But to use them in your views, you need to add them to a client-side folder, such as lib under wwwroot folder.
You can copy them to wwwroot folder manually through the file system, or use the Library dialog:
right click on the lib directory inside wwwroot
Click Add, and choose Client-Side Library
From the provider, choose fileSystem (if desired files already exist in node_modules folder)
Choose all or specific files needed
Click install
However, you can manage this file copying operation manually.
Now, from the folders under wwwroot, you can drag and drop the file into your views. Be careful to omit ~ if your view is a Layout.
Hope this helped....
More details here: https://learn.microsoft.com/en-us/aspnet/core/client-side/libman/libman-vs?view=aspnetcore-3.0
The common practice is to bundle your web assets, and put only the compiled bundle into your wwwroot folder.
Since Visual Studio 2015 we have multiple Taskrunners from the NPM World:
Gulp
Grunt
With them you could write a script, which automatically bundles your web assets. This script has full access to the NPM infrastructure.
There are some tools out there which make this super easy:
gulp-uglify
gulp-cssmin
More Information:
https://learn.microsoft.com/en-us/aspnet/core/client-side/using-gulp
That said, it is also possible to include your npm folder:
public void Configure(IApplicationBuilder app)
{
app.UseStaticFiles(); // For the wwwroot folder
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(
Path.Combine(Directory.GetCurrentDirectory(), "node_modules")),
RequestPath = "/node_modules"
});
}
But this would be the wrong way.
I am developing an app and I must take that project to GitHub. Now, I must make gitIgnore file. I know that file is used to ignore some specified files from my project. I used gitIgnore.io service and I received generated file. This is my gitIgnore file:
# Created by https://www.gitignore.io/api/android
### Android ###
# Built application files
*.apk
*.ap_
# Files for the ART/Dalvik VM
*.dex
# Java class files
*.class
# Generated files
bin/
gen/
out/
# Gradle files
.gradle/
build/
# Local configuration file (sdk path, etc)
local.properties
# Proguard folder generated by Eclipse
proguard/
# Log Files
*.log
# Android Studio Navigation editor temp files
.navigation/
# Android Studio captures folder
captures/
# Intellij
*.iml
.idea/workspace.xml
# Keystore files
*.jks
### Android Patch ###
gen-external-apklibs
But I don't know were to copy this, and where to put that in my Android project.
Could someone help me?
I copied this file into my gitIgnore file in Android Studio, but when I have pushed that project on gitHub my gitnigore file looks like this:
*.iml
.gradle
/local.properties
/.idea/workspace.xml
/.idea/libraries
.DS_Store
/build
/captures
So, that files that I copied into Android Studio are not here. What is the problem?
Normally when creating a new project the gitignore file is generated for you.
Here is the correct .gitignore file.
*.iml
.gradle
/local.properties
/.idea/workspace.xml
/.idea/libraries
.DS_Store
/build
/captures
This is were you have to put it.
.gitignore file must be in the root directory of the project not just in android projects but in any project types
I hope my answer would be useful
Location
The file should always be placed in the root directory of the project.
Contents
Check out this handy page on Github with template gitignore files for Android and other languages - they represent best practice and are regularly updated.
I am having an issue to configure Android studio after importing gradle project. My project structures is as following:
Root Project
|_.config
|_settings.gradle
|_build.gradle
|_app_module
|_lib1_module
|_lib2_module
|_ etc.
Please note, that for several reasons I am not able to move settings.gradle and build.gradle files to project root . Also, the files mentioned above are configured correctly, so there is no problem with the build.
So the problem is that once the project in imported, the all gradle related file and folders are are generated inside .config folder, which doesn't disturd me.
Also the .idea folder and all relevant sub-folders are generated in this very folder.
So this is the problem. For some reason, the studio doesn't recognize all sub-modules are under source control. I.e. it's vcs.xml is empty and contains only project root. Actually the problem is resolved by adding the modules via settings--> subversion menu, but I'd really like out-of-the-box solution. I've tried to put .idea folder under source-control - doesn't help. Upon project creation, the vcs.xml is re-written and empty again.
So, the main question is:
Is there a possibility to
Force studio to generate .idea folder and the root project folder without changing location of .gradle files OR
Make studio NOT to re-write it's settings files upon project import (e.g. keep predefined vcs.xml)
PS. I'm aware the putting all generated files (including gradle folder, gradlew, etc.) will probably solve the issue, but I wouldn't like to go so far.
Thank all in advance
It should be a comment, but it is too long.
Android Studio works with a project.
Inside this project you can configure more modules but it need this structure:
Root Project
|_.idea
|_.gradle
|_.config
|_build.gradle
|_app_module
|_build.gradle
|_lib1_module
|_build.gradle
|_lib2_module
|_build.gradle
|_ etc.
|_settings.gradle
|_build.gradle
Inside the settings.gradle you have to define all modules:
include ':config' , ':app_module' , ':lib1_module', ':lib2_module'
Under the root folder, Android Studio when builds the project with gradle, makes same folders, like the .idea.
I read that your are not able to move the settings.gradle file.
In this case Android Studio recognizes the config folder as the root of a project and build the .idea folder inside.
|_.config (root)
|_.idea
|_.gradle
|_build.gradle
|_settings.gradle
|_myModule
Force studio to generate .idea folder and the root project folder without changing location of .gradle files OR
As I know you can't avoid this.
Also ,
Make studio NOT to re-write it's settings files upon project import
The .idea, the .gradle folder, the .iml files are built locally by the IDE when the project is built. The IDE re-writes these resources, also these files contain local paths and usually they are not commited in VCS for this reason.
I was using ANT before (Android Project) and i had "static" files in the same packages as my code
Here is an example
src/com/my/app/test/Parser.java
src/com/my/app/test/json_to_parse.json
When executing the unit tests, the json file was copied into the gen folder, therfor it was possible to access the json in the test with
getClass().getResourceAsStream(fileName)
I had to convert the project to gradle, but now the tests are failing.
After checking the "build" folder, i've realised, the .json files are not there, therefor the getResourceAsStream method returns null.
Any idea how to include these "static" files (json, xml, ...) into the build folder?
Moving the files into the resources folder did not work out of the box in Android Studio (even though is should have)
This should be fixed in Android Studio 1.2.
However, this is what i did:
Moved all static files into the resources folder.
In my unit-test module i've added this to the build.gradle file
task copyTestResources(type: Copy) {
from "${projectDir}/src/test/resources"
into "${buildDir}/classes/test"
}
processTestResources.dependsOn copyTestResources
Now, all files located inside src/test/resources will be copied into /classes/test where i can access them with
getClass().getResourceAsStream(fileName)
If i keep the package structure inside the resources folder the same as it was in the java folder, i don't need to adjust any code.
To complete the story a bit more:
JUnit4 runner requires
getClass().getResourceAsStream(name)
while Robolectric requires
getClass().getClassLoader().getResourceAsStream(name)
The files you are asking about are called "resource files" in Maven/Gradle lingo.
Gradle assumes that you are using the Maven Standard Directory Layout.
So, either you move your files into src/test/resources (then Gradle will pick them up automatically), or you tell Gradle that it should look for resources in some other place.
In the latter case, you need to modify the processTestResources task. However, keeping resource files in the same directory as source code is a bad practice. So I advise the former option.
if your problem is happen when you create apk with AndroidStudio.
you can create a jar file that includes your resources with jar.exe
for example i put a.txt into resources directory
and run this code in cmd:
"C:\Program Files\Java\jdk1.7.0_79\bin\jar" cvfe res.jar -c resources
after that a jar file "res.jar" was created
then add that res.jar into libs folder in your project
when your apk is creating resources are added to your final apk and you can use this code to acsess a.txt:
someclass.class.getClassLoader().getResourceAsStream("resources/a.txt");
with this job no need to change Gradle setting.
I am confused about the assets folder. It doesn't come auto-created in Android Studio, and almost all the forums in which this is discussed talk about Eclipse.
How can the Assets directory be configured in Android Studio?
Since Android Studio uses the new Gradle-based build system, you should be putting assets/ inside of the source sets (e.g., src/main/assets/).
In a typical Android Studio project, you will have an app/ module, with a main/ sourceset (app/src/main/ off of the project root), and so your primary assets would go in app/src/main/assets/. However:
If you need assets specific to a build type, such as debug versus release, you can create sourcesets for those roles (e.g,. app/src/release/assets/)
Your product flavors can also have sourcesets with assets (e.g., app/src/googleplay/assets/)
Your instrumentation tests can have an androidTest sourceset with custom assets (e.g., app/src/androidTest/assets/), though be sure to ask the InstrumentationRegistry for getContext(), not getTargetContext(), to access those assets
Also, a quick reminder: assets are read-only at runtime. Use internal storage, external storage, or the Storage Access Framework for read/write content.
Let Android Studio do it for you.
In Android Studio (1.0 & above), right-click on the folder and navigate to the Assets Folder.
On the next screen just click Finish.
And voila! It will create the assets folder in the main target source set.
Looking inside the .iml file of your project you will see the following line:
<option name="ASSETS_FOLDER_RELATIVE_PATH" value="/src/main/assets" />
This means the "assets" folder is already declared for Gradle. You will need to create it under src/main/ (I'm using Android Studio 0.4.2).
Select the app folder and then:
File > New > folder > assets Folder ,
the default location is inside /main folder
First of all the "Assets" folder will not be created automatically with the project. We have to create it.
The location of Assets folder is: App > src > Assets
Please have a look of the simple image below.
Note: For creating assets folder just click on Project => Right click => Select New => Folder => Assets. It will create Assets folder.
It's simple, follow these steps
File > New > Folder > Assets Folder
Note : App must be selected before creating folder.
In android studio you can specify where the source, res, assets folders are located.
for each module/app in the build.gradle file you can add something like:
android {
compileSdkVersion 21
buildToolsVersion "21.1.1"
sourceSets {
main {
java.srcDirs = ['src']
assets.srcDirs = ['assets']
res.srcDirs = ['res']
manifest.srcFile 'AndroidManifest.xml'
}
}
}
Simply, double shift then type Assets Folder
choose it to be created in the correct place
Click over main → new -> directory → and type as name "assets"
or... main -> new -> folder -> assets folder (see image)
In Android Studio 4.1.1
Right Click on your module (app for example) -> New -> Folder -> Assets Folder
File > New > folder > assets Folder
Project -> app -> src -> main -> RMB(right mouse button) -> New -> Directory:
Two ways:
Select app/main folder, Right click and select New => Folder => Asset Folder.
It will create 'assets' directory in main.
Select main folder, Right click and select New => Directory
Enter name as 'assets' = > Ok.
If you tried all your bullets in this thread in vain try cleaning your project . In my case it only worked after Projet -> clean
right click on app folder->new->folder->Assets folder->set Target Source set->click on finish button
Put the assets folder in the main/src/assets path.
Src/main/Assets
It might not show on your side bar if the app is selected. Click the drop-down at the top that says android and select packages. you will see it then.
need configure parameter for gradle
i hope is will work
// file: build.gradle
sourceSets {
main {
assets.srcDirs = ['src/main/res/icon/', 'src/main/assets/']
}
}
When upgrading to the release version of Android Studio, you may be automatically switched to the new Android project View (see here for more info). If you swap back to either the Project or Packages view, you should see the standard folder hierarchy of a Gradle-based project. Then refer to CommonsWare's answer for the appropriate location.
In Android Studio, click on the app folder, then the src folder, and then the main folder. Inside the main folder you can add the assets folder.
Step 1 : Go to Files.
Step 2 : Go to Folders.
Step 3 : Create Assets Folder.
In Assets folder just put fonts and use it if needed.
follow these steps
1)file->New->Folder
there are multiple options like
aidl folder
assets folder
jni folder
2) choose options assets folder
3) then there is option to change path of assets folder if you
want to change then check otherwise left that checkbox of cahnge folder location
4) click on finish
Either create a directory under /app/src/main or use studio File-> New -> Folder - > Assets Folder.
In Android Studio right-click Folder in app->src->main then create new DIRECTORY name that assets.
It seems that nobody mentioned this:
You can define it in Project Structure > Project Settings: