I have a client server program to communicate the pc with an android phone using usb, based on http://www.anothem.net/archives/2010/10/15/android-usb-connection-to-pc/
Now I need to design a protocol that facilitates information exchange from the pc to the phone. How should I go about this ? Should we use XML for this? I was looking at google protocol buffer.. Is that the right direction ?
Thanks
Caroline
I've been using protocol buffers on Android. I avoided it for a long time, reasoning that it was overkill. That was before I took half a day to try it out.
Here were my results, after spending an afternoon on it. At first it increased my APK size from 2.89megs to 3.1 megs. I consider that inconsequential. Then I found that I was able to delete code I had all over the place, where I had been doing parsing manually. I was able to delete code that required the data to come in in a specific sequence.
Then I was able to completely delete a few classes I had in my application, whose purpose was to serve as temporary, lightweight information-only "model" classes that represented data coming to or from the data stream. In short, it started making things way easier and smaller, and more reliable.
Protocol Buffers may well be not the best thing for your situation. But I do recommend that you take a few hours and try it out. That way you'll be making your decision to leave it behind from a position of strength and knowledge.
Be sure to use the lite version of protocol buffers. The .jar file is 160k, but the amount of functionality it brings is huge. I'll be using it all the time from here on out.
I do have some concerns about dynamic memory allocation / garbage collection when using it in a game context long term. But for now the serialization happens infrequently enough that it's a non-issue for me.
Another bonus: I have some Python code that generates data files that the application reads. That python code processes some XML and then generates binary files. I think I'll be able to completely eliminate that code by using protocol buffer's text mode, then using protoc directly to create binary files.
You need first to design the higher layer of your protocol. Xml and protocol buffers have to do with how the data are formatted. Depending on the data you need to exchange they may or not be suitable. From what you way in your comment, it seems that you want to develop something like a remote control for your PC. In that case both XML and Google Protocol Buffers will be an overdesign. Simply create a text protocol, allocate a byte or two for the command type and some bytes for the data body.
Have a look at the AT commands structure. The structure of an HDLC frame could also give you some ideas. This has some things like error checking, which you don't need, but other than that a simple text protocol will use similar fields.
Related
Suppose you have a common communication protocol between your app and webservice. This protocol never changes and has a high demand.
I was thinking, to get a better performance use ASN.1(or other in-house bit code protocol) protocolo to code all information inside Android before send to webservice.
Today, I use json encode, and after I gzip all information before send to the webservice. I have the cost of zipping and unzipping the data, more json_decode and encode for both sides.
I know that to code to ASN.1 I will have bit operations to code and decode, but generally they are really fast. And other point that I am planning to NOT zip this information, once I am using bit coding the size will be reduced naturally.
An important observation is that I want to get a better perfomance to the server side. The client performance issue is not a problem here.
I have more then 50 fields that is continiously writing in the .proto file but my query is that
1) if I need to read only 10 fields then how can this be achieve.
2) If I need to read partial data from the particular field then how can I achieve.
this should be done without loading all the data from the .proto file.
Thanks for your concern.
This is not really possible with Protobufs. In theory you could write a streaming parser that might be able to extract part of the message without parsing the whole thing, but it would only work if the fields you needed happened to be located towards the front of the message, since you'd at least have to parse through everything before the fields you want. In any case, none of the standard protobuf implementations provide an easy way to do streaming parses, because this isn't the way protobuf is designed to be used. Some third-party implementations, such as upb, might help.
On the other hand, Cap'n Proto, an alternative to Protocol Buffers, does support reading just one field out of a large file, without having to parse the fields before it. It does this by placing fields at fixed offsets and taking advantage of mmap() for large files.
Disclosure: I am the author of both Cap'n Proto and Protocol Buffers v2 (the version open sourced by Google).
I am working on a telehealth device showcase.
I have found Mirth Connect but no able to get hold on it that much. Is there any other api or frees source or library which can be used on our android client to convert xml into HL7 or any other format to HL7.
It seems no one wants to speak up so I'll try. First of all, there are two distinct HL7 formats – HL7v2 and HL7v3. So your first question would be – I have some data stored in the database (in a flat file in the XML format; in a flat file in JSON; etc) and I’d like to map it to HL7v2/HL7v3/CDA/etc.
Since both HL7v2 and HL7v3 cover multiple domains (e.g., Patient Administration, Medical Records, Genomics, etc.) your next question would be to specify what you are trying to achieve. If it’s a single domain solution, i.e., Pharmacy Dispensing System notifications or a full-fledged multi-domain solution.
The next one, what open-source system to use if any – Mirth Connect or something else. It also depends on where the data mapping or transformation is done – on the client side or on the server side (i.e., you can send a request message in your own format and transform it to the HL7 on the server side before passing to other players).
I presume, and I might be incorrect, we are talking about the patient demographic data using HL7v2 running on a patient's mobile phone. The Mirth Connect, as your initial format to HL7v2 translator, may be Ok for prototyping, running as a black box somewhere, but for the real solution on the mobile phone it might be too excessive. If there are quite a few request messages I would build them as my own proprietary code. If your solution is more complex, then it requires reviewing the solution architecture to find out all transformation points and this goes a bit beyond than a discussion on this site.
Again, this is my very subjective opinion.
And the last, but not least, there is an "Unofficial Mirth Connect Developer's Guide" book which may help in initial understanding what the Mirth Connect is capable of.
(Disclaimer: I'm the author of this book, so any comments or suggestions are welcome.)
For creation of some simple HL7 v2 messages you don't need any special libraries or tools or as it is almost simple text piped format (actually it is a binary format but if you take care about correct segment delimiters and don't use other then ASCII characters then it is straightforward to create).
Once you have the HL7 packet you can send it to an IP address with HL7 listening endpoint using the HL7 Minimal Lower Layer Protocol (MLLP).
Some open source code base that might be useful even on Adroid device are Java libraries used by the dcm4chee project.
e.g. the DICOM Clinical Data Manager system - image archive is able to communicate with both DICOM and HL7 systems and internally uses code that translates HL7 v2 messages into XML intermediate representation and back. Look for XSLT (*.xsl) transformation scripts.
I am looking to develop a transit app using GTFS static data. One of the constraints I've set to myself is that the app should use minimal mobile data transfers. Therefore, I would like to embed all the data in the app.
My issue is that GTFS data sets are usually quite large (85MB uncompressed for the city of Sydney for example). I've done a bit of reverse engineering on other apps out there and found out that some of them have managed to compress all that data into a much smaller file (I'm talking about a few MB at most).
Using 7zip, I've managed to compress my 85MB data set down to 5MB which is acceptable for me. The next step is for me to use that 7z file into my app and that's where I'm stuck. There's no way I'm going to uncompress it and put it in a SQL database as that will use too much space on the phone. So I was wondering what are my other options.
Thanks
First, for embedding, I recommend using the Embedded XZ library (similar to 7zip). I have embedded this in a project and had good luck with it. Just be sure to compress data using 'xz --check=crc32' so it's compatible with Embedded XZ, and remember to initialize the CRC table.
As for a decompression strategy, you may need to segment the data in such a way that you can decompress different parts of it on demand (i.e., a tree of databases). I'm not familiar with your data's characteristics. Will a user need it all loaded at the same time? Or can it easily be compartmentalized?
Also, XZ can be a bit slow, even to decode. Have you evaluated how well regular gzip performs? That tends to be A) very fast; and B) available as a standard part of all embedded and mobile frameworks.
Use protocol binary format (pbf) formely google and now open source. It is compact and very fast searchable, so no need to decompress it on a device and load it into a database on that device because pbf acts as a database. Just include pbf library in your code to query it. Of course you have to compress it once before distributing the data online.
I am a php/mysql developer learning android. I am creating an android app that receives info from my php app to create list views of different products which will open a web view of that product's detail.
Currently my php cms web application outputs xml lists for an iphone app.... (also, separately outputs html). I have full control of the php app so if there is a better way to output the data for the android app please let me know.
I have created code that reads the xml from the web and creates the list view. The list can be refreshed daily, so the data does not need to be read from the online xml every time the app starts.
So I was thinking to store the data retrieved locally to improve my apps responsiveness. there may be up to 500 product descriptions to be stored at any given time in up to 30 different xml lists. I am starting development with one xml list with about 30 products.
For best performance should i store the product info in a sqlLite db or should i store the actual xml file in the cache/db or some other method like application cache.
I also was think to create the update of the data as a service, would this be a good idea?
The most efficient way to store data is RAM. But if you want to cache it, then the most efficient way is Database.
I recommend you store your data in sqlite android database.
You could also consider zipping you xml for faster network transfer and unzipping through java.util.zip package classes. You could even consider a simpler format for transmitting data, less verbose than xml, using a datainput/outputstream.
(I do that in of my apps and it works great)
Here are some details on data input / output stream method :
imagine a proprietary protocol for your data, only what you need. No tags, no attributes, just raw values in order.
on the client side, get an input stream on your data using URL.getContent() and cast it in input stream.
on the client side still, build a data input stream encapsulating your socket input stream and read data in order. Use readInt, readDouble, readUTF, and so on.
on the client side, from php, you need to find a way to save your data in a format that is compatible with the data format expected by the client. I can't tell much about PHP, I only program using java.
The advantage of this technique is that you save bandwith as there is only data and no verbose decoration due to xml. You should read about java specs to understand how double, int, strings are written in data output stream. But it can be hard using two languages to get the data right.
If php can't save format in a suitable way, use xml, it will be much simpler. First try with just plain xml, then give a try using a zip or tarball or xml file.
But all this is about speed gain during network connection.
The second part of what you have to do is to store each row of your list in a SQL table. Then you can retrieve it pretty fast using a CursorAdapter for your list view (it breaks the charming MVC model but it is quite fast !).
Sorry about this, but it became too long to write as a comment. This is not intended to be an answer to your question, because in my opinion Stéphane answered very well. The best solution is indeed to store the data in an sqlite database. Then you need to create the class to be used as a connection between the data, the database and the app. I don't want to take credit for what is said here already (I, too, voted it up).
I'm concerned with the other suggestion (use of low level raw streams for data manipulation, the list steps on that answer). I strongly recommend you to avoid creating your own proprietary protocol. It goes like this:
I need to exchange data.
I don't want to deal with the hassle of integrating external APIs into my code.
I know I can write two 5 minute routines to read and write the data back and forth.
Therefore, I just created my own proprietary format for exchanging data!
It makes me cry whenever I need to deal with unknown, obscure and arbitrary sequence of data blobs. It's always good to remember why we should not use unknown formats:
Reinventing the wheel is counter-productive. It seems not, but on the middle term it is. You can adapt your project to other mediums (server-side, other platforms) easily.
Using off-the-shelf components help you scale your code later.
Whenever you need to adapt your solution to other technologies and mediums, you'll work faster. Otherwise, you would probably end up with ad hoc code solutions that are not (easily) extensible and interoperable.
Using off the shelf components enables you to leverage advances in that particular technology. That's particularly important when you are using Android APIs, as they are frequently optimized for performance later down the road (See Android's Designing for Performance). Rolling your own standards may result in a performance penalty.
Unless you document your protocol, it's extremely easy to forget the protocol you created yourself. Just give it enough time and it will happen: you'll need to relearn/remember. If you document, then you are just wasting the computational time of your brain.
You think you don't need to scale your work, but chances are you will most of the time.
When you do, you will wish you had learned how to easily and seamlessly integrate well known formats.
The learning curve is needed anyway. In my experience, when you learn, you actually integrate well known formats faster than imagining your own way of doing things.
Finally, trust your data to geniuses that take their lives into creating cohesive and intelligent standards. They know it better!
Finally, if the purpose is to avoid the typical verbosity of XML, for whatever reasons, you have several options. Right now I can think of CSV, but I'm no expert in data storage, so if you're not confortable with it, I'm sure you can find good alternatives with plenty of ready to use APIs.
Good luck!