2013-08-22 8 views
5

पहली बार चलाने के लिए (या कुछ प्रमुख अपडेट के बाद), कुछ Google ऐप्स या कोर एंड्रॉइड सिस्टम कभी-कभी नई सुविधाओं का उपयोग करने के लिए एक छोटे टूलटिप के साथ एक पारदर्शी ओवरले प्रदर्शित करता है। एक उदाहरण छवि bellow हो सकता है।पहले रन पर प्रदर्शित ओवरले टूलटिप

क्या इन्हें बनाने के लिए एंड्रॉइड फ्रेमवर्क में कुछ एपीआई है या क्या यह सभी कस्टम बनाया गया है? बाद के मामले में इसे कैसे लागू किया जाएगा? और आखिरी, लेकिन कम से कम नहीं, क्या इन टूलटिप्स में किसी प्रकार का आधिकारिक/तकनीकी नाम होता है जिसके द्वारा कोई उन्हें संदर्भित कर सकता है (विषय के बारे में कुछ जानकारी के लिए Googling जब उपयोगी हो सकता है)? धन्यवाद।

संपादित

मैं एक स्क्रीनशॉट जो अधिक सटीक मैं क्या मतलब है दिखाता है अर्जित किया है। "पॉइंटिंग हैंड" ग्राफ़िक के अलावा, इस टूलटिप में क्लॉक ऐप के आइकन के चारों ओर एक हाइलाइटिंग सर्कल है। यह केवल एक पारदर्शी ओवरले नहीं है जो क्लिक के बाद गायब हो जाता है: घड़ी आइकन को इस पल में क्लिक किया जा सकता है या यहां तक ​​कि लंबे समय तक दबाया जा सकता है, लेकिन टूलबार गायब होने तक अन्य आइकन (सर्कल के बाहर) उपलब्ध नहीं हैं। क्या यह सब व्यवहार विशेष रूप से इस उद्देश्य के लिए बनाया गया है, या कुछ अंतर्निहित सुविधा मौजूद है?

enter image description here

+1

मैं इस प्रश्न को खुद से पूछने वाला था, हालांकि मैं "गुब्बारा-टूलटिप" प्रभाव के बाद था। क्या आपको ऐसा करने का कोई तरीका मिला? मैं एक फीचर के लिए अपना लेआउट अधिक जटिल नहीं बनाना चाहता हूं जिसका उपयोग एक बार किया जाएगा ... – Basic

उत्तर

3

यह सिर्फ एक पारदर्शी संवाद है।

रेस फ़ोल्डर

<style name="Theme.TranparentDialog" parent="@android:style/Theme.NoTitleBar"> 
     <item name="android:colorBackgroundCacheHint">@null</item> 
     <item name="android:windowIsTranslucent">true</item> 
     <item name="android:colorForeground">@color/transparent</item> 
     <item name="android:windowIsFloating">false</item> 
     <item name="android:backgroundDimEnabled">false</item> 
     <item name="android:windowAnimationStyle">@android:style/Animation.Dialog</item> 
     <item name="android:windowBackground">@color/transparent</item> 
    </style> 

एक पारदर्शी प्रभाव प्राप्त करने के स्क्रीन पर संवाद बनाने में themes.xml में नीचे दिए गए कोड डालने/

Dialog dialog= new Dialog(context, R.style.Theme_TutorialDialog); 

dialog.show();

+0

उत्तर के लिए धन्यवाद। हालांकि, मैंने एक और सटीक स्क्रीनशॉट प्रदान किया है और मेरे प्रश्न को थोड़ा सा अद्यतन किया है। कृपया इसे देखें। – Natix

0

उपरोक्त संवाद में पृष्ठभूमि के रूप में उपयोग किए जाने पर इस दृश्य का उपयोग स्क्रीन पर एक पारदर्शी आयत खींचने के लिए किया जा सकता है।

