If you see it listed right-click on it and choose 'Delete' or 'Remove Device' Open up the run command with the 'Windows key + R' key combo. Type printui.exe /s and click Ok. (Note: there is a space in between “printui.exe” and “/s”) Click on the 'Drivers' tab; Look for HP Printer driver. If you see it Click on it and click Remove at the. Aug 04, 2014 Click Install from a list or specific location then Next Check Include this location in the search then Browse to the folder you saved on your Desktop (I.e. The extracted ZIP file) then Next.
Sometimes you may come across the strange problem of being unable to Delete File or Folder in Windows 10. You will find below the steps to fix this issue in Windows 10.
Unable to Delete File or Folder in Windows 10
The problem of being unable to delete a File or Folder in Windows 10 can happen even if the File or Folder was created by you and you do have the permission to edit the File or Folder.
In most cases, the reason for being Unable to Delete File or Folder in Windows 10 is due to the requested File or Folder being open or locked up by a process on your computer.
In most single User cases, this problem can be fixed by Restarting the computer. In some cases, you may be required to change File permissions.
1. Restart Your Computer
The simplest way to fix the problem of being unable to delete File or Folder in Windows 10 is to simply Restart your computer.
This helps in closing or terminating the process that was keeping the File or Folder busy and preventing it from being deleted.
If this does not work, completely Power OFF your computer using the Power button > Wait for 60 seconds and Restart your computer.
2. Stop the Process
In case you do not want to reboot the computer, you can use the Task Manager to terminate Tasks that are keeping the File occupied and preventing it from being deleted.
1. Right-click on the Start button and click on Task Manager.
2. On the Task Manager screen, click on the Processes Tab and stop the Program or Process that is keeping the File or Folder busy.
For example, if the file that you are trying to delete is an Excel or Word File, you should be able to find Excel/Word related processes in the Task Manager.
Simply, right-click on the Process that you want to stop and click on End Task.
3. Change Permissions
If you are unable to delete File or Folder in Windows 10 due to lack of permissions, you can follow the steps below to change the permission levels for the concerned File or Folder.
1. Right-click the File/Folder that you are unable to delete and click on Properties.
2. On the Properties screen, click on the Security tab and then click on Advanced.
3. On the next screen, click on the Permissions tab and see if there is any permission entry that contains “Deny”.
If you find any entry containing “Deny”, select the Entry and click on the Remove button.
4. Click on OK to save changes and exit the Permissions screen.
Now you should be able to delete the File or Folder that you were unable to delete on your computer.
-->Getting Diagnostic Information
Xamarin.Android has a few places to look when tracking down various bugs.These include:
- Diagnostic MSBuild output.
- Device deployment logs.
- Android Debug Log Output.
Diagnostic MSBuild Output
Diagnostic MSBuild can contain additional information relating to packagebuilding and may contain some package deployment information.
To enable diagnostic MSBuild output within Visual Studio:
- Click Tools > Options...
- In the left-hand tree view, select Projects and Solutions > Build and Run
- In the right-hand panel, set the MSBuild build output verbosity dropdown to Diagnostic
- Click OK
- Clean and rebuild your package.
- Diagnostic output is visible within the Output panel.
To enable diagnostic MSBuild output within Visual Studio for Mac/OS X:
- Click Visual Studio for Mac > Preferences...
- In the left-hand tree view, select Projects > Build
- In the right-hand panel, set the Log verbosity drop-down to Diagnostic
- Click OK
- Restart Visual Studio for Mac
- Clean and rebuild your package.
- Diagnostic output is visible within the Errors Pad (View > Pads > Errors ), by clicking the Build Output button.
Device Deployment Logs
To enable device deployment logging within Visual Studio:
- Tools > Options...>
- In the left-hand tree view, select Xamarin > Android Settings
- In the right-hand panel, enable the [X] extension debug logging (writes monodroid.log to your desktop) check box.
- Log messages are written to the monodroid.log file on your desktop.
Visual Studio for Mac always writes device deployment logs. FInding them isslightly more difficult; a AndroidUtils log file is created for everyday + time that a deployment occurs, for example: AndroidTools-2012-10-24_12-35-45.log.
- On Windows, log files are written to
%LOCALAPPDATA%XamarinStudio-{VERSION}Logs
. - On OS X, log files are written to
$HOME/Library/Logs/XamarinStudio-{VERSION}
.
Android Debug Log Output
Android will write many messages to theAndroid Debug Log.Xamarin.Android uses Android system properties to control thegeneration of additional messages to the Android Debug Log. Androidsystem properties can be set through the setprop command within theAndroid Debug Bridge (adb):
System properties are read during process startup, and thus must beeither set before the application is launched or the application mustbe restarted after the system properties are changed.
Xamarin.Android System Properties
Xamarin.Android supports the following system properties:
- debug.mono.debug: If a non-empty string, this is equivalent to
*mono-debug*
. - debug.mono.env: A pipe-separated ('|') list of environmentvariables to export during application startup, before mono hasbeen initialized. This allows setting environment variables thatcontrol mono logging.NoteSince the value is '|'-separated, the value must havean extra level of quoting, as the `adb shell` command willremove a set of quotes.NoteAndroid system property values can be no longer than 92characters in length.Example:
- debug.mono.log: A comma-separated (',') list of components thatshould print additional messages to the Android Debug Log. Bydefault, nothing is set. Components include:
- all: Print all messages
- gc: Print GC-related messages.
- gref: Print (weak, global) reference allocation and deallocation messages.
- lref: Print local reference allocation and deallocation messages.
NoteThese are extremely verbose. Do not enable unless you really need to. - debug.mono.trace: Allows setting the mono --trace
=PROPERTY_VALUE
setting.
Deleting bin
and obj
Xamarin.Android has suffered in the past from a situation such as:
- You encounter a strange build or runtime error.
- You
Clean
,Rebuild
, or manually delete yourbin
andobj
directories. - The problem goes away.
We are heavily invested into fixing problems such as these due to their impact on developer productivity.
If a problem such as this happens to you:
- Make a mental note. What was the last action that got your project into this state?
- Save your current build log. Try building again, and record a diagnostic build log.
- Submit a bug report.
Before deleting your
bin
and obj
directories, zip them up and save them for later diagnosis if needed. You can probably merely Clean
your Xamarin.Android application project to get things working again.Xamarin.Android cannot resolve System.ValueTuple
This error occurs due to an incompatibility with Visual Studio.
- Visual Studio 2017 Update 1 (version 15.1 or older) is only compatible with the System.ValueTuple NuGet 4.3.0 (or older).
- Visual Studio 2017 Update 2 (version 15.2 or newer) is only compatible with the System.ValueTuple NuGet 4.3.1 (or newer).
Please choose the correct System.ValueTuple NuGet that corresponds with your Visual Studio 2017 installation.
GC Messages
GC component messages can be viewed by setting the debug.mono.log systemproperty to a value that contains gc.
GC messages are generated whenever the GC executes and provides informationabout how much work the GC did:
Additional GC information such as timing information can be generated bysetting the
MONO_LOG_LEVEL
environment variable to debug
:This will result in (lots of) additional Mono messages, including thesethree of consequence:
In the
GC_BRIDGE
message, num-objects
is thenumber of bridge objects this pass is considering, and num_hash_entries
is the number of objects processed during thisinvocation of the bridge code.In the
GC_MINOR
and GC_MAJOR
messages, total
is the amount of time while the world is paused (no threadsare executing), while bridge
is the amount of time taken in thebridge processing code (which deals with the Java VM). The world is not paused while bridge processing occurs.In general, the larger the value of
num_hash_entries
,the more time that the bridge
collections will take, and thelarger the total
time spent collecting will be.Global Reference Messages
To enable Global Reference loggig (GREF) logging, the debug.mono.logsystem property must contain gref, e.g.:
Xamarin.Android uses Android global references to provide mappings betweenJava instances and the associated managed instances, as when invoking a Javamethod a Java instance needs to be provided to Java.
Unfortunately, Android emulators only allow 2000 global references to existat a time. Hardware has a much higher limit of 52000 global references. Thelower limit can be problematic when running applications on the emulator, soknowing where the instance came from can be very useful.
Note
The global reference count is internal to Xamarin.Android,and does not (and cannot) include global references taken out by other nativelibraries loaded into the process. Use the global reference count as anestimate.
Hp Installer Cannot Delete Output File Mac
There are four messages of consequence:
- Global reference creation: these are the lines that start with +g+ , and will provide a stack trace for the creating code path.
- Global reference destruction: these are the lines that start with -g- , and may provide a stack trace for the code path disposing of the global reference. If the GC is disposing of the gref, no stack trace will be provided.
- Weak global reference creation: these are the lines that start with +w+ .
- Weak global reference destruction: these are lines that start with -w- .
In all messages, The grefc value is the count of global referencesthat Xamarin.Android has created, while the grefwc value is the countof weak global references that Xamarin.Android has created. The handleor obj-handle value is the JNI handle value, and the character afterthe ' /' is the type of handle value: /L for local reference, /G for global references, and /W for weak globalreferences.
As part of the GC process, global references (+g+) are converted into weakglobal references (causing a +w+ and -g-), a Java-side GC is kicked, and thenthe weak global reference is checked to see if it was collected. If it's stillalive, a new gref is created around the weak ref (+g+, -w-), otherwise the weakref is destroyed (-w).
Java instance is created and wrapped by a MCW
A GC is being performed...
Object is still alive, as handle != null
wref turned back into a gref
Object is dead, as handle null
wref is freed, no new gref created
There is one 'interesting' wrinkle here: on targets running Android prior to4.0, the gref value is equal to the address of the Java object in the Android runtime'smemory. (That is, the GC is a non-moving, conservative, collector, and it'shanding out direct references to those objects.) Thus after a +g+, +w+, -g-,+g+, -w- sequence, the resulting gref will have the same value as the originalgref value. This makes grepping through logs fairly straightforward.
Android 4.0, however, has a moving collector and no longer hands out directreferences to Android runtime VM objects. Consequently, after a +g+, +w+, -g-, +g+, -w-sequence, the gref value will be different. If the object survivesmultiple GCs, it will go by several gref values, making it harder to determinewhere an instance was actually allocated from.
Querying Programmatically
You can query both the GREF and WREF counts by querying the
JniRuntime
object.Java.Interop.JniRuntime.CurrentRuntime.GlobalReferenceCount
- Global Reference Count![Hp installer cannot delete output file download Hp installer cannot delete output file download](/uploads/1/1/8/8/118820164/644867263.png)
Java.Interop.JniRuntime.CurrentRuntime.WeakGlobalReferenceCount
- Weak Reference CountAndroid Debug Logs
The Android Debug Logs may provide additional context regarding any runtime errors you'reseeing.
Floating-Point performance is terrible!
Alternatively, 'My app runs 10x faster with the Debug build than with theRelease build!'
Xamarin.Android supports multiple device ABIs: armeabi,armeabi-v7a, and x86. Device ABIs can be specified within ProjectProperties > Application tab > Supported architectures.
Hp Installer Cannot Delete Output File Windows 7
Debug builds use an Android package which provides all ABIs, and thus willuse the fastest ABI for the target device.
Release builds will only include the ABIs selected in the Project Propertiestab. More than one can be selected.
armeabi is the default ABI, and has the broadest device support. However, armeabi doesn't support multi-CPU devices and hardwarefloating-point, amont other things. Consequently, apps using the armeabi Releaseruntime will be tied to a single core and will be using a soft-floatimplementation. Both of these can contribute to significantly slower performancefor your app.
If your app requires decent floating-point performance (e.g. games), youshould enable the armeabi-v7a ABI. You may want to only support the armeabi-v7a runtime, though this means that older devices which onlysupport armeabi will be unable to run your app.
Could not locate Android SDK
There are 2 downloads available from Google for the Android SDK for Windows.If you choose the .exe installer, it will write registry keys that tellXamarin.Android where it was installed. If you choose the .zip file and unzip ityourself, Xamarin.Android does not know where to look for the SDK. You can tellXamarin.Android where the SDK is in Visual Studio by going toTools > Options > Xamarin > Android Settings:
IDE does not display target device
Sometimes you will attempt to deploy your application to a device, butthe device you want to deploy to isn't shown in the Select Devicedialog. This can happen when the Android Debug Bridge decides to go onvacation.
To diagnose this issue, find theadb program,then run:
If your device isn't present, then you need to restart the Android Debug Bridge server so that your device can be found:
HTC Sync software may prevent adb start-server from workingproperly. If the adb start-server command doesn't print out whichport it's starting on, please exit the HTC Sync software and tryrestarting the adb server.
The specified task executable 'keytool' could not be run
This means that your PATH does not contain the directory where the JavaSDK's bin directory is located. Check that you followed those stepsfrom theInstallation guide.
monodroid.exe or aresgen.exe exited with code 1
To help you debug this problem, go into Visual Studio and change theMSBuild verbosity level, to do this, select: Tools > Options >Project and Solutions > Build and Run > MSBuild Project BuildOutput Verbosity and set this value to Normal.
Rebuild, and check Visual Studio's Output pane, which should contain the full error.
There is not enough storage space on the device to deploy the package
This occurs when you don't start the emulator from within VisualStudio. When starting the emulator outside of Visual Studio, you needto pass the
-partition-size 512
options, e.g.Ensure you use the correct simulator name, i.e.the name you used when configuring the simulator.
INSTALL_FAILED_INVALID_APK when installing a package
Android package names must contain a period ('.'). Edit your package name so that it contains a period.
- Within Visual Studio:
- Right click your project > Properties
- Click the Android Manifest tab on the left.
- Update the Package name field.
- If you see the message “No AndroidManifest.xml found. Click to add one.”, click the link and then update the Package name field.
- Within Visual Studio for Mac:
- Right click your project > Options.
- Navigate to the Build / Android Application section.
- Change the Package name field to contain a '.'.
INSTALL_FAILED_MISSING_SHARED_LIBRARY when installing a package
A 'shared library' in this context is not a native sharedlibrary (libfoo.so) file; it is instead a library that must beseparately installed on the target device, such as Google Maps.
The Android package specifies which shared libraries are required withthe
<uses-library/>
element. If a required library is not presenton the target device (e.g. //uses-library/@android:required
istrue, which is the default), then package installation will fail withINSTALL_FAILED_MISSING_SHARED_LIBRARY.To determine which shared libraries are required, view the generatedAndroidManifest.xml file (e.g.objDebugandroidAndroidManifest.xml) and look for the
<uses-library/>
elements. <uses-library/>
elements can be addedmanually in your project's PropertiesAndroidManifest.xml file and via theUsesLibraryAttribute custom attribute.For example, adding an assembly reference toMono.Android.GoogleMaps.dll will implicitly add a
<uses-library/>
for the Google Maps shared library.INSTALL_FAILED_UPDATE_INCOMPATIBLE when installing a package
Android packages have three requirements:
- They must contain a '.' (see previous entry)
- They must have a unique string package name (hence the reverse-tld convention seen in Android app names, e.g. com.android.chrome for the Chrome app)
- When upgrading packages, the package must have the same signing key.
Thus, imagine this scenario:
- You build & deploy your app as a Debug app
- You change the signing key, e.g. to use as a Release app (or because you don't like the default-provided Debug signing key)
- You install your app without removing it first, e.g. Debug > Start Without Debugging within Visual Studio
When this happens, package installation will fail with aINSTALL_FAILED_UPDATE_INCOMPATIBLE error, because the package namedidn't change while the signing key did. TheAndroid Debug Logwill also contain a message similar to:
To fix this error, completely remove the application from your devicebefore re-installing.
INSTALL_FAILED_UID_CHANGED when installing a package
When an Android package is installed, it is assigned a user id (UID).Sometimes, for currently unknown reasons, when installing over an alreadyinstalled app, the installation will fail with
INSTALL_FAILED_UID_CHANGED
:![Hp installer cannot delete output file windows 7 Hp installer cannot delete output file windows 7](/uploads/1/1/8/8/118820164/166441840.png)
To work around this issue, fully uninstall the Android package, either byinstalling the app from the Android target's GUI, or using
adb
:DO NOT USE
adb uninstall -k
, as this will preserve application data,and thus preserve the conflicting UID on the target device.Release apps fail to launch on device
Does the Android Debug Log output will contain a message similar to:
If so, there are two possible causes for this:
- The .apk doesn't provide an ABI that the target device supports.For example, the .apk only contains armeabi-v7a binaries, and thetarget device only supports armeabi.
- An Android bug. Ifthis is the case, uninstall the app, cross your fingers, andreinstall the app.
To fix (1), edit the Project Options/Properties andadd support for the required ABI to the list of Supported ABIs. Todetermine which ABI you need to add, run the following adb commandagainst your target device:
The output will contain the primary (and optional secondary) ABIs.
The OutPath property is not set for project “MyApp.csproj”
This generally means you have an HP computer and the environmentvariable “Platform” has been set to something like MCD orHPD. This conflicts with the MSBuild Platform property that isgenerally set to “Any CPU” or “x86”. You willneed to remove this environment variable from your machine beforeMSBuild can function:
- Control Panel > System > Advanced > Environment Variables
Restart Visual Studio or Visual Studio for Mac and try to rebuild. Thingsshould now work as expected.
java.lang.ClassCastException: mono.android.runtime.JavaObject cannot be cast to...
Xamarin.Android 4.x doesn't properly marshal nested generic typesproperly. For example, consider the following C# code usingSimpleExpandableListAdapter:
The problem is that Xamarin.Android incorrectly marshals nested generictypes. The
List<IDictionary<string, object>>
is being marshaled to ajava.lang.ArrrayList,but the ArrayList
is containing mono.android.runtime.JavaObject
instances (which reference the Dictionary<string, object>
instances)instead of something that implementsjava.util.Map,resulting in the following exception:The workaround is to use the providedJava Collection types insteadof the
System.Collections.Generic
types for the “inner”types. This will result in appropriate Java types when marshaling theinstances. (The following code is more complicated than necessary inorder to reduce gref lifetimes. It can be simplified to altering theoriginal code via s/List/JavaList/g
ands/Dictionary/JavaDictionary/g
if gref lifetimes aren't a worry.)This will be fixed in a future release.
Unexpected NullReferenceExceptions
Occasionally theAndroid Debug Logwill mention NullReferenceExceptions that “cannot happen,”or come from Mono for Android runtime code shortly before the app dies:
or
This can happen when the Android runtime decides to abort the process,which can happen for any number of reasons, including hitting thetarget's GREF limit or doing something “wrong” with JNI.
To see if this is the case, check the Android Debug Log for a messagefrom your process similar to:
Abort due to Global Reference Exhaustion
The Android runtime's JNI layer only supports a limited number of JNIobject references to be valid at any given point in time. When thislimit is exceeded, things break.
The GREF (global reference) limit is 2000 references in the emulator, and ~52000 references on hardware.
You know you're starting to create too many GREFs when you see messages such as this in the Android Debug Log:
When you reach the GREF limit, a message such as the following is printed:
In the above example (which, incidentally, comes frombug 685215) theproblem is that too many Android.Graphics.Point instances are beingcreated; seecomment #2for a list of fixes for this particular bug.
Typically, a useful solution is to find which type has too manyinstances allocated – Android.Graphics.Point in the above dump– then find where they're created in your source code and disposeof them appropriately (so that their Java-object lifetime isshortened). This is not always appropriate (#685215 is multithreaded,so the trivial solution avoids the Dispose call), but it's the firstthing to consider.
You can enableGREF Loggingto see when GREFs are created and how many exist.
Abort due to JNI type mismatch
If you hand-roll JNI code, it's possible that the types won't matchcorrectly, e.g. if you try to invoke
java.lang.Runnable.run
on a typethat doesn't implement java.lang.Runnable
. When this occurs, therewill be a message similar to this in the Android Debug Log:Dynamic Code Support
Dynamic code does not compile
To use C# dynamic in your application or library, you have to addSystem.Core.dll, Microsoft.CSharp.dll and Mono.CSharp.dll to yourproject.
In Release build, MissingMethodException occurs for dynamic code at run time.
- It is likely that your application project does not have referencesto System.Core.dll, Microsoft.CSharp.dll or Mono.CSharp.dll. Makesure those assemblies are referenced.
- Keep in mind that dynamic code always costs. If you need efficient code, consider not using dynamic code.
- In the first preview, those assemblies were excluded unless typesin each assembly are explicitly used by the application code. Seethe following for a workaround:http://lists.ximian.com/pipermail/mo...il/009798.html
Projects built with AOT+LLVM crash on x86 devices
When deploying an app built withAOT+LLVMon x86-based devices, you may see an exception error message similar tothe following:
This is a known issue – the workaround is to disable LLVM.