Autore Topic: Come lanciare differenti activity a seconda della poly area cliccata  (Letto 888 volte)

Offline darkmax

  • Utente junior
  • **
  • Post: 63
  • Respect: 0
    • Mostra profilo
    • Emoe - Agenzia di comunicazione Torino
  • Dispositivo Android:
    Samsung Galaxy S 3
  • Sistema operativo:
    Mac OS X
Ciao a tutti, sto provando a creare un'app.
Voglio creare una mappa cliccabile.

Ho un'immagine e voglio lanciare differenti activity a seconda di quale parte clicco.

Ho trovato questo esempio sul web che potrebbe fare al caso mio.

Ecco la classe ImageMap

Codice (Java): [Seleziona]
public class ImageMap extends ImageView {
       
        private boolean mFitImageToScreen=true;
        private boolean mScaleFromOriginal=true;
        private float mMaxSize = 1.5f;
   
        private Scroller mScroller;
   
        private boolean mIsBeingDragged = false;       
       
        HashMap<Integer,TouchPoint> mTouchPoints = new HashMap<Integer,TouchPoint>();
        TouchPoint mMainTouch=null;
        TouchPoint mPinchTouch=null;
       
        /*
         * Pinch zoom
         */

        float mInitialDistance;
        boolean mZoomEstablished=false;
        int mLastDistanceChange=0;
        boolean mZoomPending=false;
       
        /*
         * Paint objects for drawing info bubbles
         */

        Paint textPaint;
        Paint textOutlinePaint;
        Paint bubblePaint;
        Paint bubbleShadowPaint;
       
        /*
         * Bitmap handling
         */

        Bitmap mImage;
        Bitmap mOriginal;
       
   
        // Info about the bitmap (sizes, scroll bounds)
        // initial size
        int mImageHeight;  
        int mImageWidth;
        float mAspect;
        // scaled size
        int mExpandWidth;
        int mExpandHeight;
        // the right and bottom edges (for scroll restriction)
        int mRightBound;
        int mBottomBound;
        // the current zoom scaling (X and Y kept separate)
        private float mResizeFactorX;
        private float mResizeFactorY;
        // minimum height/width for the image
        int mMinWidth=-1;
        int mMinHeight=-1;
        // maximum height/width for the image
        int mMaxWidth=-1;
        int mMaxHeight=-1;
   
        // the position of the top left corner relative to the view    
        int mScrollTop;
        int mScrollLeft;
   
        // view height and width
        int mViewHeight=-1;
        int mViewWidth=-1;
   
        /*
         * containers for the image map areas
         */

        ArrayList<Area> mAreaList=new ArrayList<Area>();
        HashMap<Integer,Area> mIdToArea= new HashMap<Integer,Area>();
       
        // click handler list
        ArrayList<OnImageMapClickedHandler> mCallbackList;
       
        // list of open info bubbles
        HashMap<Integer,Bubble> mBubbleMap = new HashMap<Integer,Bubble>();
   
       
       
        /*
         * Constructors
         */

        public ImageMap(Context context) {
                super(context);
                init();
        }
   
        public ImageMap(Context context, AttributeSet attrs) {
                super(context, attrs);
                init();
                loadAttributes(attrs);         
        }
   
        public ImageMap(Context context, AttributeSet attrs, int defStyle) {
                super(context, attrs, defStyle);
                init();
                loadAttributes(attrs);
        }
       
        /**
         * get the map name from the attributes and load areas from xml
         * @param attrs
         */

        private void loadAttributes(AttributeSet attrs) {
                TypedArray a = getContext().obtainStyledAttributes(attrs,R.styleable.ImageMap);
                String map = a.getString(R.styleable.ImageMap_map);
                if (map != null) {
                        loadMap(map);
                }
        }
       
        /**
         * parse the maps.xml resource and pull out the areas
         * @param map - the name of the map to load
         */

