localmidlet.java

fantastic j2me user interface designer for midp2.0 cldcd 1.1. Works on many phones as a generic appl

            details.setTransitionInAnimator(Transition3D.createCube(500, false));
            details.setTransitionOutAnimator(Transition3D.createCube(500, true));
            details.show();
        }
    }
    
    private void showMap(final Form resultForm, final Object selectedItem) {
        try {
            // might still be downloading the entry...
            if(selectedItem instanceof Links) {
                final Links link = (Links)selectedItem;
                if (link == null) {
                    return;
                }

                final Arg[] args = {
                    new Arg("output", "json"),
                    new Arg("appid", APPID),
                    new Arg("latitude", link.latitude),
                    new Arg("longitude", link.longitude),
                    new Arg("image_height", Integer.toString((int)(Display.getInstance().getDisplayHeight() * 1.5))),
                    new Arg("image_width", Integer.toString((int)(Display.getInstance().getDisplayWidth() * 1.5))),
                    new Arg("zoom", Integer.toString(zoom))
                };

                final Dialog progress = new Dialog();
                progress.getDialogStyle().setBorder(Border.createRoundBorder(6, 6, 0xe3ef5a));
                progress.setTransitionInAnimator(CommonTransitions.createSlide(CommonTransitions.SLIDE_VERTICAL, true, 400));
                progress.setTransitionOutAnimator(CommonTransitions.createSlide(CommonTransitions.SLIDE_VERTICAL, false, 400));
                progress.addComponent(new Label("Please Wait"));
                progress.addComponent(new InfiniteProgressIndicator(Image.createImage("/wait-circle.png")));
                int height = Display.getInstance().getDisplayHeight() - (progress.getContentPane().getPreferredH() + progress.getTitleComponent().getPreferredH());
                height /= 2;
                progress.show(height, height, 20, 20, true, false);
                new Thread() {
                    public void run() {
                        try {
                            Response response;
                            if (!demoMode) {
                                response = Request.get(MAP_BASE, args, null, null);
                            }
                            else {
                                response = Request.get(Request.DEMO_URL, args, null, null);
                            }
                            Result result = response.getResult();
                            String location = result.getAsString("ResultSet.Result");
                            HttpConnection imgConn;
                            imgConn = (HttpConnection) Connector.open(location);
                            imgConn.setRequestProperty("Accept", "image/png");

                            //int totalToReceive = imgConn.getHeaderFieldInt(Arg.CONTENT_LENGTH, 0);
                            InputStream is = imgConn.openInputStream();        
                            Image mapImage = Image.createImage(is);
                            final Form map = createForm("Map");
                            map.setScrollable(false);
                            map.setTransitionInAnimator(Transition3D.createCube(500, false));
                            map.setTransitionOutAnimator(Transition3D.createCube(500, true));
                            map.setLayout(new BorderLayout());
                            MotionComponent mapLabel = new MotionComponent(mapImage);
                            map.addComponent(BorderLayout.CENTER, mapLabel);
                            if(zoom < 9) {
                                map.addCommand(new Command("Zoom Out") {
                                    public void actionPerformed(ActionEvent ev) {
                                        zoom++;
                                        map.setTransitionOutAnimator(null);
                                        showMap(resultForm, selectedItem);
                                    }
                                });
                            }
                            if(zoom > 1) {
                                map.addCommand(new Command("Zoom In") {
                                    public void actionPerformed(ActionEvent ev) {
                                        zoom--;
                                        map.setTransitionOutAnimator(null);
                                        showMap(resultForm, selectedItem);
                                    }
                                });
                            }
                            map.addCommand(new Command("Back") {
                                public void actionPerformed(ActionEvent ev) {
                                    resultForm.show();
                                }
                            });
                            map.addCommand(exitCommand);
                            progress.dispose();
                            map.show();
                        } catch(IOException ioErr) {
                            exception(ioErr);
                        } 
                    }
                }.start();
            } else {
                Dialog.show("Please Wait", "Please wait for download to complete", "OK", null);
            }
        } catch(IOException ioErr) {
            exception(ioErr);
        }
    }
    
    protected void pauseApp() {
    }

    protected void destroyApp(boolean arg0) {
    }

    private static class Links {
        String title;
        String business;
        String listing;
        String map;
        String tel;
        String latitude;
        String longitude;
        String rating;
        String address;
        String distance;
    };

    private Form createForm(String title) {
        Form f = new Form(title);
        f.getTitleComponent().setAlignment(Component.LEFT);
        f.setMenuCellRenderer(new DefaultListCellRenderer(false));
        return f;
    }
    
    /**
     * A list model that lazily fetches a result over the web if its unavailable
     */
    class LocalResultModel implements ListModel {
        private Vector cache;
        private Arg[] args;
        private boolean fetching;
        private Vector fetchQueue = new Vector();
        private Vector dataListeners = new Vector();

        private Vector selectionListeners = new Vector();

        private int selectedIndex = 0;
        private boolean firstTime = true;
        
        public LocalResultModel(String searchFor, String location, String sortOrder, String street) {
            cache = new Vector();
            cache.setSize(1);
            args = new Arg[]{
                new Arg("output", "json"),  
                new Arg("appid", APPID),
                new Arg("query", searchFor),
                new Arg("location", location),
                new Arg("sort", sortOrder.toLowerCase()),
                null,
                null
            };
            final String str = street;
            if (!"".equals(str)) {
                args[6] = new Arg("street", str);
            }
        }
        
        private void fetch(final int startOffset) {
            int count = Math.min(cache.size(), startOffset + 9);
            for(int iter = startOffset - 1 ; iter < count ; iter++) {
                if(cache.elementAt(iter) == null) {
                    cache.setElementAt(LOADING_MARKER, iter);
                }
            }
            if(!fetching) {
                fetching = true;
                new Thread() {
                    public void run() {
                        if(firstTime) {
                            firstTime = false;
                            try {
                                // yield a bit CPU the first time around since the model
                                // call might occur before the display is refreshed
                                Thread.sleep(400);
                            } catch (InterruptedException ex) {
                                ex.printStackTrace();
                            }
                        }
                        fetchThread(startOffset);
                        while(fetchQueue.size() > 0) {
                            int i = ((Integer)fetchQueue.elementAt(0)).intValue();
                            fetchQueue.removeElementAt(0);
                            fetchThread(i);
                        }
                        fetching = false;
                    }
                }.start();
            } else {
                fetchQueue.addElement(new Integer(startOffset));
            }
        }
        
        private void fetchThread(int startOffset) {
            try {
                Response response;
                args[5] = new Arg("start", Integer.toString(startOffset));
                if (!demoMode) {
                    response = Request.get(LOCAL_BASE, args, null, null);
                } else {
                    response = Request.get(Request.DEMO_URL, args, null, null);
                }
                final Exception ex = response.getException();
                if (ex != null || response.getCode() != HttpConnection.HTTP_OK) {
                    Dialog.show("Error", "Error connecting to search service - Turning on DEMO MODE", "OK", null);
                    demoMode = true;
                    showMainForm();
                    return;
                }

                Result result = response.getResult();
                //String mapAllLink = result.getAsString("ResultSet.ResultSetMapUrl");
                int totalResultsAvailable = result.getAsInteger("ResultSet.totalResultsAvailable");
                final int resultCount = result.getSizeOfArray("ResultSet.Result");

                // this is the first time... set the size of the vector to match the results!
                if(startOffset == 1) {
                    cache.setSize(totalResultsAvailable);
                }

                for(int i = 0 ; i < resultCount ; i++) {
                    String title = result.getAsString("ResultSet.Result["+i+"].Title");

                    Links link = new Links();
                    link.title = title;
                    link.address = result.getAsString("ResultSet.Result["+i+"].Address");
                    link.map = result.getAsString("ResultSet.Result["+i+"].MapUrl");
                    link.listing = result.getAsString("ResultSet.Result["+i+"].ClickUrl");
                    link.business = result.getAsString("ResultSet.Result["+i+"].BusinessClickUrl");
                    link.tel = result.getAsString("ResultSet.Result["+i+"].Phone");
                    link.latitude = result.getAsString("ResultSet.Result["+i+"].Latitude");
                    link.longitude = result.getAsString("ResultSet.Result["+i+"].Longitude");
                    link.rating = result.getAsString("ResultSet.Result["+i+"].Rating.AverageRating");
                    link.distance = result.getAsString("ResultSet.Result["+i+"].Distance");
                    cache.setElementAt(link, startOffset + i - 1);
                    fireDataChangedEvent(DataChangedListener.CHANGED, startOffset + i - 1);
                }
            } catch (Exception ex) {
                exception(ex);
            }
        }
        
        public Object getItemAt(int index) {
            Object val = cache.elementAt(index);
            if(val == null) {
                fetch(index + 1);
                return LOADING_MARKER;
            }
            return val;
        }

        public int getSize() {
            return cache.size();
        }

        public void setSelectedIndex(int index) {
            int oldIndex = selectedIndex;
            this.selectedIndex = index;
            fireSelectionEvent(oldIndex, selectedIndex);
        }

        public void addDataChangedListener(DataChangedListener l) {
            dataListeners.addElement(l);
        }

        public void removeDataChangedListener(DataChangedListener l) {
            dataListeners.removeElement(l);
        }

        private void fireDataChangedEvent(final int status, final int index){
            if(!Display.getInstance().isEdt()) {
                Display.getInstance().callSeriallyAndWait(new Runnable() {
                    public void run() {
                        fireDataChangedEvent(status, index);
                    }
                });
                return;
            }
            // we query size with every iteration and avoid an Enumeration since a data 
            // changed event can remove a listener instance thus break the enum...
            for(int iter = 0 ; iter < dataListeners.size() ; iter++) {
                DataChangedListener l = (DataChangedListener)dataListeners.elementAt(iter);
                l.dataChanged(status, index);
            }
        }

        public void addSelectionListener(SelectionListener l) {
            selectionListeners.addElement(l);
        }

        public void removeSelectionListener(SelectionListener l) {
            selectionListeners.removeElement(l);
        }

        private void fireSelectionEvent(int oldIndex, int newIndex){
            Enumeration listenersEnum = selectionListeners.elements();
            while(listenersEnum.hasMoreElements()){
                SelectionListener l = (SelectionListener)listenersEnum.nextElement();
                l.selectionChanged(oldIndex, newIndex);
            }
        }

        public void addItem(Object item) {
        }

        public void removeItem(int index) {
        }
        
        public int getSelectedIndex() {
            return selectedIndex;
        }
    }
}