Sketchware पर हिलता हुए Text कैसे बनाए जाते है वो भी 2 मिनट में

 आप तो जानते ही होंगे की Sketchware की सेटिंग कितनी टप है और कही न कही हम उसकी जानकारी आप के सामने काम समय में आपको बताने की कोशिश करते है ।

How to make GIF TEXT

आपने किसी के app या वेबसाइट में कही न कही देखा ही होगा की किसी को Text अपने आप ही हिलती है यानि जलती बुझती हुई दिखी होगी ।

Sketchware project

 
वैसे ही आज हम आपको  बहुत ही आसान तरीके से बताने वाले है की आप किस तरह से बना सकते हो

Stap 1 आपको सबसे पहले Sketchware ऐप को open करना है जिसमें आपको एक New Project पर एक app Create करना है ।

Stap 2 अब आपको एक Liniyar V को लेना है इसको आप जैसे चाहे setup कर सकते है ।

Stap 3 अब आपको एक Text लेना है उसमे आप जो भी चाहे आप अपने हिसाब से लिख सकते है जिसका Size और Bolt कर सकते हैं

Stap 4 अब आपको Event >>Activity Create में जाना है जिसमे आपको Componet पर क्लिक करे और Add Variable के Time आइकन पर क्लिक करे । 

फिर आप मेरे द्वारा दिए गए image को ध्यान से देख कर create कर सकते हो। After 0 और me fer every er 520 MS को डालना जरूरी है

Stap 5 अब आपको अपने menu के Control आइकॉन में इस वाले Option को Add करना है 

जिसके बाद आपको इस में 2 और आइकॉन फिट करने है 

जैसे जैसे मैंने आपको setup करके दिखाए है आपको वैसे ही setup करने है 

Number वाले इमेज को ध्यान से सेटअप करना है जिससे आपको कही कोई गलती न हो । फिर आपको View वाले Optuin को Select करना है जिसमे आपको VISIBLE रखना है और दूसरे वाले में आपको INVISIBLE रखना है 

अब आपको कुछ अपनी setting कुछ इस तरह से दिख रही होगी

 लो अब आपका App पूरी तरह से Complete हो चुका है अब आप इसे Inastall करके चेक कर सकते हो।

अब और भी भयानक पड सकता है पोर्न वीडियो देखना -Watching porn videos can be even more terrible now

आज हम बहुत ही मह्त्वपूर्ण टॉपिक पर बात करने जा रहे है शायद किसी अभी तक किसी व्यक्ति को पता नहीं होगा कि पोर्न वीडियो के देखने से क्या प्रभाव पड रहा है। पोर्न वीडियो के चलते  हमारे दिलो दिमाग में बहुत ही गहरे से बैठ गया है । 

हम अपनी इस पोस्ट में बताएंगे कि सबसे ज्यादा इस तरह की वीडियो कौन देख रहा है और आने वाले दिनों में सरकार इस पर क्या इक्सशन लेगी। हम आपको बताना चाहते है कि कुछ महीनों पहले ही भारत सरकार ने पोर्न वीडियो पर रोक लगवा दी थी 

जिससे किसी प्रकार से लोगो पर ऐसे Video का असर ना पड़े  साथ ही सरकार ने हिदायत भी दी थी कि ऐसे वीडियो देखे जाने या पकड़े जाने पर तुरंत कारवाही होगी ।

आज हम आपको एक ऐसी ही जानकारी देने जा रहा हूं जो बिल्कुल सच है शायद आप विश्वास नहीं करेंगे 

अभी हाल के एक सर्वे में पाया गया की किस एरिया में सबसे ज्यादा पोर्न वीडियो देखे जा रहे है।

हम आपको बता दे कुछ खास पुलिस वालो को एक एरिया में सर्वे करने के लिए कुछ टीम एक नदी किनारे पर पहुंची तो उस एरिया का सारा Network अपने कब्जे में ले लिया लेकिन एक week में पता चल गया की कौन किस जगह पोर्न वीडियो को कितने लोग और कहा पर देखा जा रहा है।

क्या होता है पोर्न वीडियो को देखने से-What happens by watching porn videos,

आप को तो पता ही होगा की कोई भी video या movies देखने से हमारे दिमाग पर क्या असर पड़ता है वैसे ही पोर्न वीडियो को देखने से होता है और वैसे ही कार्य करने की इच्छा जागने की 90% है जाती है और आगे चल कर रह एक गम्मीर रोग का रूप ले लेती है ।

कौन सबसे ज्यादा वीडियो को देख रहा है-Who is watching the most videos

जब किसी एरिया का सर्वे किया गया तो पाया कि सबसे ज्यादा वीडियो को कौन और कहा के लोग ज्यादा मात्रा में देखा गया है सर्वे के अनुसार पाया गया की सबसे ज्यादा वीडियो पुरषों की अपेक्षा महिलाओं में देखा गया ।

किस नगर के लोग सबसे ज्यादा पोर्न वीडियो को देख रहे है-Which City people are watching the most porn videos

पोर्न वीडियो को से विदेश है नहीं भारत भी आगे निकलता जा रहा है एडल्ट साइट्स सर्च के मुताबिक मुंबई, हैदराबाद,कोलकाता दिल्ली जैसी महानगरों में अधिक मात्रा में देखा गया है अगर बात करे कि किस City में सबसे ज्यादा पोर्न वीडियो को देखा रहा है वो है दिल्ली शहर , दिल्ली के पोर्न देखने की सबसे ज्यादा मात्रा 39.8%  है। दिल्ली और कोलकाता जैसे महानगरों में वीडियो देखने का औसत 10 मिनट 30 सेकेंड  का आता है 

Google  पर सबसे ज्यादा पोर्न किस नाम से सर्च किया जाता है-What is the most porn search on Google?

हम आपको बताना चाहते है कि देश के सबसे ज्यादा पाकिस्तान और चीन में पोर्न वीडियो सबसे ज्यादा देखा जाता है , पाकिस्तान में Search पोर्न जानवरो में रुचि रखता है पाकिस्तान में Google Search ने पाया कि सबसे ज्यादा पाकिस्तान जानवरो में सूअर कुत्ता गधा कैसे पोर्न देखना पसंद करता है ।

पोर्न वीडियो या मूवीज देखने से आपके घर  आ सकती है पुलिस Police can come to your house by watching porn videos or movies 

अभी हाल में न्यूजनुसार अब आप पोर्न वीडियो देखते है तो अब आएगी आप के घर भी पुलिस जी हा। आपने सही सुना पुलिस के कुछ अधिकारियों के मुताबिक अगर आपके एरिया में कहीं किसी भी जगह कोई रेप का केस दर्ज होता है तो पीड़ित के एरिया के सारे मोबाइल की लोकेशन से , उस Time में कितने पोर्न वीडियो देख रहे थे सभी के पास एक मैसेज भेजा जाएगा और ना आने वाले को पुलिस घर से उठने जाएगी कुल मिलके सबसे ज्यादा उन्हीं लोगो को बुलाया जाएगा जी व्यक्ति उसी वक्त कोई पोर्न वीडियो देख रहा होगा , माना जा रहा है कि पोर्न देखने वाला व्यक्ति केस में ज्यादा रेप की मात्रा होती है 

पोर्न वीडियो देखने से कैसे बचना चाहिए_How to avoid watching porn videos

हम आपको बताना चाहते है तो आप एक बहुत ही अच्छा काम कर रहे है जिससे आप का परिवार और किसी से रहा सकता है साथ ही आप अपने परिवार को अच्छा खासा time safed भी कर सकते है और हां आपने अंदर Negative सोच भी नहीं आएगी जिससे आप का में अच्छे कामों को करने में लगेगा 

तो आप को मेरी यह post कैसी लगी मुझे कॉमेंट में जरूर बताएं और हां  Like और Comment करना ना भूले।

Google पर अपना Add Card 2 मिनट में कैसे बनाए How to make your Add Card on Google in 2 minutes

आपको पता ही होगा कि जब भी कोई आपके blog या YouTube चैनल को जब google में Search करता है तो सबसे पहले आपको add card दिखता है जिससे आपके blog , YouTube चैनल की पहचान हो सकते या देख सके ।

अगर आप अपने ब्लॉग या YouTube का add me to search card बनाना चाहते है जैसा आपको मेरी पोस्ट को read कर बना सकते है या तो आप मेरे द्वारा बताए गए Trick को follow जरूर करे ।