        private void loadMap(String map) {
                boolean loading = false;
                try {
                XmlResourceParser xpp = getResources().getXml(R.xml.maps);
                   
                int eventType = xpp.getEventType();
                while (eventType != XmlPullParser.END_DOCUMENT) {
                 if(eventType == XmlPullParser.START_DOCUMENT) {
                     // Start document
                         //  This is a useful branch for a debug log if
                         //  parsing is not working
                 } else if(eventType == XmlPullParser.START_TAG) {
                     String tag = xpp.getName();
                         
                     if (tag.equalsIgnoreCase("map")) {
                         String mapname = xpp.getAttributeValue(null, "name");
                         if (mapname !=null) {
                                 if (mapname.equalsIgnoreCase(map)) {
                                         loading=true;
                                 }
                         }
                     }
                     if (loading) {
                             if (tag.equalsIgnoreCase("area")) {
                                 Area a=null;
                                 String shape = xpp.getAttributeValue(null, "shape");
                                 String coords = xpp.getAttributeValue(null, "coords");
                                 String id = xpp.getAttributeValue(null, "id");
                                 
                                 // as a name for this area, try to find any of these
                                 // attributes
                                 //  name attribute is custom to this impl (not standard in html area tag)
                                 String name = xpp.getAttributeValue(null, "name");
                                 if (name == null) {
                                         name = xpp.getAttributeValue(null, "title");
                                 }
                                 if (name == null) {
                                         name = xpp.getAttributeValue(null, "alt");
                                 }
                                 
                                 if ((shape != null) && (coords != null)) {
                                         a = addShape(shape,name,coords,id);
                                         if (a != null) {
                                                 // add all of the area tag attributes
                                                 // so that they are available to the
                                                 // implementation if needed (see getAreaAttribute)
                                                 for (int i=0;i<xpp.getAttributeCount();i++) {
                                                         String attrName = xpp.getAttributeName(i);
                                                         String attrVal = xpp.getAttributeValue(null,attrName);
                                                         a.addValue(attrName, attrVal);
                                                 }
                                         }
                                 }                                                             
                             }
                     }
                 } else if(eventType == XmlPullParser.END_TAG) {
                         String tag = xpp.getName();
                         if (tag.equalsIgnoreCase("map")) {
                                 loading = false;
                         }
                 }
                 eventType = xpp.next();
                }        
                } catch (XmlPullParserException xppe) {
                        // Having trouble loading? Log this exception
                } catch (IOException ioe) {
                        // Having trouble loading? Log this exception
                }
        }
       
        /**
         * Create a new area and add to tracking
         * @param shape
         * @param name
         * @param coords
         * @param id
         * @return
         */

        private Area addShape( String shape, String name, String coords, String id) {  
                Area a = null;
                String rid = id.replace("@+id/", "");
                int _id=0;
               
                try {
                        Class<R.id> res = R.id.class;
                        Field field = res.getField(rid);
                    _id = field.getInt(null);
                }
                catch (Exception e) {
                   _id = 0;
                }
                if (_id != 0) {
                        if (shape.equalsIgnoreCase("rect")) {
                                String[] v = coords.split(",");
                                if (v.length == 4) {
                                        a = new RectArea(_id, name, Float.parseFloat(v[0]),
                                                        Float.parseFloat(v[1]),
                                                        Float.parseFloat(v[2]),
                                                        Float.parseFloat(v[3]));
                                }
                        }
                        if (shape.equalsIgnoreCase("poly")) {                          
                                a = new PolyArea(_id,name, coords);                                            
                        }
                        if (a != null) {
                                addArea(a);
                        }
                }
                return a;
        }
       
        public void addArea( Area a ) {
                mAreaList.add(a);
                mIdToArea.put(a.getId(), a);
        }      
       
        public void addBubble(String text, int areaId ) {
                if (mBubbleMap.get(areaId) == null) {
                        Bubble b = new Bubble(text,areaId);
                        mBubbleMap.put(areaId,b);
                }
        }
       
