traininfo/provider/OfflineStationProvider.java

package dk.thoerup.traininfo.provider;

import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;

import org.simpleframework.xml.Serializer;
import org.simpleframework.xml.core.Persister;

import android.content.Context;
import android.location.Location;
import android.util.Log;
import dk.thoerup.android.traininfo.common.StationBean;
import dk.thoerup.android.traininfo.common.StationEntry;
import dk.thoerup.genericjavautils.HttpUtil;
import dk.thoerup.traininfo.util.DownloadUtil;
import dk.thoerup.traininfo.util.IntSet;
import dk.thoerup.traininfo.util.XmlUtil;

public class OfflineStationProvider implements StationProvider {
        
        StationBean stations = new StationBean();


        public boolean loadStations(Context context) throws Exception {
                long start = System.currentTimeMillis();
                
                stations.entries.clear(); //TODO: remove
                
                File parent = context.getFilesDir();
                File stationsFile = new File(parent, "stations.bin");
                
                if (!stationsFile.exists())
                        return false;
                
                /*int size = (int) stationsFile.length();
                byte data[] = new byte[size];
                
                RandomAccessFile raf = new RandomAccessFile(stationsFile, "r");
                raf.readFully(data);
                
                Serializer serializer = new Persister();
                stations = serializer.read(StationBean.class,  new String(data, "ISO-8859-1") );*/
                
                
                try {
                        ObjectInputStream in = new ObjectInputStream( new FileInputStream(stationsFile) );
                        Object o;
                        StationEntry e = null;
                        while ( (o=in.readObject()) != null ) {
                                e = (StationEntry) o;
                                updateSearchStrings(e);
                                stations.entries.add( e );
                        }
                        in.close();
                } catch (EOFException e) {
                        //do nothing;
                }
                
                Log.e("OFFLINE", "loaded" + stations.entries.size());
                logElapsedTime(start, "loadStations");
                
                return true;
        }
        
        public void updateSearchStrings(StationEntry entry) {           
                entry.nameLower = entry.getName().toLowerCase();
                entry.nameInternational = entry.nameLower.replace("æ", "ae").replace("ø", "oe").replace("å", "aa");
        }
        
        public void downloadStations(Context context) throws Exception {
                File parent = context.getFilesDir();
                File stationsFile = new File(parent, "stations.bin");

                
                byte data[] = HttpUtil.getContent(XmlUtil.SERVICE_BASE + "/LocateStations?dump=1", 5000);
                Serializer serializer = new Persister();
                stations = serializer.read(StationBean.class,  new String(data, "ISO-8859-1") );
                
                
                ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream(stationsFile) );
                Log.e("OFFLINE", "data size" + data.length);
                
                for (StationEntry entry : stations.entries) {
                        updateSearchStrings( entry ); //prepare name fields for byName search
                        out.writeObject(entry);
                }
                
