We are in the process of developing app for an POS(point of sale) system in which we need to design some kind of driver to capture the data that is going for print. We need to develop specifically the driver to capture the data between POS application and printer device driver. If anybody can provide some idea as to how to approach to this problem.
Is it possible with virtual driver to extract data to text file then print the document ?
Related
The 0.5.1-devpreview BSP for RPI3 comes with libtinyalsa.so, libalasautils.so but seemingly no adb shell commandline support for audio.
We are designing a custom audio board (with audio processor) for use with Android Things and Raspberry Pi and we would typically use ALSA utilities and custom kernel drivers for accessing this board under Raspian.
It is possible the default Android Things I2S peripheral drivers and Peripheral Manager support the stream interfaces we need (the same way the VoiceHat drivers were wrapped), but we have little to no information on the default drivers in the RPI3 BSP, and we don't have any information on how to override the default drivers in Android Things without a distro rebuild.
Seems silly to write a Native C++ low-level peripheral driver when so many audio processor companies already provide ALSA-ready ASoC drivers for device source tree use.
Best practices for writing your own audio driver for Android Things?
The VoiceHat driver is one example of how to do a userspace audio driver.
If you're using a custom audio board, you should be aware of the audio chip the board uses. Looking at that chip's datasheet, you should be able to use the same peripheral I/O (UART, GPIO, I2C, SPI) to configure the connection and read/write data over the I2S bus.
In the Google Assistant sample, the app registers the VoiceHat at the beginning of the activity and unregisters it at the end of the activity.
I am developing a smartcard UMDF windows driver. I would like to achieve following behaviour:
When listing all connected readers by using API call SCardListReaders I want to retrieve the correct friendly names for each attached reader. So for example if I have two readers of same brand I want this to be returned by the driver:
SmartcardBrand USBReader 0
SmartcardBrand USBReader 1
I know that the friendly name is composed of the attributes SCARD_ATTR_VENDOR_NAME, SCARD_ATTR_VENDOR_IFD_TYPE and SCARD_ATTR_DEVICE_UNIT the driver returns.
My question is, in my driver, how can I distinguish between SmartcardBrand USBReader 0 and SmartcardBrand USBReader 1?
What shall I return to the OS when SCARD_ATTR_DEVICE_UNIT is requested. I cannot use and increment a global static variable in my driver because every time a new reader gets connected a new UMDF host process is launched (I can see it in the task manager) resulting in a separate new memory area.
What is the proper way of counting device instances in a UMDF driver?
I solved the problem by using memory-mapped files. Basically each UMDF process of my driver creates a memory-mapped file with name of the reader's friendly name. When an other process tries to create a file with the same name it indicates that a driver is already running.
However, there is inconsistency when I connect a reader which uses my driver and afterwards connect a reader which uses Windows native driver. The Windows driver will not see my memory-mapped file I created and apply index 0 for its device.
I found out that, when the Windows driver is loaded it queries SCARD_ATTR_VENDOR_IFD_TYPE, SCARD_ATTR_VENDOR_IFD_TYPE and SCARD_ATTR_DEVICE_UNIT from my driver (and from all other drivers currently loaded). I guess this way the Windows driver can know which device units are taken and apply a free one to its reader.
I'm trying to build a virtual printer.
There are already some answers like this and this.
However my demand is more specific. I just want to create a virtual printer that can be added into the system and can be accessed from any application. On clicking print command, a dialog looks like a real printer pops out and generates a PDF on printing. Then some more actions, like pushing the PDF to my server, are performed.
Do I need to dig into Windows Driver Kit? Or is there any free SDK for this?
Thanks.
Not sure if this question is still relevant to you, but you'd probably want to think about something like this:
Use the WDK (Windows Driver Kit) to create a Unidrv UI plugin. This will allow you to specify UI during the print (for your printer dialogue). The reason why you'd want to show UI here is because it's one of the only printer driver components that runs in the user session (the same process as the printing application). The XPS pipeline and port monitor are both session 0.
If you want to stick to MS convention, you'll do the spool file to PDF conversion in the render filter of the XPS Filter pipeline (this is if you're using an XPSDrv driver). The filter pipeline is where you have the opportunity to modify the XPS spool data coming in and in the final filter, convert it to your output document type (PDF in your case).
To do post print processing, you might want to consider creating a port monitor (again with the WDK) and kicking off a new process to do the post print processing after the port monitor writes out the print output to disk.
Only problem with this approach is that you can't use port monitors in Version 4 drivers (this is the new type of driver in Windows 8). Version 3 drivers still work in Win 8, but I guess they'll be phased out eventually.
Sorry it's probably not very obvious, but as I say, it's a high level overview (and unfortunately driver development is still very complex beyond a simple print to file). Version 4 printer drivers are becoming a lot easier to develop, but unfortunately with the removal of port monitor support and other improvements, it makes it a lot harder to develop anything requiring post processing.
[DISCLAIMER: I'm associated with the Mako SDK R&D team]
I know you asked for a free SDK, unfortunately I don't know of anything that would be suitable, but I know our company offer a Virtual Printer Platform (SDK) which would be good for you (prints to PDF and supports post print processing). You can find more information at the Mako SDK website
Hope this helps a bit anyway. I know printer driver development can be very confusing at times!
After reading up and doing a lot of research, with the aim to setup up something like redmon and use the printer SDK, I have completed the project using this SDK: http://www.novapdf.com/pdf-sdk.html
This solution however will work with windows only.
[I am not affiliated with novaPDF]
I have investigated an OSX version, however this will be a different build, you can probably set something up using this method: http://www.jms1.net/osx-pdf-services.shtml [I have not yet tried this]
I have a Wi-Fi driver from a manufacturer. That driver has Plug and Play support. After the adapter has been inserted or removed, Windows CE has recognized it successfully. But at boot time, if the adapter is "inserted state", CE OS does not load it so I must remove then insert it.
I want to load the driver automatically during boot time. Is it possible?
Before, I've written a simple stream interface driver. I have edited project.reg to create a sub-key under HKLM\Devices\BuiltIn so that Device Manager can load automatically during boot time. And it was successfully loaded. But Wi-Fi driver is a non-stream driver. Can Device Manager load Wi-Fi driver automatically with the same way?
Are "all of drivers under HKLM\Drivers\BuiltIn" stream interface drivers? What differences are there between stream interface drivers and NDIS Wi-Fi drivers from the point of loading automatically during boot-time? I will very happy if you can explain it a little.
I want to load the driver automatically during boot time. Is it
possible?
Yes, it is definitely possible. That was the main purpose of plug and play devices. The WinCE device automatically loads a driver appropriate to the Plug 'n' Play device. There would not be any need for doing it manually. If so, then there is no need for a Plug 'n' Play functionality.
As this is not happening in your case, you could try the following
Have you checked with any other Plug-n-Play devices to the WinCE device?
Each time you plug-out and plug-in, is it installing the drivers or is it just loading? You can verify the debug logs to confirm this.
Are "all of drivers under HKLM\Drivers\BuiltIn" stream interface drivers? What differences are there between stream interface drivers and NDIS Wi-Fi drivers from the point of loading automatically during boot-time?
Actually, the block devices can also be loaded automatically, as similar to stream interface drivers. The HKEY_LOCAL_MACHINE\Drivers\BuiltIn registry key recognizes built-in block devices also.
You can refer this msdn link for further information regarding loading the block devices.
can you please help me with the following questions...
If I need a virtual printer that will convert a PostScript stream to a different format, do I have to implement a virtual printer from scratch or implement a rendering plug-in?
The rendering plug-in seems to support only certain customizations. Also the data invariably goes to the spooler which is not needed in this case.
If I implement a virtual printer driver does it completely replace the Microsoft PostScript Driver or the Microsoft Universal Driver?
Since my driver is virtual, does it matter if I write a PostScript compliant or a Universal Driver compliant one?
Any other method to convert a printed document to a custom document format apart from implementing a virtual printer driver? Can I hook on as a port monitor or something? From what I could understand I guess not.
What you need is a port monitor. You can create a virtual printer using the Microsoft Postscript driver found in the WDK. You don't need to provide any code for this part, just an INF and PPD file to describe your virtual printer. Once you have that working and installed, users will then see your virtual printer when they print from an app. This printer will produce a stream of Postscript like any standard Postscript printer, which will then be sent to the printer's port monitor.
Now add a port monitor to handle converting the Postscript stream to whatever format you need. Port monitors are considerably easier to deal with than print drivers.
EDIT: Andy points out in the comments that v4 (ie, Win8) print drivers don't support custom port monitors. However, v3 drivers will still work in Win8.
I know this is old, but these answers would have helped me a couple months ago, when I started this project. I spent a lot of time creating a port monitor, only to find a much easier method in the end (see WritePrinter link below).
If I need a virtual printer that will convert a PostScript stream to a
different format, do I have to implement a virtual printer from
scratch or implement a rendering plug-in?
Rendering plug-in is what you want.
The rendering plug-in seems to support only certain customizations.
Correct -- you'll have to decide if it is enough for you.
Also the data invariably goes to the spooler which is not needed in
this case.
This should not be an issue.
If I implement a virtual printer driver does it completely replace the
Microsoft PostScript Driver or the Microsoft Universal Driver?
If you implement a rendering plug-in, it does not replace the PS/Uni drivers. The PS/Uni drivers are in fact used by a huge number (maybe 90%?) of all "printer drivers". OEMs that make printers don't want to write their own drivers, so they use the PS/Uni driver design -- some create UI plug-ins, some rendering plug-ins, some both, some neither.
Since my driver is virtual, does it matter if I write a PostScript
compliant or a Universal Driver compliant one?
It depends what format you want the data in. If you want bitmap format, a Uni driver is better, if you want PostScript format, PS is better. If you want data for each line drawn, text out, and other GDI operations, then either is fine.
Any other method to convert a printed document to a custom document
format apart from implementing a virtual printer driver? Can I hook on
as a port monitor or something? From what I could understand I guess
not.
Most people that want raw access to the PostScript data, usually to use GhostScript to convert to PDF or other format, use a port monitor to do this. For example, the Virtual PDF Printer that Adobe ships with the full version of Acrobat (Writer), uses a port monitor, and also a rendering plug-in and a UI plug-in, for the PSCRIPT5 driver.
The problem with a port monitor is that it doesn't run in the context of the user -- not in the context of the application/process doing the printing. It runs in the context of the print spooler, and requires a lot of hacks to figure out which user/session is doing the printing.
If you want bitmap data, to save as a JPG/BMP/PNG, for example, then just create a rendering plug-in for the universal printer driver and access/save the bitmap data inside IPrintOemUni::FilterGraphics.
If you want PostScript data, to use with GhostScript (or other library, or your own code) to convert to PDF or other formats, then just create a rendering plug-in for the PSCRIPT5 driver and access/save the PS data inside IPrintOemUni2::WritePrinter.
In either case, you want a rendering plug-in. If you want to easily display a UI while printing, and want your code to run in the same context as the user, and not the spooler service, then make sure you set your printer to print directly to printer -- bypass the spooler. If you use AddPrinter to install your printer, you would use the PRINTER_ATTRIBUTE_DIRECT flag.
Not sure I fully understand. You have an app that produces Postscript and you want to convert that to something else? If the application outputs the 'print ready' data then a new printer driver isn't going to help as the 'queue/driver' is just a way to get the data to the printer and not something that is creating the output file.
You might be best to look at something like: Redmon
This can take the output and spawn an new process. The idea would be that you have it output the Postscript to a file and then you launch some console .exe that you create against it.
Just a thought.
Again not sure which way round you are doing this, but ghostscript is the simplest way to convert a PS output into any other format. It's also pretty easy to write your own output format for ghostscript.
This all happens at the app level - no need to write a driver.