आपको हम बताना चाहते है कि आप किस प्रकार से add card banaye जब तक आप अपने Google Account को अपने मोबाइल से verify नही करा देते जब तक यह सुविधा आपके Account को Aproble  नही करेगी, आप एक बार OTP को Submit करना अनिवार्य हो चुका है 

अब आपको कुछ कुलम खाली से देख रहे है आपको उनको सही full Detail डाल देना है इसके लिए मैंने आपको कुछ सरल तरीके से भरने की जानकारी और ट्रिक आपके सामने दी है 

Neme_ आप अपने बिसनेज का या अपना नाम को दे सकते है ,

Location_आपको लोकेशन Select करनी है जो आपके कॉलम में show हो रही हो ,

About- आपको about में वो जानकारी देनी है जो आपके ब्लॉग या YouTube में Submit है आप चाहे हो आपके कोई खास जानकारी भी दे सकते है,

आप सारा का सारा फॉर्म feel करने के बाद Social media को अपने Icon में add करना बहुत है जरूरी है जिससे आप अपने card को google mein search के दौरान लोगों के बीच अपने Page पर आसान तरीके से ले जा सकते है ,

जब आप अपने google add card पूर्व रूप से check ✅ कर ले कि यह form सही से भरा है या नही अगर हां तो आप Save Butten पर क्लिक कर दे।

अब आपके सामने एक new विंडो खुल कर आपके सामने आ जाएगी जैसे आपको मेरे ऊपर icon में दिख रही है जिसमे आपको बता रहा है ही आपकी जानकारी Submit कर ली गई है और आपका Google add card Success हो चुका है अब अगर आप चाहे हो View Search Card पर click कर के check भी कर सकते है

जिस फॉर्म को आपने feel किया है वो आपकी future में बहुत है मदद गार साबित होगा ।

आवास विकास योजना List को अपने मोबाइल या लैपटॉप से कैसे निकले और जानिए गांव और शहर की जानकारी मेरे साथ In Hindi

आज की पोस्ट मैं हम बताएं वाले है कि आप अपने एरिया आ शहर के आवास या कॉलोनी को कैसे पता करे की अभी तक आप के name आई हुई है या नही वो भी चुटकी में बस करना नही है 

कुछ ज्यादा काम जुड़े रहे मेरे साथ हम आपको बताएंगे की आप आवास योजनाऐ का किस प्रकार से लाभ ले सकते है अब नही हैं किसी से पूछने की जरूरत नहीं है 

आप अपनी या रिश्तेदार की या गांव शहर की किसी की भी आवास योजनाऐं Check या देख सकते है

आप आवास विकास कालोनी या निवास कैसे देखे 

बहुत ही साधारण तरीके से आप अपने गांव ब शहर की आवास योजना की लिस्ट देख सकते है जिसके लिए आपको दिए गए Lick पर Click करे

1, सबसे पहले आपको State Select करना हे बिना गलत हुआ बरना अपको आवास   योजना ली लिस्ट प्राप्त नही होगी।

2, अब अपको अपनी शहर का नाम Search करना हैं किस शहर मैं आपका गांव पड़ता है

3, अब आपको अपने गांव को सर्च करना हैं कि आपका गांव आवास योजना कि लिस्ट मैं दिख रहा हैं या नही अगर हां तो आपको अपने गांव को Select कर लेना हैं

4, जब आप next butten पर क्लिक करेंगे तो आपको कुछ कोड दिख रहे होंगे जिसको आप सही से हाल करके नीचे Enter कर देना है 

5, अब आपको Next Submit पर Click करेंगे वैसे ही आपके सामने आपकी पसंद की List आपके सामने  प्रदर्शित हो जाएंगी ।

अब आप अपने गांव की लिस्ट भी डाउनलोड कर सकते है और List की कॉपी को आप Save या सुरक्षित भी कर सकते है , आपको मेरी पोस्ट कैसी लगी आप मुझे Comments Box में जरूर बताएं 

Google Adsense में दिए Earning at risk Error को कैसे सही करे ,Error सही ना करने पर आपका Adsense Account हो सकता है Cancel।

आज की पोस्ट में हम आपको बताने वाले है की आप गूगल एडसेंस में दिए जा रहे Error को कैसे सुधार करा/कर सकते है 

मेरे द्वारा दिए गए एक छोटी से Tricks के जरिए

वैसे तो आपको पता ही होगा की blogger के लिए Assense का होना कितना जरूरी है और जब तक आपको Google की तरफ से परमिशन नही मिल जाती तब तक आपका ब्लॉगर आपके लिए कोई काम का नही है इसी लिए छोटी से छोटी blog और adsense की जानकारी होनी चाहिए जिससे आपके Blog और Adsense को  जल्द से जल्द परमिशन मिल सके। तो में आशा करता हूं की मेरी Post को पड़ने के बाद आपको अपने Adsense में Help जरूर मिलेंगी।

Earning at risk-you need to fix same txt.file issue to avoid server impact to your revenue के risk को कैसे सुधार करे

जब भी आप अपने Adsense को open करते हो तो आपके सामने एक popup विंडो open होती है जिसमे आपको मेरे Image की तरह से show होती हुई दिखाई दे रही होगी जिसमे आपको एक fix now पर Click करने पर आपको एक फाइल download करनी पड़ती है जिसमे आपको कुछ इस तरह की लिंक और Code मिलता है 

google.com, pub-0000000000000, DIRECT, f08c47fec0942fa0

मिलता है जिसको आप कॉपी करे और अब आप अपने blogger की Setting में जाए

अब आपको नीचे की और जाते हुए आपको बहुत सारे Option नजर आ रहे होंगे जिसमें से आपको Enable Customer robots.txt को ON कर देेंना है 

फिर आपनेे जो Code Copy किया था उसेे आप नीचे  Customer robots.txt पर Click कर के Post कर देना है जैसे की आपको मेंरे Image  दिख रहा हैै।

अब आपको 2 से 3 घंटे wait करना होगा फिर आपके सामने आपका Adsense Approval मिल जायेगा 

Microsoft office पर जानिए की आप 30 दिन फ्री में कैसे Microsoft office का प्रोयोग कर सकते है और साथ ही आप Microsoft Office 2013 Product Key All Version की जानकारी ले सकते हो

आज हम आपको एक न्यू पोस्ट के बारे में जानकारी देने जा रहे है जो आपके लिए बहुत ही ज्यादा महतपूर्ण होगी ।

अगर आप कंप्यूटर या लैपटॉप चलाते है तो आपको कही न कही Microsoft की जरूरत तो  पड़ती होगी तो उसी से जुड़ी जानकारी आपको प्रदान करने जा रहा हूं 

आपके सामने एक Microsoft office आप किस प्रकार से प्रयोग में use kar सकते है Microsoft office 30 day Software free मैं प्रयोग कर सकते है जब आपको  पसंद आ तो आप pay भी कर  सकते 

हो।

Microsoft office 2013’s trial version for 30 days, so that you will get a chance to test it without have to buy it, you will get different Microsoft office 2013 product key for that that will make sure that you have a smooth operation for one month. With this package you will get access to Word 2013, PowerPoint 2013, Excel 2013, Outlook 2013, OneNote 2013, Access 2013, Publisher 2013, and the LyncMessenger program.

Microsoft Office 2013 Product Key for Professional Plus

FCMXC-RDWMP-RFGVD-8TGPD-VQQ2X
MT7YN-TMV9C-7DDX9-64W77-B7R4D
PGD67-JN23K-JGVWW-KTHP4-GXR9G
B9GN2-DXXQC-9DHKT-GGWCR-4X6XK
6PMNJ-Q33T3-VJQFJ-23D3H-6XVTX

MS Office 2013 Product Key List

6KTFN-PQH9H-T8MMB-YG8K4-367TX
B9GN2-DXXQC-9DHKT-GGWCR-4X6XK
J484Y-4NKBF-W2HMG-DBMJC-PGWR7
FCMXC-RDWMP-RFGVD-8TGPD-VQQ2X
C2FG9-N6J68-H8BTJ-BW3QX-RM3B3
MT7YN-TMV9C-7DDX9-64W77-B7R4D
6PMNJ-Q33T3-VJQFJ-23D3H-6XVTX
PGD67-JN23K-JGVWW-KTHP4-GXR9G
KBDNM-R8CD9-RK366-WFM3X-C7GXK
4HNBK-863MH-6CR6P-GQ6WP-J42C9

MS Office 2013 Serial number 100% Working

2XKYR-THNHY-4M9D4-9YG2X-M96XV
366NX-BQ62X-PQT9G-GPX4H-VT7TX
YC7DK-G2NP3-2QQC3-J6H88-GVGXT
KDVQM-HMNFJ-P9PJX-96HDF-DJYGX