public class WindowView extends View { 
private static final int LOW_DPI_STATUS_BAR_HEIGHT = 19; 

private static final int MEDIUM_DPI_STATUS_BAR_HEIGHT = 25; 

private static final int HIGH_DPI_STATUS_BAR_HEIGHT = 38; 
Context mContext; 

int mHeight, mWidth, mTop, mRight, mLeft, mBottom; 
Rect mLeftRect, mRightRect, mTopRect, mBottomRect; 

Rect mRect; 
Paint mPaint; 
View mAnchorView; 
Paint mTempPaint1; 

public WindowView(Context context, AttributeSet attrs) { 
    this(context, attrs, 0); 
} 

public WindowView(Context context) { 
    this(context, null); 
} 

public WindowView(Context context, AttributeSet attrs, int defStyle) { 
    super(context, attrs, defStyle); 
    mContext = context; 
    initVariables(); 
} 

boolean mReset = false; 

GestureDetector mGestureDetector; 
GestureDetector.SimpleOnGestureListener mSimpleOnGestureListener; 

private View getView() { 
    return this; 
} 

@Override 
public boolean onTouchEvent(MotionEvent event) { 
    if (mSimpleOnGestureListener == null) { 
     mSimpleOnGestureListener = new SimpleOnGestureListener() { 
      @Override 
      public boolean onSingleTapConfirmed(MotionEvent e) { 
       if (mListener != null && e.getX() >= mRect.left 
         && e.getX() <= mRect.right && e.getY() >= mRect.top 
         && e.getY() <= mRect.bottom) 
        mListener.onClick(getView()); 
       return true; 
      } 
     }; 
    } 
    if (mGestureDetector == null) { 
     mGestureDetector = new GestureDetector(mContext, 
       mSimpleOnGestureListener); 
    } 
    mGestureDetector.onTouchEvent(event); 
    return true; 
} 

private void initVariables() { 
    mPaint = new Paint(); 
    mPaint.setStyle(Style.FILL); 
    mPaint.setColor(mContext.getResources().getColor(
      R.color.tut_transcluscent_bg)); 
    mRect = new Rect(); 

    mTempPaint1 = new Paint(Paint.ANTI_ALIAS_FLAG); 
    mTempPaint1.setAlpha(64); 
    mTempPaint1.setColorFilter(new PorterDuffColorFilter(Color.WHITE, 
      Mode.SRC_IN)); 
} 

OnClickListener mListener; 

public void setTransparentBackGroundColor(int color) { 
    mPaint.setColor(color); 
    invalidate(); 
} 

@Override 
public void setOnClickListener(OnClickListener l) { 
    mListener = l; 
} 

public View getAnchorView() { 
    return mAnchorView; 
} 

float[] mPaddings; 
Rect mAnchorRect;; 

public void setAnchorView(View mView, Rect rect, float[] paddings) { 
    mAnchorRect = rect; 
    if (mAnchorRect == null) 
     mAnchorView = mView; 
    else 
     mAnchorView = null; 
    mPaddings = paddings; 
    requestLayout(); 
    invalidate(); 
} 

@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
    if (mAnchorView != null || mAnchorRect != null) 
     initView(); 
    mReset = true; 
} 

boolean mFlagInvalid = false; 
Handler mAnrHandler; 

public void setHandler(Handler handler) { 
    mAnrHandler = handler; 
} 

private int getStatusBarHeight() { 
    DisplayMetrics displayMetrics = new DisplayMetrics(); 
    ((WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE)) 
      .getDefaultDisplay().getMetrics(displayMetrics); 

    int statusBarHeight; 

    switch (displayMetrics.densityDpi) { 
    case DisplayMetrics.DENSITY_HIGH: 
     statusBarHeight = HIGH_DPI_STATUS_BAR_HEIGHT; 
     break; 
    case DisplayMetrics.DENSITY_MEDIUM: 
     statusBarHeight = MEDIUM_DPI_STATUS_BAR_HEIGHT; 
     break; 
    case DisplayMetrics.DENSITY_LOW: 
     statusBarHeight = LOW_DPI_STATUS_BAR_HEIGHT; 
     break; 
    default: 
     statusBarHeight = MEDIUM_DPI_STATUS_BAR_HEIGHT; 
    } 
    return statusBarHeight; 
} 