        public void showBubble(String text, int areaId) {
                mBubbleMap.clear();
                addBubble(text,areaId);
                invalidate();
        }
       
        public void showBubble(int areaId) {
                mBubbleMap.clear();
                Area a = mIdToArea.get(areaId);
                if (a != null) {
                        addBubble(a.getName(),areaId);
                }
                invalidate();
        }
       
        public void centerArea( int areaId ) {
                Area a = mIdToArea.get(areaId);
                if (a != null) {
                        float x = a.getOriginX()*mResizeFactorX;
                        float y = a.getOriginY()*mResizeFactorY;
                        int left = (int)((mViewWidth/2)-x);
                        int top  = (int)((mViewHeight/2)-y);
                        moveTo(left,top);
                }
        }
       
        public void centerAndShowArea(String text, int areaId) {
                centerArea(areaId);
                showBubble(text,areaId);
        }
       
        public void centerAndShowArea(int areaId) {
                Area a = mIdToArea.get(areaId);
                if (a != null) {
                        centerAndShowArea(a.getName(),areaId);                 
                }
        }
       
        public String getAreaAttribute(int areaId, String key) {
                String value = null;
                Area a = mIdToArea.get(areaId);
                if (a != null) {
                        value = a.getValue(key);
                }
                return value;
        }
   
        /**
         * initialize the view
         */

        private void init() {
                // set up paint objects
                initDrawingTools();
   
                // create a scroller for flinging
                mScroller = new Scroller(getContext());
   
                // get some default values from the system for touch/drag/fling
                final ViewConfiguration configuration = ViewConfiguration
                                .get(getContext());
                mTouchSlop = configuration.getScaledTouchSlop();
                mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
                mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
        }
   
        /*
         * These methods will be called when images or drawables are set
         * in the XML for the view.  We handle either bitmaps or drawables
         * @see android.widget.ImageView#setImageBitmap(android.graphics.Bitmap)
         */

        @Override
        public void setImageBitmap(Bitmap bm) {
                if (mImage==mOriginal) {
                        mOriginal=null;
                } else {
                        mOriginal.recycle();
                        mOriginal=null;
                }
                if (mImage != null) {
                        mImage.recycle();
                        mImage=null;
                }
                mImage = bm;
                mOriginal = bm;
                mImageHeight = mImage.getHeight();
                mImageWidth = mImage.getWidth();
                mAspect = (float)mImageWidth / mImageHeight;
                setInitialImageBounds();
        }
   
        @Override
        public void setImageResource(int resId) {
                Bitmap b = BitmapFactory.decodeResource(getResources(), resId);
                setImageBitmap(b);
        }
   
        @Override
        public void setImageDrawable(Drawable drawable) {              
                if (drawable instanceof BitmapDrawable) {
                        BitmapDrawable bd = (BitmapDrawable) drawable;                 
                        setImageBitmap(bd.getBitmap());
                }
        }
   
        /**
         * setup the paint objects for drawing bubbles
         */

        private void initDrawingTools() {
                textPaint = new Paint();
                textPaint.setColor(0xFF000000);
                textPaint.setTextSize(30);
                textPaint.setTypeface(Typeface.SERIF);
                textPaint.setTextAlign(Paint.Align.CENTER);
                textPaint.setAntiAlias(true);
   
                textOutlinePaint = new Paint();
                textOutlinePaint.setColor(0xFF000000);
                textOutlinePaint.setTextSize(18);
                textOutlinePaint.setTypeface(Typeface.SERIF);
                textOutlinePaint.setTextAlign(Paint.Align.CENTER);
                textOutlinePaint.setStyle(Paint.Style.STROKE);
                textOutlinePaint.setStrokeWidth(2);
               
                bubblePaint=new Paint();
                bubblePaint.setColor(0xFFFFFFFF);
                bubbleShadowPaint=new Paint();
                bubbleShadowPaint.setColor(0xFF000000);
        }
   