Sketchware पर SingUp FireBase पर कैसे बनाते है जानिए इस की फुल जानकारी

आज की पोस्ट में आपको Sketchware से जुड़ी जानकारी आपको प्रदान करने जा रहे है , 

अगर आप Sketchware के बारे में नहीं जानते तो आपको मेरे पोस्ट पर जल्दी से जानकारी प्राप्त हो जाएगी ।

वैसे तो हम आपको पूरी जानकारी किसी के बारे में नहीं बता पाएंगे उसके लिये मुझे पोस्ट को बहुत ही ज्यादा time जाएगा साथ ही आप बोर भी हो जाओगे इसी लिए में आपको short में sketchware की जानकारी आपके सामने प्रस्तुत करता रहूंगा ।

आइए हम आपको sketchware की जानकारी से अवगत कराता हूं आज की जो पोस्ट है जिससे आप अपने सिस्टम में किसी भी प्रकार के मोबाइल App ऐप को बना सकते है 

1> सबसे पहले आपको Sketchware ऐप को ओपन करना है साथ ही आप अपने अनुसार पेज को डिजाइन कर सकते है 

2> जब आपका पेज डिजाइन हो जाए तो आपको Complete में जाकर के Firebase के option ko चुन सकते है ।

3>  जैसा कि आपको मेरे Image में दिख रहा है सबसे पहले आपको firebase के option mein oncreateuserComplete पर क्लिक कर के उसेे Create करना है कुछ इस तरह से डिजाइन करना है 

मैं आपको इसमें कुछ खास प्रकार की जानकारी दूंगा क्योंकि मुझे पोस्ट को ज्यादा नहीं बड़ना है

4>  जैसा कि आपको आपको TextView में जाने के बाद आपको   setText को लेकर केे चिपका देंेेना है 

जैसा आपको मेरे इमेज में दिखाया गया ही वैसा ही आप अपने ऐप में  पोस्ट कर देना है ।

5>  अब आपको add Source directly के बाद आपको  मेरे द्वारा दिए गए कोड  add करना है

FirebaseAuth auth = FirebaseAuth.getInstance();
 com.google.firebase.auth.FirebaseUser user = 
auth.getCurrentUser();

user.sendEmailVerification().addOnCompleteListener
(new 
OnCompleteListener<Void>()
{ @Override
public void onComplete(Task task)
{ if (task.isSuccessful()) {

साथ में एक बार फिर से Add Source directly को लेकर इसे भी टाइप करना है 

1.

 } else {

 2.   और

 }

}});

नोट-जैसा में कोड डालने के लिए कहा है आपको वैसा ही डालना है अगर कोई Misstek होती है तो आपको अपने ऐप में Error Show होने लगेगा ।

Sketchware mein Butten style aur Butten Color kaise lagaye.

Aaj hum aapko batane wale hai ki sketchware par color butten kaise banate hai 

Waise to aapko kaphi YouTuberon ke channels se sketchware ki jankari mil jayegi lekin mein aap ko kuchh jyada hi short mein jankari de raha hun. Jisse aapka time bhi bachat ho.

Jaisa ki meine aap sabko diyegaye image mein dekh rahi photo ko dekh kar aap samjh gaye hi honge ki kis prakar se butten Color karte hai . Bas di gai jankari ko dhayan de jarur dekhe.

New TagTarget View<<View<<Title<<massage<<color

Jaisa ki meine aapko 9 short code diye huye hai jiski madat se aap apne app ko aaram se coding kar sakte hai.

 1.

TapTargetView.showFor(MainActivity.this,
TapTarget.forView(_view, _title, _msg)
.outerCircleColorInt(Color.parseColor(_bgcolor))
.outerCircleAlpha(0.96f)
.targetCircleColorInt(Color.parseColor("#FFFFFF"))
.titleTextSize(25)
.titleTextColorInt(Color.parseColor("#FFFFFF"))
.descriptionTextSize(18)
.descriptionTextColor(android.R.color.white)
.textColorInt(Color.parseColor("#FFFFFF"))
.textTypeface(Typeface.SANS_SERIF)
.dimColor(android.R.color.black)
.drawShadow(true)
.cancelable(true)
.tintTarget(true)
.transparentTarget(true)
//.icon(Drawable)
.targetRadius(60),

//LISTENER//

new TapTargetView.Listener() {
@Override
public void onTargetClick(TapTargetView view) {
//ON CLICKED//
super.onTargetClick(view);
}
});

 

}static class UiUtil {
    UiUtil() {
    }
    static int dp(Context context, int val) {
        return (int) TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP, val, context.getResources().getDisplayMetrics());
    }
    static int sp(Context context, int val) {
        return (int) TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_SP, val, context.getResources().getDisplayMetrics());
    }
    static int themeIntAttr(Context context, String attr) {
        final android.content.res.Resources.Theme theme = context.getTheme();
        if (theme == null) {
            return -1;
        }
        final TypedValue value = new TypedValue();
        final int id = context.getResources().getIdentifier(attr, "attr", context.getPackageName());

        if (id == 0) {
            // Not found
            return -1;
        }
        theme.resolveAttribute(id, value, true);
        return value.data;
    }
    static int setAlpha(int argb, float alpha) {
        if (alpha > 1.0f) {
            alpha = 1.0f;
        } else if (alpha <= 0.0f) {
            alpha = 0.0f;
        }
        return ((int) ((argb >>> 24) * alpha) << 24) | (argb & 0x00FFFFFF);
    }
}

3.

static class FloatValueAnimatorBuilder {

    private final ValueAnimator animator;

    private EndListener endListener;

    interface UpdateListener {
        void onUpdate(float lerpTime);
    }
    interface EndListener {
        void onEnd();
    }
    protected FloatValueAnimatorBuilder() {
        this(false);
    }
    FloatValueAnimatorBuilder(boolean reverse) {
        if (reverse) {
            this.animator = ValueAnimator.ofFloat(1.0f, 0.0f);
        } else {
            this.animator = ValueAnimator.ofFloat(0.0f, 1.0f);
        }
    }
    public FloatValueAnimatorBuilder delayBy(long millis) {
        animator.setStartDelay(millis);
        return this;
    }
    public FloatValueAnimatorBuilder duration(long millis) {
        animator.setDuration(millis);
        return this;
    }
    public FloatValueAnimatorBuilder interpolator(TimeInterpolator lerper) {
        animator.setInterpolator(lerper);
        return this;
    }
    public FloatValueAnimatorBuilder repeat(int times) {
        animator.setRepeatCount(times);
        return this;
    }
    public FloatValueAnimatorBuilder onUpdate(final UpdateListener listener) {
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                listener.onUpdate((float) animation.getAnimatedValue());
            }
        });
        return this;
    }
    public FloatValueAnimatorBuilder onEnd(final EndListener listener) {
        this.endListener = listener;
        return this;
    }
    public ValueAnimator build() {
        if (endListener != null) {
            animator.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    endListener.onEnd();
                }
            });
        }
        return animator;
    }
}:

4

 ReflectUtil() {
    }
    static Object getPrivateField(Object source, String fieldName)
            throws NoSuchFieldException, IllegalAccessException {
        final java.lang.reflect.Field objectField = source.getClass().getDeclaredField(fieldName);
        objectField.setAccessible(true);
        return objectField.get(source);
    }
}

   

5.

static class TapTarget extends Activity {
    final CharSequence title;
    final CharSequence description;
    float outerCircleAlpha = 0.96f;
    int targetRadius = 44;
    Rect bounds;
    android.graphics.drawable.Drawable icon;
    Typeface titleTypeface;
    Typeface descriptionTypeface;


    private int outerCircleColorRes = -1;
    private int targetCircleColorRes = -1;
    private int dimColorRes = -1;
    private int titleTextColorRes = -1;
    private int descriptionTextColorRes = -1;

    private Integer outerCircleColor = null;
    private Integer targetCircleColor = null;
    private Integer dimColor = null;
    private Integer titleTextColor = null;
    private Integer descriptionTextColor = null;