public void initView() { 

    mFlagInvalid = false; 
    int top = 0, left = 0; 
    if (mAnchorView != null) { 
     top = mAnchorView.getTop(); 
     left = mAnchorView.getLeft(); 
     View temp = mAnchorView; 
     int cnt = 0; 
     try { 
      while (((View) temp.getParent()).getId() != android.R.id.content) { 
       temp = (View) temp.getParent(); 
       int scrolledHeight = 0; 
       if (temp instanceof ScrollView) { 
        scrolledHeight = ((ScrollView) temp).getScrollY(); 
       } 
       top = top + temp.getTop() - scrolledHeight; 
       left = left + temp.getLeft(); 
       cnt++; 
       if (cnt > 100) { 
        if (mAnrHandler != null) 
         mAnrHandler.sendEmptyMessage(9); 
        mFlagInvalid = true; 
        break; 
       } 
      } 
     } catch (Exception e) { 
      mFlagInvalid = true; 
      if (mAnrHandler != null) 
       mAnrHandler.sendEmptyMessage(8); 
      e.printStackTrace(); 
     } 
     TypedValue tv = new TypedValue(); 
     if (getContext() 
       .getTheme() 
       .resolveAttribute(
         VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB ? android.R.attr.actionBarSize 
           : R.attr.actionBarSize, tv, true)) { 
      int actionBarHeight = TypedValue.complexToDimensionPixelSize(
        tv.data, getResources().getDisplayMetrics()); 
      top = top + actionBarHeight; 
     } 

    } else if (mAnchorRect != null) { 
    } 

    if (mFlagInvalid) 
     init(20, 20, 50, 50); 
    else { 
     if (mAnchorRect != null) { 
      init(mAnchorRect.bottom, mAnchorRect.right, mAnchorRect.left, 
        mAnchorRect.top); 
     } else 
      init(mAnchorView.getHeight(), mAnchorView.getWidth(), left, top); 
    } 
} 

public void init(int height, int width, int left, int top) { 
    mWidth = width; 
    mHeight = height; 
    mTop = top; 
    mBottom = top + height; 
    mLeft = left; 
    mRight = left + width; 

    mLeft = (int) (mLeft + mPaddings[0] * mWidth); 
    mTop = (int) (mTop + mPaddings[1] * mHeight); 
    mRight = (int) (mRight - mPaddings[2] * mWidth); 
    mBottom = (int) (mBottom - mPaddings[3] * mHeight); 
    mRect = new Rect(mLeft, mTop, mRight, mBottom); 

    invalidate(); 
} 

public Rect getAnchorRect() { 
    return mRect; 
} 

@Override 
protected void onDraw(Canvas canvas) { 
    super.onDraw(canvas); 
    initOnceOnDraw(); 
    canvas.drawRect(mLeftRect, mPaint); 
    canvas.drawRect(mTopRect, mPaint); 
    canvas.drawRect(mRightRect, mPaint); 
    canvas.drawRect(mBottomRect, mPaint); 
    canvas.drawRect(mRect, mTempPaint1); 
} 

private void initOnceOnDraw() { 
    if (mReset) { 
     mReset = false; 
     mTopRect = new Rect(0, 0, getWidth(), mRect.top); 
     mLeftRect = new Rect(0, mRect.top, mRect.left, mRect.bottom); 
     mRightRect = new Rect(mRect.right, mRect.top, getWidth(), 
       mRect.bottom); 
     mBottomRect = new Rect(0, mRect.bottom, getWidth(), getHeight()); 
    } 
}} 

विधि setAnchorView() .. दृश्य जिस पर ओवरले तैयार हो गया है देता है

mWindowView = (WindowView) mTutorialView 
          .findViewById(R.id.windowview_tutorial); 
         mWindowView.setTransparentBackGroundColor(backgroundColor); 

        mWindowView.setAnchorView(view, null, padding); 

आशा इस मदद करता है

संबंधित मुद्दे