                out.close();            
        }
        
        
        @Override
        public void purgeOldEntries() {
        }

        Comparator<StationEntry> distanceComparator = new Comparator<StationEntry>() {
                @Override
                public int compare(StationEntry object1, StationEntry object2) {
                        if (object1.getCalcdist() == object2.getCalcdist())                                     
                                return 0;
                        
                        if (object1.getCalcdist() > object2.getCalcdist())
                                return 1;
                        else
                                return -1;
                }               
        };
        
        @Override
        public StationBean lookupStationsByLocation(Location location) {
                
                statsByLocation(location);
                
                long start = System.currentTimeMillis();
                Location tmpLoc = new Location("GPS");
                
                LinkedList<StationEntry> entries = new LinkedList<StationEntry>() ;
                
                for (StationEntry entry : stations.entries) {
                        tmpLoc.setLatitude(entry.getLatitude());
                        tmpLoc.setLongitude(entry.getLongitude());
                        
                        int distance = (int) location.distanceTo(tmpLoc);
                        
                        if (entries.size() <8 || entries.getLast().getCalcdist() > distance) {
                                entry.setCalcdist(distance);
                                
                                if (entries.size() == 8)
                                        entries.removeLast();
                                
                                entries.addLast(entry);
                                
                                Collections.sort( entries, distanceComparator);
                        }                       
                }
                
                logElapsedTime(start, "location_stage1");
                
                Collections.sort( entries, distanceComparator);
                
                StationBean tmpStations = new StationBean();
                for (int i = 0; i<8; i++) {
                        tmpStations.entries.add( entries.get(i) );
                }
                
                logElapsedTime(start, "location");
                return tmpStations;
        }
        
        private void logElapsedTime(long start, String method) {
                long now = System.currentTimeMillis();
                
                Log.i("TrainInfo", "Search by " + method + " elapsed " + (now-start) );
        }

        @Override
        public StationBean lookupStationsByName(String name) {
                
                long start = System.currentTimeMillis();
                
                name = name.toLowerCase();
                StationBean tmpStations = new StationBean();
                for (StationEntry entry : stations.entries) {
                        if (entry.nameLower.startsWith(name) || entry.nameInternational.startsWith(name) ) {
                                tmpStations.entries.add(entry);
                        }
                }
                logElapsedTime(start, "name");                          
                return tmpStations;
        }

        @Override
        public StationBean lookupStationsByIds(String ids) {
                statsByIds(ids);
                
                IntSet idset = new IntSet();
                idset.fromString(ids);
                
                StationBean tmpStations = new StationBean();
                for (StationEntry entry : stations.entries) {
                        if (idset.contains( entry.getId() ) ) {
                                tmpStations.entries.add(entry);
                        }
                }
                
                return tmpStations;
        }
        

        private void statsByLocation(Location location) {
                double lat = XmlStationProvider.roundToPlaces(location.getLatitude(), 4);
                double lng = XmlStationProvider.roundToPlaces(location.getLongitude(), 4);
                
                final String url = XmlUtil.SERVICE_BASE + "/LocateStations?latitude=" + lat + "&longitude=" + lng + "&dummy=1";
                Log.i("url", url);
                urlSender(url);
        }
        
        private void statsByName(String name) { 
                
                try {
                        name = URLEncoder.encode(name, "ISO8859-1");    
                } catch (Exception e) {
                        Log.e("lookupStations", "Encoding failed", e);//if encoding fails use original and hope for the best
                }
                
                String url = XmlUtil.SERVICE_BASE + "/LocateStations?name=" + name + "&dummy=1";
                Log.i("url", url);
                urlSender(url);
        }
        
        private void statsByIds(String ids) {   
                final String url = XmlUtil.SERVICE_BASE + "/LocateStations?list=" + ids + "&dummy=1";
                Log.i("url", url);
                urlSender(url);
        }
        
        private void urlSender(final String url) {
                Thread t = new Thread(new Runnable() {

                        @Override
                        public void run() {
                                try {
                                        DownloadUtil.getContentString(url, 15000, "ISO-8859-1");
                                } catch (IOException e) {
                                        Log.e("TrainInfo", "stats failed");
                                }                               
                        }                       
                });
                t.start();
        }
        

}
1	package dk.thoerup.traininfo.provider;
2
3	import java.io.EOFException;
4	import java.io.File;
5	import java.io.FileInputStream;
6	import java.io.FileOutputStream;
7	import java.io.IOException;
8	import java.io.ObjectInputStream;
9	import java.io.ObjectOutputStream;
10	import java.net.URLEncoder;
11	import java.util.Collections;
12	import java.util.Comparator;
13	import java.util.LinkedList;
14
15	import org.simpleframework.xml.Serializer;
16	import org.simpleframework.xml.core.Persister;
17
18	import android.content.Context;
19	import android.location.Location;
20	import android.util.Log;
21	import dk.thoerup.android.traininfo.common.StationBean;
22	import dk.thoerup.android.traininfo.common.StationEntry;
23	import dk.thoerup.genericjavautils.HttpUtil;
24	import dk.thoerup.traininfo.util.DownloadUtil;
25	import dk.thoerup.traininfo.util.IntSet;
26	import dk.thoerup.traininfo.util.XmlUtil;
27
28	public class OfflineStationProvider implements StationProvider {
29
30	StationBean stations = new StationBean();
31
32
33	public boolean loadStations(Context context) throws Exception {
34	long start = System.currentTimeMillis();
35
36	stations.entries.clear(); //TODO: remove
37
38	File parent = context.getFilesDir();
39	File stationsFile = new File(parent, "stations.bin");
40
41	if (!stationsFile.exists())
42	return false;
43
44	/*int size = (int) stationsFile.length();
45	byte data[] = new byte[size];
46
47	RandomAccessFile raf = new RandomAccessFile(stationsFile, "r");
48	raf.readFully(data);
49
50	Serializer serializer = new Persister();
51	stations = serializer.read(StationBean.class, new String(data, "ISO-8859-1") );*/
52
53
54	try {
55	ObjectInputStream in = new ObjectInputStream( new FileInputStream(stationsFile) );
56	Object o;
57	StationEntry e = null;
58	while ( (o=in.readObject()) != null ) {
59	e = (StationEntry) o;
60	updateSearchStrings(e);
61	stations.entries.add( e );
62	}
63	in.close();
64	} catch (EOFException e) {
65	//do nothing;
66	}
67
68	Log.e("OFFLINE", "loaded" + stations.entries.size());
69	logElapsedTime(start, "loadStations");
70
71	return true;
72	}
73
74	public void updateSearchStrings(StationEntry entry) {
75	entry.nameLower = entry.getName().toLowerCase();
76	entry.nameInternational = entry.nameLower.replace("æ", "ae").replace("ø", "oe").replace("å", "aa");
77	}
78
79	public void downloadStations(Context context) throws Exception {
80	File parent = context.getFilesDir();
81	File stationsFile = new File(parent, "stations.bin");
82
83
84	byte data[] = HttpUtil.getContent(XmlUtil.SERVICE_BASE + "/LocateStations?dump=1", 5000);
85	Serializer serializer = new Persister();
86	stations = serializer.read(StationBean.class, new String(data, "ISO-8859-1") );
87
88
89	ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream(stationsFile) );
90	Log.e("OFFLINE", "data size" + data.length);
91
92	for (StationEntry entry : stations.entries) {
93	updateSearchStrings( entry ); //prepare name fields for byName search
94	out.writeObject(entry);
95	}
96
97	out.close();
98	}
99
100
101
102	@Override
103	public void purgeOldEntries() {
104	}
105
106	Comparator<StationEntry> distanceComparator = new Comparator<StationEntry>() {
107	@Override
108	public int compare(StationEntry object1, StationEntry object2) {
109	if (object1.getCalcdist() == object2.getCalcdist())
110	return 0;
111
112	if (object1.getCalcdist() > object2.getCalcdist())
113	return 1;
114	else
115	return -1;
116	}
117	};
118
119	@Override
120	public StationBean lookupStationsByLocation(Location location) {
121
122	statsByLocation(location);
123
124	long start = System.currentTimeMillis();
125	Location tmpLoc = new Location("GPS");
126
127	LinkedList<StationEntry> entries = new LinkedList<StationEntry>() ;
128
129	for (StationEntry entry : stations.entries) {
130	tmpLoc.setLatitude(entry.getLatitude());
131	tmpLoc.setLongitude(entry.getLongitude());
132
133	int distance = (int) location.distanceTo(tmpLoc);
134
135	if (entries.size() <8 \|\| entries.getLast().getCalcdist() > distance) {
136	entry.setCalcdist(distance);
137
138	if (entries.size() == 8)
139	entries.removeLast();
140
141	entries.addLast(entry);
142
143	Collections.sort( entries, distanceComparator);
144	}
145	}
146
147	logElapsedTime(start, "location_stage1");
148
149	Collections.sort( entries, distanceComparator);
150
151	StationBean tmpStations = new StationBean();
152	for (int i = 0; i<8; i++) {
153	tmpStations.entries.add( entries.get(i) );
154	}
155
156	logElapsedTime(start, "location");
157	return tmpStations;
158	}
159
160	private void logElapsedTime(long start, String method) {
161	long now = System.currentTimeMillis();
162
163	Log.i("TrainInfo", "Search by " + method + " elapsed " + (now-start) );
164	}
165
166	@Override
167	public StationBean lookupStationsByName(String name) {
168
169	long start = System.currentTimeMillis();
170
171	name = name.toLowerCase();
172	StationBean tmpStations = new StationBean();
173	for (StationEntry entry : stations.entries) {
174	if (entry.nameLower.startsWith(name) \|\| entry.nameInternational.startsWith(name) ) {
175	tmpStations.entries.add(entry);
176	}
177	}
178	logElapsedTime(start, "name");
179	return tmpStations;
180	}
181
182	@Override
183	public StationBean lookupStationsByIds(String ids) {
184	statsByIds(ids);
185
186	IntSet idset = new IntSet();
187	idset.fromString(ids);
188
189	StationBean tmpStations = new StationBean();
190	for (StationEntry entry : stations.entries) {
191	if (idset.contains( entry.getId() ) ) {
192	tmpStations.entries.add(entry);
193	}
194	}
195
196	return tmpStations;
197	}
198
199
200	private void statsByLocation(Location location) {
201	double lat = XmlStationProvider.roundToPlaces(location.getLatitude(), 4);
202	double lng = XmlStationProvider.roundToPlaces(location.getLongitude(), 4);
203
204	final String url = XmlUtil.SERVICE_BASE + "/LocateStations?latitude=" + lat + "&longitude=" + lng + "&dummy=1";
205	Log.i("url", url);
206	urlSender(url);
207	}
208
209	private void statsByName(String name) {
210
211	try {
212	name = URLEncoder.encode(name, "ISO8859-1");
213	} catch (Exception e) {
214	Log.e("lookupStations", "Encoding failed", e);//if encoding fails use original and hope for the best
215	}
216
217	String url = XmlUtil.SERVICE_BASE + "/LocateStations?name=" + name + "&dummy=1";
218	Log.i("url", url);
219	urlSender(url);
220	}
221
222	private void statsByIds(String ids) {
223	final String url = XmlUtil.SERVICE_BASE + "/LocateStations?list=" + ids + "&dummy=1";
224	Log.i("url", url);
225	urlSender(url);
226	}
227
228	private void urlSender(final String url) {
229	Thread t = new Thread(new Runnable() {
230
231	@Override
232	public void run() {
233	try {
234	DownloadUtil.getContentString(url, 15000, "ISO-8859-1");
235	} catch (IOException e) {
236	Log.e("TrainInfo", "stats failed");
237	}
238	}
239	});
240	t.start();
241	}
242
243
244	}