    private int titleTextDimen = -1;
    private int descriptionTextDimen = -1;
    private int titleTextSize = 20;
    private int descriptionTextSize = 18;
    int id = -1;
    boolean drawShadow = false;
    boolean cancelable = true;
    boolean tintTarget = true;
    boolean transparentTarget = false;
    float descriptionTextAlpha = 0.54f;

6.

public static TapTarget forView(View view, CharSequence title) {
        return forView(view, title, null);
    }
    public static TapTarget forView(View view, CharSequence title, CharSequence description) {
        return new ViewTapTarget(view, title, description);
    }
    public static TapTarget forBounds(Rect bounds, CharSequence title) {
        return forBounds(bounds, title, null);
    }
    public static TapTarget forBounds(Rect bounds, CharSequence title, CharSequence description) {
        return new TapTarget(bounds, title, description);
    }
    protected TapTarget(Rect bounds, CharSequence title, CharSequence description) {
        this(title, description);
        if (bounds == null) {
            throw new IllegalArgumentException("Cannot pass null bounds or title");
        }
        this.bounds = bounds;
    }
    protected TapTarget(CharSequence title, CharSequence description) {
        if (title == null) {
            throw new IllegalArgumentException("Cannot pass null title");
        }
        this.title = title;
        this.description = description;
    }
    public TapTarget transparentTarget(boolean transparent) {
        this.transparentTarget = transparent;
        return this;
    }
    public TapTarget outerCircleColor( int color) {
        this.outerCircleColorRes = color;
        return this;
    }
    public TapTarget outerCircleColorInt( int color) {
        this.outerCircleColor = color;
        return this;
    }
    public TapTarget outerCircleAlpha(float alpha) {
        if (alpha < 0.0f || alpha > 1.0f) {
            throw new IllegalArgumentException("Given an invalid alpha value: " + alpha);
        }
        this.outerCircleAlpha = alpha;
        return this;
    }
    public TapTarget targetCircleColor( int color) {
        this.targetCircleColorRes = color;
        return this;
    }
    public TapTarget targetCircleColorInt( int color) {
        this.targetCircleColor = color;
        return this;
    }
    public TapTarget textColor( int color) {
        this.titleTextColorRes = color;
        this.descriptionTextColorRes = color;
        return this;
    }
    public TapTarget textColorInt( int color) {
        this.titleTextColor = color;
        this.descriptionTextColor = color;
        return this;
    }
    public TapTarget titleTextColor( int color) {
        this.titleTextColorRes = color;
        return this;
    }
    public TapTarget titleTextColorInt( int color) {
        this.titleTextColor = color;
        return this;
    }
    public TapTarget descriptionTextColor( int color) {
        this.descriptionTextColorRes = color;
        return this;
    }
    public TapTarget descriptionTextColorInt( int color) {
        this.descriptionTextColor = color;
        return this;
    }
    public TapTarget textTypeface(Typeface typeface) {
        if (typeface == null) throw new IllegalArgumentException("Cannot use a null typeface");
        titleTypeface = typeface;
        descriptionTypeface = typeface;
        return this;
    }
    public TapTarget titleTypeface(Typeface titleTypeface) {
        if (titleTypeface == null) throw new IllegalArgumentException("Cannot use a null typeface");
        this.titleTypeface = titleTypeface;
        return this;
    }
    public TapTarget descriptionTypeface(Typeface descriptionTypeface) {
        if (descriptionTypeface == null) throw new IllegalArgumentException("Cannot use a null typeface");
        this.descriptionTypeface = descriptionTypeface;
        return this;
    }
    public TapTarget titleTextSize(int sp) {
        if (sp < 0) throw new IllegalArgumentException("Given negative text size");
        this.titleTextSize = sp;
        return this;
    }
    public TapTarget descriptionTextSize(int sp) {
        if (sp < 0) throw new IllegalArgumentException("Given negative text size");
        this.descriptionTextSize = sp;
        return this;
    }
    public TapTarget titleTextDimen( int dimen) {
        this.titleTextDimen = dimen;
        return this;
    }
    public TapTarget descriptionTextAlpha(float descriptionTextAlpha) {
        if (descriptionTextAlpha < 0 || descriptionTextAlpha > 1f) {
            throw new IllegalArgumentException("Given an invalid alpha value: " + descriptionTextAlpha);
        }
        this.descriptionTextAlpha = descriptionTextAlpha;
        return this;
    }
    public TapTarget descriptionTextDimen( int dimen) {
        this.descriptionTextDimen = dimen;
        return this;
    }
    public TapTarget dimColor( int color) {
        this.dimColorRes = color;
        return this;
    }
    public TapTarget dimColorInt( int color) {
        this.dimColor = color;
        return this;
    }
    public TapTarget drawShadow(boolean draw) {
        this.drawShadow = draw;
        return this;
    }
    public TapTarget cancelable(boolean status) {
        this.cancelable = status;
        return this;
    }
    public TapTarget tintTarget(boolean tint) {
        this.tintTarget = tint;
        return this;
    }
    public TapTarget icon(android.graphics.drawable.Drawable icon) {
        return icon(icon, false);
    }
    public TapTarget icon(android.graphics.drawable.Drawable icon, boolean hasSetBounds) {
        if (icon == null) throw new IllegalArgumentException("Cannot use null drawable");
        this.icon = icon;
        if (!hasSetBounds) {
            this.icon.setBounds(new Rect(0, 0, this.icon.getIntrinsicWidth(), this.icon.getIntrinsicHeight()));
        }
        return this;
    }
    public TapTarget id(int id) {
        this.id = id;
        return this;
    }
    public TapTarget targetRadius(int targetRadius) {
        this.targetRadius = targetRadius;
        return this;
    }
    public int id() {
        return id;
    }
    public void onReady(Runnable runnable) {
        runnable.run();
    }
    public Rect bounds() {
        if (bounds == null) {
            throw new IllegalStateException("Requesting bounds that are not set! Make sure your target is ready");
        }
        return bounds;
    }
    Integer outerCircleColorInt(Context context) {
        return colorResOrInt(context, outerCircleColor, outerCircleColorRes);
    }
    Integer targetCircleColorInt(Context context) {
        return colorResOrInt(context, targetCircleColor, targetCircleColorRes);
    }
    Integer dimColorInt(Context context) {
        return colorResOrInt(context, dimColor, dimColorRes);
    }
    Integer titleTextColorInt(Context context) {
        return colorResOrInt(context, titleTextColor, titleTextColorRes);
    }

    Integer descriptionTextColorInt(Context context) {
        return colorResOrInt(context, descriptionTextColor, descriptionTextColorRes);
    }
    int titleTextSizePx(Context context) {
        return dimenOrSize(context, titleTextSize, titleTextDimen);
    }
    int descriptionTextSizePx(Context context) {
        return dimenOrSize(context, descriptionTextSize, descriptionTextDimen);
    }

    private Integer colorResOrInt(Context context, Integer value, int resource) {
        if (resource != -1) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                return context.getColor(resource);
            }
        }
        return value;
    }
    private int dimenOrSize(Context context, int size, int dimen) {
        if (dimen != -1) {
            return context.getResources().getDimensionPixelSize(dimen);
        }
        return UiUtil.sp(context, size);
    }
}

7.

static class TapTargetView extends View {
    private boolean isDismissed = false;
    private boolean isDismissing = false;
    private boolean isInteractable = true;

    final int TARGET_PADDING;
    final int TARGET_RADIUS;
    final int TARGET_PULSE_RADIUS;
    final int TEXT_PADDING;
    final int TEXT_SPACING;
    final int TEXT_MAX_WIDTH;
    final int TEXT_POSITIONING_BIAS;
    final int CIRCLE_PADDING;
    final int GUTTER_DIM;
    final int SHADOW_DIM;
    final int SHADOW_JITTER_DIM;


    final ViewGroup boundingParent;
    final ViewManager parent;
    final TapTarget target;
    final Rect targetBounds;

    final TextPaint titlePaint;
    final TextPaint descriptionPaint;
    final Paint outerCirclePaint;
    final Paint outerCircleShadowPaint;
    final Paint targetCirclePaint;
    final Paint targetCirclePulsePaint;

    CharSequence title;

    StaticLayout titleLayout;

    CharSequence description;

    StaticLayout descriptionLayout;
    boolean isDark;
    boolean debug;
    boolean shouldTintTarget;
    boolean shouldDrawShadow;
    boolean cancelable;
    boolean visible;

    // Debug related variables

    SpannableStringBuilder debugStringBuilder;

    DynamicLayout debugLayout;

    TextPaint debugTextPaint;

    Paint debugPaint;

    // Drawing properties
    Rect drawingBounds;
    Rect textBounds;

    Path outerCirclePath;
    float outerCircleRadius;
    int calculatedOuterCircleRadius;
    int[] outerCircleCenter;
    int outerCircleAlpha;

    float targetCirclePulseRadius;
    int targetCirclePulseAlpha;

    float targetCircleRadius;
    int targetCircleAlpha;

    int textAlpha;
    int dimColor;