        /*
         * Called by the scroller when flinging
         * @see android.view.View#computeScroll()
         */

        @Override
        public void computeScroll() {
                if (mScroller.computeScrollOffset()) {
                        int oldX = mScrollLeft;
                        int oldY = mScrollTop;
                       
                        int x = mScroller.getCurrX();
                        int y = mScroller.getCurrY();
   
                        if (oldX != x) {
                                moveX(x-oldX);
                        }
                        if (oldY != y) {
                                moveY(y-oldY);
                        }
                }
        }
   
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                int widthMode = MeasureSpec.getMode(widthMeasureSpec);
                int widthSize = MeasureSpec.getSize(widthMeasureSpec);
   
                int heightMode = MeasureSpec.getMode(heightMeasureSpec);
                int heightSize = MeasureSpec.getSize(heightMeasureSpec);
   
                int chosenWidth = chooseDimension(widthMode, widthSize);
                int chosenHeight = chooseDimension(heightMode, heightSize);
   
                setMeasuredDimension(chosenWidth, chosenHeight);
        }
   
        private int chooseDimension(int mode, int size) {
                if (mode == MeasureSpec.AT_MOST || mode == MeasureSpec.EXACTLY) {
                        return size;
                } else { // (mode == MeasureSpec.UNSPECIFIED)
                        return getPreferredSize();
                }
        }
   
   
        /**
         * set the initial bounds of the image
         */

        void setInitialImageBounds() {
                if (mFitImageToScreen) {
                        setInitialImageBoundsFitImage();
                } else {
                        setInitialImageBoundsFillScreen();
                }
        }
       
        /**
         * setInitialImageBoundsFitImage sets the initial image size to match the
         * screen size.  aspect ratio may be broken
         */
   
        void setInitialImageBoundsFitImage() {
                if (mImage != null) {
                        if (mViewWidth > 0) {                  
                                mMinHeight = mViewHeight;
                                mMinWidth = mViewWidth;
                                mMaxWidth = (int)(mMinWidth * mMaxSize);
                                mMaxHeight = (int)(mMinHeight * mMaxSize);                             
                                       
                                mScrollTop = 0;
                                mScrollLeft = 0;
                                scaleBitmap(mMinWidth, mMinHeight);
                    }
                }
        }