    float lastTouchX;
    float lastTouchY;

    int topBoundary;
    int bottomBoundary;

    Bitmap tintedTarget;

    Listener listener;


    ViewOutlineProvider outlineProvider;

    public static TapTargetView showFor(Activity activity, TapTarget target) {
        return showFor(activity, target, null);
    }

    public static TapTargetView showFor(Activity activity, TapTarget target, Listener listener) {
        if (activity == null) throw new IllegalArgumentException("Activity is null");

        final ViewGroup decor = (ViewGroup) activity.getWindow().getDecorView();
        final ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
        final ViewGroup content = (ViewGroup) decor.findViewById(android.R.id.content);
        final TapTargetView tapTargetView = new TapTargetView(activity, decor, content, target, listener);
        decor.addView(tapTargetView, layoutParams);

        return tapTargetView;
    }

    public static TapTargetView showFor(Dialog dialog, TapTarget target) {
        return showFor(dialog, target, null);
    }

    public static TapTargetView showFor(Dialog dialog, TapTarget target, Listener listener) {
        if (dialog == null) throw new IllegalArgumentException("Dialog is null");

        final Context context = dialog.getContext();
        final WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        final WindowManager.LayoutParams params = new WindowManager.LayoutParams();
        params.type = WindowManager.LayoutParams.TYPE_APPLICATION;
        params.format = PixelFormat.RGBA_8888;
        params.flags = 0;
        params.gravity = Gravity.START | Gravity.TOP;
        params.x = 0;
        params.y = 0;
        params.width = WindowManager.LayoutParams.MATCH_PARENT;
        params.height = WindowManager.LayoutParams.MATCH_PARENT;

        final TapTargetView tapTargetView = new TapTargetView(context, windowManager, null, target, listener);
        windowManager.addView(tapTargetView, params);

        return tapTargetView;
    }

8. 

public static class Listener {
        /** Signals that the user has clicked inside of the target **/
        public void onTargetClick(TapTargetView view) {
            view.dismiss(true);
        }

        /** Signals that the user has long clicked inside of the target **/
        public void onTargetLongClick(TapTargetView view) {
            onTargetClick(view);
        }

        /** If cancelable, signals that the user has clicked outside of the outer circle **/
        public void onTargetCancel(TapTargetView view) {
            view.dismiss(false);
        }

        /** Signals that the user clicked on the outer circle portion of the tap target **/
        public void onOuterCircleClick(TapTargetView view) {
            // no-op as default
        }

        /**
         * Signals that the tap target has been dismissed
         * @param userInitiated Whether the user caused this action
         *
         *
         */
        public void onTargetDismissed(TapTargetView view, boolean userInitiated) {
        }
    }

    final FloatValueAnimatorBuilder.UpdateListener expandContractUpdateListener = new FloatValueAnimatorBuilder.UpdateListener() {
        @Override
        public void onUpdate(float lerpTime) {
            final float newOuterCircleRadius = calculatedOuterCircleRadius * lerpTime;
            final boolean expanding = newOuterCircleRadius > outerCircleRadius;
            if (!expanding) {
                // When contracting we need to invalidate the old drawing bounds. Otherwise
                // you will see artifacts as the circle gets smaller
                calculateDrawingBounds();
            }

            final float targetAlpha = target.outerCircleAlpha * 255;
            outerCircleRadius = newOuterCircleRadius;
            outerCircleAlpha = (int) Math.min(targetAlpha, (lerpTime * 1.5f * targetAlpha));
            outerCirclePath.reset();
            outerCirclePath.addCircle(outerCircleCenter[0], outerCircleCenter[1], outerCircleRadius, Path.Direction.CW);

            targetCircleAlpha = (int) Math.min(255.0f, (lerpTime * 1.5f * 255.0f));

            if (expanding) {
                targetCircleRadius = TARGET_RADIUS * Math.min(1.0f, lerpTime * 1.5f);
            } else {
                targetCircleRadius = TARGET_RADIUS * lerpTime;
                targetCirclePulseRadius *= lerpTime;
            }

            textAlpha = (int) (delayedLerp(lerpTime, 0.7f) * 255);

            if (expanding) {
                calculateDrawingBounds();
            }

            invalidateViewAndOutline(drawingBounds);
        }
    };

    final ValueAnimator expandAnimation = new FloatValueAnimatorBuilder()
            .duration(250)
            .delayBy(250)
            .interpolator(new AccelerateDecelerateInterpolator())
            .onUpdate(new FloatValueAnimatorBuilder.UpdateListener() {
                @Override
                public void onUpdate(float lerpTime) {
                    expandContractUpdateListener.onUpdate(lerpTime);
                }
            })
            .onEnd(new FloatValueAnimatorBuilder.EndListener() {
                @Override
                public void onEnd() {
                    pulseAnimation.start();
                    isInteractable = true;
                }
            })
            .build();

    final ValueAnimator pulseAnimation = new FloatValueAnimatorBuilder()
            .duration(1000)
            .repeat(ValueAnimator.INFINITE)
            .interpolator(new AccelerateDecelerateInterpolator())
            .onUpdate(new FloatValueAnimatorBuilder.UpdateListener() {
                @Override
                public void onUpdate(float lerpTime) {
                    final float pulseLerp = delayedLerp(lerpTime, 0.5f);
                    targetCirclePulseRadius = (1.0f + pulseLerp) * TARGET_RADIUS;
                    targetCirclePulseAlpha = (int) ((1.0f - pulseLerp) * 255);
                    targetCircleRadius = TARGET_RADIUS + halfwayLerp(lerpTime) * TARGET_PULSE_RADIUS;

                    if (outerCircleRadius != calculatedOuterCircleRadius) {
                        outerCircleRadius = calculatedOuterCircleRadius;
                    }

                    calculateDrawingBounds();
                    invalidateViewAndOutline(drawingBounds);
                }
            })
            .build();

    final ValueAnimator dismissAnimation = new FloatValueAnimatorBuilder(true)
            .duration(250)
            .interpolator(new AccelerateDecelerateInterpolator())
            .onUpdate(new FloatValueAnimatorBuilder.UpdateListener() {
                @Override
                public void onUpdate(float lerpTime) {
                    expandContractUpdateListener.onUpdate(lerpTime);
                }
            })
            .onEnd(new FloatValueAnimatorBuilder.EndListener() {
                @Override
                public void onEnd() {
                    onDismiss(true);
                    ViewUtil.removeView(parent, TapTargetView.this);
                }
            })
            .build();

    private final ValueAnimator dismissConfirmAnimation = new FloatValueAnimatorBuilder()
            .duration(250)
            .interpolator(new AccelerateDecelerateInterpolator())
            .onUpdate(new FloatValueAnimatorBuilder.UpdateListener() {
                @Override
                public void onUpdate(float lerpTime) {
                    final float spedUpLerp = Math.min(1.0f, lerpTime * 2.0f);
                    outerCircleRadius = calculatedOuterCircleRadius * (1.0f + (spedUpLerp * 0.2f));
                    outerCircleAlpha = (int) ((1.0f - spedUpLerp) * target.outerCircleAlpha * 255.0f);
                    outerCirclePath.reset();
                    outerCirclePath.addCircle(outerCircleCenter[0], outerCircleCenter[1], outerCircleRadius, Path.Direction.CW);
                    targetCircleRadius = (1.0f - lerpTime) * TARGET_RADIUS;
                    targetCircleAlpha = (int) ((1.0f - lerpTime) * 255.0f);
                    targetCirclePulseRadius = (1.0f + lerpTime) * TARGET_RADIUS;
                    targetCirclePulseAlpha = (int) ((1.0f - lerpTime) * targetCirclePulseAlpha);
                    textAlpha = (int) ((1.0f - spedUpLerp) * 255.0f);
                    calculateDrawingBounds();
                    invalidateViewAndOutline(drawingBounds);
                }
            })
            .onEnd(new FloatValueAnimatorBuilder.EndListener() {
                @Override
                public void onEnd() {
                    onDismiss(true);
                    ViewUtil.removeView(parent, TapTargetView.this);
                }
            })
            .build();

    private ValueAnimator[] animators = new ValueAnimator[]
            {expandAnimation, pulseAnimation, dismissConfirmAnimation, dismissAnimation};

    private final ViewTreeObserver.OnGlobalLayoutListener globalLayoutListener;
    public TapTargetView(final Context context,
                         final ViewManager parent,
                          final ViewGroup boundingParent,
                         final TapTarget target,
                          final Listener userListener) {
        super(context);
        if (target == null) throw new IllegalArgumentException("Target cannot be null");

        this.target = target;
        this.parent = parent;
        this.boundingParent = boundingParent;
        this.listener = userListener != null ? userListener : new Listener();
        this.title = target.title;
        this.description = target.description;

        TARGET_PADDING = UiUtil.dp(context, 20);
        CIRCLE_PADDING = UiUtil.dp(context, 40);
        TARGET_RADIUS = UiUtil.dp(context, target.targetRadius);
        TEXT_PADDING = UiUtil.dp(context, 40);
        TEXT_SPACING = UiUtil.dp(context, 8);
        TEXT_MAX_WIDTH = UiUtil.dp(context, 360);
        TEXT_POSITIONING_BIAS = UiUtil.dp(context, 20);
        GUTTER_DIM = UiUtil.dp(context, 88);
        SHADOW_DIM = UiUtil.dp(context, 8);
        SHADOW_JITTER_DIM = UiUtil.dp(context, 1);
        TARGET_PULSE_RADIUS = (int) (0.1f * TARGET_RADIUS);

        outerCirclePath = new Path();
        targetBounds = new Rect();
        drawingBounds = new Rect();

        titlePaint = new TextPaint();
        titlePaint.setTextSize(target.titleTextSizePx(context));
        titlePaint.setTypeface(Typeface.create("sans-serif-medium", Typeface.NORMAL));
        titlePaint.setAntiAlias(true);

        descriptionPaint = new TextPaint();
        descriptionPaint.setTextSize(target.descriptionTextSizePx(context));
        descriptionPaint.setTypeface(Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL));
        descriptionPaint.setAntiAlias(true);
        descriptionPaint.setAlpha((int) (0.54f * 255.0f));

        outerCirclePaint = new Paint();
        outerCirclePaint.setAntiAlias(true);
        outerCirclePaint.setAlpha((int) (target.outerCircleAlpha * 255.0f));

        outerCircleShadowPaint = new Paint();
        outerCircleShadowPaint.setAntiAlias(true);
        outerCircleShadowPaint.setAlpha(50);
        outerCircleShadowPaint.setStyle(Paint.Style.STROKE);
        outerCircleShadowPaint.setStrokeWidth(SHADOW_JITTER_DIM);
        outerCircleShadowPaint.setColor(Color.BLACK);

        targetCirclePaint = new Paint();
        targetCirclePaint.setAntiAlias(true);

        targetCirclePulsePaint = new Paint();
        targetCirclePulsePaint.setAntiAlias(true);

        applyTargetOptions(context);

        globalLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                if (isDismissing) {
                    return;
                }
                updateTextLayouts();
                target.onReady(new Runnable() {
                    @Override
                    public void run() {
                        final int[] offset = new int[2];

                        targetBounds.set(target.bounds());

                        getLocationOnScreen(offset);
                        targetBounds.offset(-offset[0], -offset[1]);

                        if (boundingParent != null) {
                            final WindowManager windowManager
                                    = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
                            final DisplayMetrics displayMetrics = new DisplayMetrics();
                            windowManager.getDefaultDisplay().getMetrics(displayMetrics);

                            final Rect rect = new Rect();
                            boundingParent.getWindowVisibleDisplayFrame(rect);

                            // We bound the boundaries to be within the screen's coordinates to
                            // handle the case where the layout bounds do not match
                            // (like when FLAG_LAYOUT_NO_LIMITS is specified)
                            topBoundary = Math.max(0, rect.top);
                            bottomBoundary = Math.min(rect.bottom, displayMetrics.heightPixels);
                        }

                        drawTintedTarget();
                        requestFocus();
                        calculateDimensions();

                        startExpandAnimation();
                    }
                });
            }
        };

        getViewTreeObserver().addOnGlobalLayoutListener(globalLayoutListener);

        setFocusableInTouchMode(true);
        setClickable(true);
        setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                if (listener == null || outerCircleCenter == null || !isInteractable) return;

                final boolean clickedInTarget =
                        distance(targetBounds.centerX(), targetBounds.centerY(), (int) lastTouchX, (int) lastTouchY) <= targetCircleRadius;
                final double distanceToOuterCircleCenter = distance(outerCircleCenter[0], outerCircleCenter[1],
                        (int) lastTouchX, (int) lastTouchY);
                final boolean clickedInsideOfOuterCircle = distanceToOuterCircleCenter <= outerCircleRadius;

                if (clickedInTarget) {
                    isInteractable = false;
                    listener.onTargetClick(TapTargetView.this);
                } else if (clickedInsideOfOuterCircle) {
                    listener.onOuterCircleClick(TapTargetView.this);
                } else if (cancelable) {
                    isInteractable = false;
                    listener.onTargetCancel(TapTargetView.this);
                }
            }
        });

        setOnLongClickListener(new OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                if (listener == null) return false;

                if (targetBounds.contains((int) lastTouchX, (int) lastTouchY)) {
                    listener.onTargetLongClick(TapTargetView.this);
                    return true;
                }

                return false;
            }
        });
    }

    private void startExpandAnimation() {
        if (!visible) {
            isInteractable = false;
            expandAnimation.start();
            visible = true;
        }
    }

    protected void applyTargetOptions(Context context) {
        shouldTintTarget = target.tintTarget;
        shouldDrawShadow = target.drawShadow;
        cancelable = target.cancelable;

        // We can't clip out portions of a view outline, so if the user specified a transparent
        // target, we need to fallback to drawing a jittered shadow approximation
        if (shouldDrawShadow && Build.VERSION.SDK_INT >= 21 && !target.transparentTarget) {
            outlineProvider = new ViewOutlineProvider() {
                @Override
                public void getOutline(View view, Outline outline) {
                    if (outerCircleCenter == null) return;
                    outline.setOval(
                            (int) (outerCircleCenter[0] - outerCircleRadius), (int) (outerCircleCenter[1] - outerCircleRadius),
                            (int) (outerCircleCenter[0] + outerCircleRadius), (int) (outerCircleCenter[1] + outerCircleRadius));
                    outline.setAlpha(outerCircleAlpha / 255.0f);
                    if (Build.VERSION.SDK_INT >= 22) {
                        outline.offset(0, SHADOW_DIM);
                    }
                }
            };

            setOutlineProvider(outlineProvider);
            setElevation(SHADOW_DIM);
        }

        if (shouldDrawShadow && outlineProvider == null && Build.VERSION.SDK_INT < 18) {
            setLayerType(LAYER_TYPE_SOFTWARE, null);
        } else {
            setLayerType(LAYER_TYPE_HARDWARE, null);
        }

        final android.content.res.Resources.Theme theme = context.getTheme();
        isDark = UiUtil.themeIntAttr(context, "isLightTheme") == 0;

        final Integer outerCircleColor = target.outerCircleColorInt(context);
        if (outerCircleColor != null) {
            outerCirclePaint.setColor(outerCircleColor);
        } else if (theme != null) {
            outerCirclePaint.setColor(UiUtil.themeIntAttr(context, "colorPrimary"));
        } else {
            outerCirclePaint.setColor(Color.WHITE);
        }

        final Integer targetCircleColor = target.targetCircleColorInt(context);
        if (targetCircleColor != null) {
            targetCirclePaint.setColor(targetCircleColor);
        } else {
            targetCirclePaint.setColor(isDark ? Color.BLACK : Color.WHITE);
        }

        if (target.transparentTarget) {
            targetCirclePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
        }

        targetCirclePulsePaint.setColor(targetCirclePaint.getColor());

        final Integer targetDimColor = target.dimColorInt(context);
        if (targetDimColor != null) {
            dimColor = UiUtil.setAlpha(targetDimColor, 0.3f);
        } else {
            dimColor = -1;
        }

        final Integer titleTextColor = target.titleTextColorInt(context);
        if (titleTextColor != null) {
            titlePaint.setColor(titleTextColor);
        } else {
            titlePaint.setColor(isDark ? Color.BLACK : Color.WHITE);
        }

        final Integer descriptionTextColor = target.descriptionTextColorInt(context);
        if (descriptionTextColor != null) {
            descriptionPaint.setColor(descriptionTextColor);
        } else {
            descriptionPaint.setColor(titlePaint.getColor());
        }

        if (target.titleTypeface != null) {
            titlePaint.setTypeface(target.titleTypeface);
        }

        if (target.descriptionTypeface != null) {
            descriptionPaint.setTypeface(target.descriptionTypeface);
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        onDismiss(false);
    }

    void onDismiss(boolean userInitiated) {
        if (isDismissed) return;

        isDismissing = false;
        isDismissed = true;

        for (final ValueAnimator animator : animators) {
            animator.cancel();
            animator.removeAllUpdateListeners();
        }
        ViewUtil.removeOnGlobalLayoutListener(getViewTreeObserver(), globalLayoutListener);
        visible = false;

        if (listener != null) {
            listener.onTargetDismissed(this, userInitiated);
        }
    }

    @Override
    protected void onDraw(Canvas c) {
        if (isDismissed || outerCircleCenter == null) return;

        if (topBoundary > 0 && bottomBoundary > 0) {
            c.clipRect(0, topBoundary, getWidth(), bottomBoundary);
        }

        if (dimColor != -1) {
            c.drawColor(dimColor);
        }

        int saveCount;
        outerCirclePaint.setAlpha(outerCircleAlpha);
        if (shouldDrawShadow && outlineProvider == null) {
            saveCount = c.save();
            {
                c.clipPath(outerCirclePath, Region.Op.DIFFERENCE);
                drawJitteredShadow(c);
            }
            c.restoreToCount(saveCount);
        }
        c.drawCircle(outerCircleCenter[0], outerCircleCenter[1], outerCircleRadius, outerCirclePaint);

        targetCirclePaint.setAlpha(targetCircleAlpha);
        if (targetCirclePulseAlpha > 0) {
            targetCirclePulsePaint.setAlpha(targetCirclePulseAlpha);
            c.drawCircle(targetBounds.centerX(), targetBounds.centerY(),
                    targetCirclePulseRadius, targetCirclePulsePaint);
        }
        c.drawCircle(targetBounds.centerX(), targetBounds.centerY(),
                targetCircleRadius, targetCirclePaint);

        saveCount = c.save();
        {
            c.translate(textBounds.left, textBounds.top);
            titlePaint.setAlpha(textAlpha);
            if (titleLayout != null) {
                titleLayout.draw(c);
            }

            if (descriptionLayout != null && titleLayout != null) {
                c.translate(0, titleLayout.getHeight() + TEXT_SPACING);
                descriptionPaint.setAlpha((int) (target.descriptionTextAlpha * textAlpha));
                descriptionLayout.draw(c);
            }
        }
        c.restoreToCount(saveCount);

        saveCount = c.save();
        {
            if (tintedTarget != null) {
                c.translate(targetBounds.centerX() - tintedTarget.getWidth() / 2,
                        targetBounds.centerY() - tintedTarget.getHeight() / 2);
                c.drawBitmap(tintedTarget, 0, 0, targetCirclePaint);
            } else if (target.icon != null) {
                c.translate(targetBounds.centerX() - target.icon.getBounds().width() / 2,
                        targetBounds.centerY() - target.icon.getBounds().height() / 2);
                target.icon.setAlpha(targetCirclePaint.getAlpha());
                target.icon.draw(c);
            }
        }
        c.restoreToCount(saveCount);

        if (debug) {
            drawDebugInformation(c);
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent e) {
        lastTouchX = e.getX();
        lastTouchY = e.getY();
        return super.onTouchEvent(e);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (isVisible() && cancelable && keyCode == KeyEvent.KEYCODE_BACK) {
            event.startTracking();
            return true;
        }

        return false;
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        if (isVisible() && isInteractable && cancelable
                && keyCode == KeyEvent.KEYCODE_BACK && event.isTracking() && !event.isCanceled()) {
            isInteractable = false;

            if (listener != null) {
                listener.onTargetCancel(this);
            } else {
                new Listener().onTargetCancel(this);
            }

            return true;
        }

        return false;
    }

    /**
     * Dismiss this view
     * @param tappedTarget If the user tapped the target or not
     * (results in different dismiss animations)
     */
    public void dismiss(boolean tappedTarget) {
        isDismissing = true;
        pulseAnimation.cancel();
        expandAnimation.cancel();
        if (tappedTarget) {
            dismissConfirmAnimation.start();
        } else {
            dismissAnimation.start();
        }
    }

    /** Specify whether to draw a wireframe around the view, useful for debugging **/
    public void setDrawDebug(boolean status) {
        if (debug != status) {
            debug = status;
            postInvalidate();
        }
    }

    /** Returns whether this view is visible or not **/
    public boolean isVisible() {
        return !isDismissed && visible;
    }

    void drawJitteredShadow(Canvas c) {
        final float baseAlpha = 0.20f * outerCircleAlpha;
        outerCircleShadowPaint.setStyle(Paint.Style.FILL_AND_STROKE);
        outerCircleShadowPaint.setAlpha((int) baseAlpha);
        c.drawCircle(outerCircleCenter[0], outerCircleCenter[1] + SHADOW_DIM, outerCircleRadius, outerCircleShadowPaint);
        outerCircleShadowPaint.setStyle(Paint.Style.STROKE);
        final int numJitters = 7;
        for (int i = numJitters - 1; i > 0; --i) {
            outerCircleShadowPaint.setAlpha((int) ((i / (float) numJitters) * baseAlpha));
            c.drawCircle(outerCircleCenter[0], outerCircleCenter[1] + SHADOW_DIM ,
                    outerCircleRadius + (numJitters - i) * SHADOW_JITTER_DIM , outerCircleShadowPaint);
        }
    }

    void drawDebugInformation(Canvas c) {
        if (debugPaint == null) {
            debugPaint = new Paint();
            debugPaint.setARGB(255, 255, 0, 0);
            debugPaint.setStyle(Paint.Style.STROKE);
            debugPaint.setStrokeWidth(UiUtil.dp(getContext(), 1));
        }

        if (debugTextPaint == null) {
            debugTextPaint = new TextPaint();
            debugTextPaint.setColor(0xFFFF0000);
            debugTextPaint.setTextSize(UiUtil.sp(getContext(), 16));
        }

        // Draw wireframe
        debugPaint.setStyle(Paint.Style.STROKE);
        c.drawRect(textBounds, debugPaint);
        c.drawRect(targetBounds, debugPaint);
        c.drawCircle(outerCircleCenter[0], outerCircleCenter[1], 10, debugPaint);
        c.drawCircle(outerCircleCenter[0], outerCircleCenter[1], calculatedOuterCircleRadius - CIRCLE_PADDING, debugPaint);
        c.drawCircle(targetBounds.centerX(), targetBounds.centerY(), TARGET_RADIUS + TARGET_PADDING, debugPaint);

        // Draw positions and dimensions
        debugPaint.setStyle(Paint.Style.FILL);
        final String debugText =
                "Text bounds: " + textBounds.toShortString() + "\n" + "Target bounds: " + targetBounds.toShortString() + "\n" + "Center: " + outerCircleCenter[0] + " " + outerCircleCenter[1] + "\n" + "View size: " + getWidth() + " " + getHeight() + "\n" + "Target bounds: " + targetBounds.toShortString();

        if (debugStringBuilder == null) {
            debugStringBuilder = new SpannableStringBuilder(debugText);
        } else {
            debugStringBuilder.clear();
            debugStringBuilder.append(debugText);
        }

        if (debugLayout == null) {
            debugLayout = new DynamicLayout(debugText, debugTextPaint, getWidth(), Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);
        }

        final int saveCount = c.save();
        {
            debugPaint.setARGB(220, 0, 0, 0);
            c.translate(0.0f, topBoundary);
            c.drawRect(0.0f, 0.0f, debugLayout.getWidth(), debugLayout.getHeight(), debugPaint);
            debugPaint.setARGB(255, 255, 0, 0);
            debugLayout.draw(c);
        }
        c.restoreToCount(saveCount);
    }

    void drawTintedTarget() {
        final android.graphics.drawable.Drawable icon = target.icon;
        if (!shouldTintTarget || icon == null) {
            tintedTarget = null;
            return;
        }

        if (tintedTarget != null) return;

        tintedTarget = Bitmap.createBitmap(icon.getIntrinsicWidth(), icon.getIntrinsicHeight(),
                Bitmap.Config.ARGB_8888);
        final Canvas canvas = new Canvas(tintedTarget);
        icon.setColorFilter(new PorterDuffColorFilter(
                outerCirclePaint.getColor(), PorterDuff.Mode.SRC_ATOP));
        icon.draw(canvas);
        icon.setColorFilter(null);
    }

    void updateTextLayouts() {
        final int textWidth = Math.min(getWidth(), TEXT_MAX_WIDTH) - TEXT_PADDING * 2;
        if (textWidth <= 0) {
            return;
        }

        titleLayout = new StaticLayout(title, titlePaint, textWidth,
                Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);

        if (description != null) {
            descriptionLayout = new StaticLayout(description, descriptionPaint, textWidth,
                    Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);
        } else {
            descriptionLayout = null;
        }
    }

    float halfwayLerp(float lerp) {
        if (lerp < 0.5f) {
            return lerp / 0.5f;
        }

        return (1.0f - lerp) / 0.5f;
    }

    float delayedLerp(float lerp, float threshold) {
        if (lerp < threshold) {
            return 0.0f;
        }

        return (lerp - threshold) / (1.0f - threshold);
    }

    void calculateDimensions() {
        textBounds = getTextBounds();
        outerCircleCenter = getOuterCircleCenterPoint();
        calculatedOuterCircleRadius = getOuterCircleRadius(outerCircleCenter[0], outerCircleCenter[1], textBounds, targetBounds);
    }

    void calculateDrawingBounds() {
        if (outerCircleCenter == null) {
            // Called dismiss before we got a chance to display the tap target
            // So we have no center -> cant determine the drawing bounds
            return;
        }
        drawingBounds.left = (int) Math.max(0, outerCircleCenter[0] - outerCircleRadius);
        drawingBounds.top = (int) Math.min(0, outerCircleCenter[1] - outerCircleRadius);
        drawingBounds.right = (int) Math.min(getWidth(),
                outerCircleCenter[0] + outerCircleRadius + CIRCLE_PADDING);
        drawingBounds.bottom = (int) Math.min(getHeight(),
                outerCircleCenter[1] + outerCircleRadius + CIRCLE_PADDING);
    }

    int getOuterCircleRadius(int centerX, int centerY, Rect textBounds, Rect targetBounds) {
        final int targetCenterX = targetBounds.centerX();
        final int targetCenterY = targetBounds.centerY();
        final int expandedRadius = (int) (1.1f * TARGET_RADIUS);
        final Rect expandedBounds = new Rect(targetCenterX, targetCenterY, targetCenterX, targetCenterY);
        expandedBounds.inset(-expandedRadius, -expandedRadius);

        final int textRadius = maxDistanceToPoints(centerX, centerY, textBounds);
        final int targetRadius = maxDistanceToPoints(centerX, centerY, expandedBounds);
        return Math.max(textRadius, targetRadius) + CIRCLE_PADDING;
    }

    Rect getTextBounds() {
        final int totalTextHeight = getTotalTextHeight();
        final int totalTextWidth = getTotalTextWidth();

        final int possibleTop = targetBounds.centerY() - TARGET_RADIUS - TARGET_PADDING - totalTextHeight;
        final int top;
        if (possibleTop > topBoundary) {
            top = possibleTop;
        } else {
            top = targetBounds.centerY() + TARGET_RADIUS + TARGET_PADDING;
        }

        final int relativeCenterDistance = (getWidth() / 2) - targetBounds.centerX();
        final int bias = relativeCenterDistance < 0 ? -TEXT_POSITIONING_BIAS : TEXT_POSITIONING_BIAS;
        final int left = Math.max(TEXT_PADDING, targetBounds.centerX() - bias - totalTextWidth);
        final int right = Math.min(getWidth() - TEXT_PADDING, left + totalTextWidth);
        return new Rect(left, top, right, top + totalTextHeight);
    }

    int[] getOuterCircleCenterPoint() {
        if (inGutter(targetBounds.centerY())) {
            return new int[]{targetBounds.centerX(), targetBounds.centerY()};
        }

        final int targetRadius = Math.max(targetBounds.width(), targetBounds.height()) / 2 + TARGET_PADDING;
        final int totalTextHeight = getTotalTextHeight();

        final boolean onTop = targetBounds.centerY() - TARGET_RADIUS - TARGET_PADDING - totalTextHeight > 0;

        final int left = Math.min(textBounds.left, targetBounds.left - targetRadius);
        final int right = Math.max(textBounds.right, targetBounds.right + targetRadius);
        final int titleHeight = titleLayout == null ? 0 : titleLayout.getHeight();
        final int centerY = onTop ?
                targetBounds.centerY() - TARGET_RADIUS - TARGET_PADDING - totalTextHeight + titleHeight
                :
                targetBounds.centerY() + TARGET_RADIUS + TARGET_PADDING + titleHeight;

        return new int[] { (left + right) / 2, centerY };
    }

    int getTotalTextHeight() {
        if (titleLayout == null) {
            return 0;
        }

        if (descriptionLayout == null) {
            return titleLayout.getHeight() + TEXT_SPACING;
        }

        return titleLayout.getHeight() + descriptionLayout.getHeight() + TEXT_SPACING;
    }

    int getTotalTextWidth() {
        if (titleLayout == null) {
            return 0;
        }

        if (descriptionLayout == null) {
            return titleLayout.getWidth();
        }

        return Math.max(titleLayout.getWidth(), descriptionLayout.getWidth());
    }
    boolean inGutter(int y) {
        if (bottomBoundary > 0) {
            return y < GUTTER_DIM || y > bottomBoundary - GUTTER_DIM;
        } else {
            return y < GUTTER_DIM || y > getHeight() - GUTTER_DIM;
        }
    }
    int maxDistanceToPoints(int x1, int y1, Rect bounds) {
        final double tl = distance(x1, y1, bounds.left, bounds.top);
        final double tr = distance(x1, y1, bounds.right, bounds.top);
        final double bl = distance(x1, y1, bounds.left, bounds.bottom);
        final double br = distance(x1, y1, bounds.right, bounds.bottom);
        return (int) Math.max(tl, Math.max(tr, Math.max(bl, br)));
    }
    double distance(int x1, int y1, int x2, int y2) {
        return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
    }
    void invalidateViewAndOutline(Rect bounds) {
        invalidate(bounds);
        if (outlineProvider != null && Build.VERSION.SDK_INT >= 21) {
            invalidateOutline();
        }
    }
}

9.

static class ViewUtil {

    ViewUtil() {}

    private static boolean isLaidOut(View view) {
        return true;
    }
    static void onLaidOut(final View view, final Runnable runnable) {
        if (isLaidOut(view)) {
            runnable.run();
            return;
        }
        final ViewTreeObserver observer = view.getViewTreeObserver();
        observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                final ViewTreeObserver trueObserver;
                if (observer.isAlive()) {
                    trueObserver = observer;
                } else {
                    trueObserver = view.getViewTreeObserver();
                }
                removeOnGlobalLayoutListener(trueObserver, this);
                runnable.run();
            }
        });
    }
    @SuppressWarnings("deprecation")
    static void removeOnGlobalLayoutListener(ViewTreeObserver observer,
                                             ViewTreeObserver.OnGlobalLayoutListener listener) {
        if (Build.VERSION.SDK_INT >= 16) {
            observer.removeOnGlobalLayoutListener(listener);
        } else {
            observer.removeGlobalOnLayoutListener(listener);
        }
    }
    static void removeView(ViewManager parent, View child) {
        if (parent == null || child == null) {
            return;
        }
        try {
            parent.removeView(child);
        } catch (Exception ignored) {
        }
    }
}