/**
         * setInitialImageBoundsFillScreen sets the initial image size to so that there
         * is no uncovered area of the device
         */
   
        void setInitialImageBoundsFillScreen() {
                if (mImage != null) {
                        if (mViewWidth > 0) {
                                boolean resize=false;
                               
                                int newWidth=mImageWidth;
                                int newHeight=mImageHeight;
                       
                                // The setting of these max sizes is very arbitrary
                                // Need to find a better way to determine max size
                                // to avoid attempts too big a bitmap and throw OOM
                                if (mMinWidth==-1) {
                                        // set minimums so that the largest
                                        // direction we always filled (no empty view space)
                                        // this maintains initial aspect ratio
                                        if (mViewWidth > mViewHeight) {
                                                mMinWidth = mViewWidth;
                                                mMinHeight = (int)(mMinWidth/mAspect);
                                        } else {
                                                mMinHeight = mViewHeight;
                                                mMinWidth = (int)(mAspect*mViewHeight);
                                        }                                      
                                        mMaxWidth = (int)(mMinWidth * 1.5f);
                                        mMaxHeight = (int)(mMinHeight * 1.5f);
                                }
                                       
                                if (newWidth < mMinWidth) {
                                        newWidth = mMinWidth;
                                        newHeight = (int) (((float) mMinWidth / mImageWidth) * mImageHeight);
                                        resize = true;
                                }
                                if (newHeight < mMinHeight) {
                                        newHeight = mMinHeight;
                                        newWidth = (int) (((float) mMinHeight / mImageHeight) * mImageWidth);
                                        resize = true;
                                }
                               
                                mScrollTop = 0;
                                mScrollLeft = 0;
                               
                                // scale the bitmap
                                if (resize) {
                                        scaleBitmap(newWidth, newHeight);
                                } else {
                                        mExpandWidth=newWidth;
                                        mExpandHeight=newHeight;                                       
                                        mResizeFactorX = ((float) newWidth / mImageWidth);
                                        mResizeFactorY = ((float) newHeight / mImageHeight);
                                        mRightBound = 0 - (mExpandWidth - mViewWidth);
                                        mBottomBound = 0 - (mExpandHeight - mViewHeight);
                                }
                        }
                }
        }
       
        /**
         * watch for screen size changes and reset the background image
         */

        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
                super.onSizeChanged(w, h, oldw, oldh);
   
                // save device height width, we use it a lot of places
                mViewHeight = h;
                mViewWidth = w;
   
                // fix up the image
                setInitialImageBounds();
        }
   
        private int getPreferredSize() {
                return 300;
        }
   
        /**
         * the onDraw routine when we are using a background image
         *
         * @param canvas
         */

        protected void drawMap(Canvas canvas) {
                canvas.save();
               
                if (mImage != null) {
                        if (!mImage.isRecycled()) {
                                canvas.drawBitmap(mImage, mScrollLeft, mScrollTop, null);
                        }
                }
                canvas.restore();
        }
       
        protected void drawBubbles(Canvas canvas) {
                for (Bubble b : mBubbleMap.values()) {
                        b.onDraw(canvas);
                }
        }
       
        protected void drawLocations(Canvas canvas) {
                for (Area a : mAreaList) {
                        a.onDraw(canvas);
                }      
        }
   
        /**
         * Paint the view
         *   image first, location decorations next, bubbles on top
         */

        @Override
        protected void onDraw(Canvas canvas) {
                drawMap(canvas);
                drawLocations(canvas);
                drawBubbles(canvas);
        }
       
       
        /*
         * Screen tapped x, y is screen coord from upper left and does not account
         * for scroll
         */

        void onScreenTapped(int x, int y) {
                boolean missed = true;
                boolean bubble = false;
                // adjust for scroll
                int testx = x-mScrollLeft;
                int testy = y-mScrollTop;
               
                // adjust for x y resize
                testx = (int)((float)testx/mResizeFactorX);
                testy = (int)((float)testy/mResizeFactorY);
   
               
                // check if bubble tapped first
                // in case a bubble covers an area we want it to
                // have precedent
                for (Bubble b : mBubbleMap.values()) {
                        if (b.isInArea((float)x-mScrollLeft,(float)y-mScrollTop)) {
                                b.onTapped();
                                bubble=true;
                                missed=false;
                                // only fire tapped for one bubble
                                break;
                        }
                }
               
                if (!bubble) {
                        // then check for area taps
                        for (Area a : mAreaList) {
                                if (a.isInArea((float)testx,(float)testy)) {
                                        if (mCallbackList != null) {
                                                for (OnImageMapClickedHandler h : mCallbackList) {
                                                        h.onImageMapClicked(a.getId());                                        
                                                }
                                        }
                                        missed=false;
                                        // only fire clicked for one area
                                        break;
                                }
                        }
                }
   
                if (missed) {
                        // managed to miss everything, clear bubbles
                        mBubbleMap.clear();
                        invalidate();
                }
        }
       
        /*
         * A class to track touches
         */

        class TouchPoint {
                int _id;
                float _x;
                float _y;
               
                TouchPoint(int id) {
                        _id=id;
                        _x=0f;
                        _y=0f;                 
                }
                int getTrackingPointer() {
                        return _id;
                }
                void setPosition(float x, float y) {
                        if ((_x != x) || (_y != y)) {
                                _x=x;
                                _y=y;
                        }
                }
                float getX() {
                        return _x;
                }
                float getY() {
                        return _y;
                }
        }
       
       
        /*
         * on clicked handler add/remove support
         */

        public void addOnImageMapClickedHandler( OnImageMapClickedHandler h ) {
                if (h != null) {
                        if (mCallbackList == null) {
                                mCallbackList = new ArrayList<OnImageMapClickedHandler>();
                        }
                        mCallbackList.add(h);
                }
        }
       
        public void removeOnImageMapClickedHandler( OnImageMapClickedHandler h ) {
                if (mCallbackList != null) {
                        if (h != null) {
                                mCallbackList.remove(h);
                        }
                }
        }

        abstract class Area {
                int _id;
                String _name;
                HashMap<String,String> _values;
                Bitmap _decoration=null;
               
                public Area(int id, String name) {
                        _id = id;
                        if (name != null) {
                                _name = name;
                        }
                }
                               
                public int getId() {
                        return _id;
                }                      
               
                public String getName() {
                        return _name;
                }
               
                // all xml values for the area are passed to the object
                // the default impl just puts them into a hashmap for
                // retrieval later
                public void addValue(String key, String value) {
                        if (_values == null) {
                                _values = new HashMap<String,String>();
                        }
                        _values.put(key, value);
                }
                               
                public String getValue(String key) {
                        String value=null;
                        if (_values!=null) {
                                value=_values.get(key);
                        }
                        return value;
                }
               
                // a method for setting a simple decorator for the area
                public void setBitmap(Bitmap b) {
                        _decoration = b;
                }
               
                // an onDraw is set up to provide an extensible way to
                // decorate an area.  When drawing remember to take the
                // scaling and translation into account
                public void onDraw(Canvas canvas) {
                        if (_decoration != null) {
                                float x = (getOriginX() * mResizeFactorX) + mScrollLeft - 17;
                                float y = (getOriginY() * mResizeFactorY) + mScrollTop - 17;
                                canvas.drawBitmap(_decoration, x, y, null);
                        }
                }
               
                abstract boolean isInArea(float x, float y);
                abstract float getOriginX();
                abstract float getOriginY();
        }
       
        /**
         * Polygon area
         */

        class PolyArea extends Area {
                ArrayList<Integer> xpoints = new ArrayList<Integer>();
                ArrayList<Integer> ypoints = new ArrayList<Integer>();
               
                // centroid point for this poly
                float _x;
                float _y;
               
                // number of points (don't rely on array size)         
                int _points;
               
                // bounding box
                int top=-1;
                int bottom=-1;
                int left=-1;
                int right=-1;
       
                public PolyArea(int id, String name, String coords) {
                        super(id,name);
                                               
                        // split the list of coordinates into points of the
                        // polygon and compute a bounding box
                        String[] v = coords.split(",");
                       
                        int i=0;
                        while ((i+1)<v.length) {
                                int x = Integer.parseInt(v[i]);
                                int y = Integer.parseInt(v[i+1]);
                                xpoints.add(x);
                                ypoints.add(y);
                                top=(top==-1)?y:Math.min(top,y);
                                bottom=(bottom==-1)?y:Math.max(bottom,y);
                                left=(left==-1)?x:Math.min(left,x);
                                right=(right==-1)?x:Math.max(right,x);
                                i+=2;
                        }
                        _points=xpoints.size();
                       
                        // add point zero to the end to make
                        // computing area and centroid easier
                        xpoints.add(xpoints.get(0));
                        ypoints.add(ypoints.get(0));
                       
                        computeCentroid();
                }
               
                /**
                 * area() and computeCentroid() are adapted from the implementation
                 * of polygon.java  published from a princeton case study
                 * The study is here: [url=http://introcs.cs.princeton.edu/java/35purple/]
Case Study: Purple America[/url]
                 * The polygon.java source is here: [url=http://introcs.cs.princeton.edu/java/35purple/Polygon.java.html]Polygon.java[/url]
                 */

   
            // return area of polygon
            public double area() {
                double sum = 0.0;
                for (int i = 0; i < _points; i++) {
                    sum = sum + (xpoints.get(i) * ypoints.get(i+1)) - (ypoints.get(i) * xpoints.get(i+1));
                }
                sum = 0.5 * sum;
                return Math.abs(sum);
            }
   
            // compute the centroid of the polygon
            public void computeCentroid() {
                double cx = 0.0, cy = 0.0;
                for (int i = 0; i < _points; i++) {
                    cx = cx + (xpoints.get(i) + xpoints.get(i+1)) * (ypoints.get(i) * xpoints.get(i+1) - xpoints.get(i) * ypoints.get(i+1));
                    cy = cy + (ypoints.get(i) + ypoints.get(i+1)) * (ypoints.get(i) * xpoints.get(i+1) - xpoints.get(i) * ypoints.get(i+1));
                }
                cx /= (6 * area());
                cy /= (6 * area());
                _x=Math.abs((int)cx);
                _y=Math.abs((int)cy);
            }
   
   
                @Override
                public float getOriginX() {                    
                        return _x;
                }
   
                @Override
                public float getOriginY() {
                        return _y;
                }
               
                /**
                 * This is a java port of the
                 * W. Randolph Franklin algorithm explained here
                 * [url=http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html]PNPOLY - Point Inclusion in Polygon Test - WR Franklin (WRF)[/url]
                 */

                @Override
                public boolean isInArea(float testx, float testy)
                {
                  int i, j;
                  boolean c = false;
                  for (i = 0, j = _points-1; i < _points; j = i++) {
                    if ( ((ypoints.get(i)>testy) != (ypoints.get(j)>testy)) &&
                         (testx < (xpoints.get(j)-xpoints.get(i)) * (testy-ypoints.get(i)) / (ypoints.get(j)-ypoints.get(i)) + xpoints.get(i)) )
                       c = !c;
                  }
                  return c;
                }              
               
                // For debugging maps, it is occasionally helpful to see the
                // bounding box for the polygons
                /*
                @Override
                public void onDraw(Canvas canvas) {
                    // draw the bounding box
                        canvas.drawRect(left * mResizeFactorX + mScrollLeft,
                                                top * mResizeFactorY + mScrollTop,
                                                right * mResizeFactorX + mScrollLeft,
                                                bottom * mResizeFactorY + mScrollTop,
                                                textOutlinePaint);
                }
                */

        }
       
        /**
         * Map tapped callback interface
         */

        public interface OnImageMapClickedHandler {
                /**
                 * Area with 'id' has been tapped
                 * @param id
                 */

                void onImageMapClicked(int id);
                /**
                 * Info bubble associated with area 'id' has been tapped
                 * @param id
                 */

                void onBubbleClicked(int id);
        }
    }