static class ViewTapTarget extends TapTarget {
    final View view;

    ViewTapTarget(View view, CharSequence title, CharSequence description) {
        super(title, description);
        if (view == null) {
            throw new IllegalArgumentException("Given null view to target");
        }
        this.view = view;
    }

    @Override
    public void onReady(final Runnable runnable) {
        ViewUtil.onLaidOut(view, new Runnable() {
            @Override
            public void run() {
                // Cache bounds
                final int[] location = new int[2];
                view.getLocationOnScreen(location);
                bounds = new Rect(location[0], location[1],
                        location[0] + view.getWidth(), location[1] + view.getHeight());

                if (icon == null && view.getWidth() > 0 && view.getHeight() > 0) {
                    final Bitmap viewBitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
                    final Canvas canvas = new Canvas(viewBitmap);
                    view.draw(canvas);
                    icon = new android.graphics.drawable.BitmapDrawable(view.getContext().getResources(), viewBitmap);
                    icon.setBounds(0, 0, icon.getIntrinsicWidth(), icon.getIntrinsicHeight());
                }

                runnable.run();
            }
        });
    }

Note.. jaisa mere dwara bataya gaya code ko copy karna koi bhi word kahi bhi change nahi kara hai.

Ab aapko componet mein jake 2 aur icone add karne se jiski madat se aap apna Timer laga sakte hai.

Ek baar phir se Oncreate par jake code ko add karna hai jaisa ki mere dwara dikhaya gaya hai aur kisi bhi word ko mistek na kare.

Ab aap apne smartphone mein jake chech kar sakte hai ki aap ka coding huya butten kam kar raha hai ya nahi..