Ed ecco la classe di test. Ora come ora ho aggiunto una sola activity che viene lanciato al click in ogni punto. Come faccio a creare invece più casi? Nel senso clicco sulla poly area uno e mi lancia l'activity X.. clicco sulla poly area 2 e mi apre una pagina web.. Etc..

Codice (Java): [Seleziona]
import android.os.Bundle;
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.content.Intent;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.TextView;
   
    public class Home extends Activity {
   
        ImageMap mImageMap;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_home2);
               
               
                // find the image map in the view
            mImageMap = (ImageMap)findViewById(R.id.map);
           
            Bundle b1 = new Bundle();  
                b1.putInt("Tab1", 0);
               
                final Intent myIntent = new Intent(Home.this, Menu.class);
                myIntent.putExtras(b1);
               
            // add a click handler to react when areas are tapped
            mImageMap.addOnImageMapClickedHandler(new ImageMap.OnImageMapClickedHandler() {
                        @Override
                        public void onImageMapClicked(int id) {
                                // when the area is tapped, show the name in a
                                // text bubble
                                mImageMap.showBubble(id);
                                startActivity(myIntent);
                        }
   
                        @Override
                        public void onBubbleClicked(int id) {
                                // react to info bubble for area being tapped
                        }
                });
        }


Questo è il layout activity_home2.

Codice: [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:kkk="http://schemas.android.com/apk/res/com.android.test"
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        >
            <com.android.test.ImageMap 
                android:id="@+id/map"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:src="@drawable/home_background"
                kkk:map="homemap"/>
    </LinearLayout>
   

e maps.xml:

Codice: [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
    <maps xmlns:android="http://schemas.android.com/apk/res/android">
        <map name="homemap">
            <area name="kkk"
                shape="poly"
                coords="93,303,207,262,248,375,135,416"
                id="@+id/area1001"/>
           
            <area name="ttt"
                shape="poly"
                coords="231,303,345,262,387,375,273,416"
                id="@+id/area1002"/>       
           
            <area name="eee"
                shape="poly"
                coords="93,443,207,402,248,515,135,556"
                id="@+id/area1004"/>
           
            <area name="yyy"
                shape="poly"
                coords="232,442,345,401,386,514,273,556"
                id="@+id/area1005"/>
           
            <area name="hhh"
                shape="poly"
                coords="90,582,204,541,246,654,131,696"
                id="@+id/area1006"/>
           
            <area name="ggg"
                shape="poly"
                coords="230,583,344,542,385,655,271,697"
                id="@+id/area1007"/>
        </map>
    </maps>
       


Tante grazie

Offline DarnellNajanReed

  • Utente normale
  • ***
  • Post: 359
  • Respect: +49
    • Google+
    • Mostra profilo
  • Dispositivo Android:
    LG Optimus One, Acer Iconia A500/501, Asus Transformer Prime, Galaxy ACE, Galaxy S Plus, Galaxy S Advance P, Galaxy Tab 2 7.0, Google Nexus 7
  • Play Store ID:
    Luigi Notaro
  • Sistema operativo:
    OS X 10.8.3
Re:Come lanciare differenti activity a seconda della poly area cliccata
« Risposta #1 il: 04 Marzo 2013, 22:57:09 CET »
+1
Da questo frammento:

Codice (Java): [Seleziona]
@Override
                        public void onImageMapClicked(int id) {
                                // when the area is tapped, show the name in a
                                // text bubble
                                mImageMap.showBubble(id);
                                startActivity(myIntent);
                        }
presumo che id sia l'id dell'area tappata. Se è così, ti basta mettere uno switch/ifelse a cascata per avviare l'Activity appropriata per ogni caso.

Offline darkmax

  • Utente junior
  • **
  • Post: 63
  • Respect: 0
    • Mostra profilo
    • Emoe - Agenzia di comunicazione Torino
  • Dispositivo Android:
    Samsung Galaxy S 3
  • Sistema operativo:
    Mac OS X
Re:Come lanciare differenti activity a seconda della poly area cliccata
« Risposta #2 il: 04 Marzo 2013, 23:58:34 CET »
0
Da questo frammento:

Codice (Java): [Seleziona]
@Override
                        public void onImageMapClicked(int id) {
                                // when the area is tapped, show the name in a
                                // text bubble
                                mImageMap.showBubble(id);
                                startActivity(myIntent);
                        }
presumo che id sia l'id dell'area tappata. Se è così, ti basta mettere uno switch/ifelse a cascata per avviare l'Activity appropriata per ogni caso.

Si si.. infatti ho aggiunto io lo startActivity.. solo non capisco come diversificare le scelte.. Lui si aspetta in ingresso un int.. in che formato glielo passo?

Post unito: 05 Marzo 2013, 00:08:10 CET
Risolto!! Faccio così:

Codice (Java): [Seleziona]
switch(id){

                                  case R.id.area1001:
                                       Intent intent = new Intent(this, MyActivity.class);
                                       this.startActivity(intent);
                                       break;

                                  case R.id.area1002:
                                       Intent intent = new Intent(this, MyActivity2.class);
                                       this.startActivity(intent);
                                       break;
                                  }


Grazie a tutti
« Ultima modifica: 05 Marzo 2013, 00:08:10 CET da darkmax, Reason: Merged DoublePost »