Latest Posts

Thursday, July 29, 2021

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 เค•เคฐเค•े เคšेเค• เค•เคฐ เคธเค•เคคे เคนो।


Monday, July 12, 2021

เค…เคฌ เค”เคฐ เคญी เคญเคฏाเคจเค• เคชเคก เคธเค•เคคा เคนै เคชोเคฐ्เคจ เคตीเคกिเคฏो เคฆेเค–เคจा -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 เค•เคฐเคจा เคจा เคญूเคฒे।

Saturday, June 12, 2021

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 เคฎें เคฌเคนुเคค เคนै เคฎเคฆเคฆ เค—ाเคฐ เคธाเคฌिเคค เคนोเค—ा ।

Wednesday, April 21, 2021

เค†เคตाเคธ เคตिเค•ाเคธ เคฏोเคœเคจा 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 เคฎें เคœเคฐूเคฐ เคฌเคคाเคं 

Sunday, March 28, 2021

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 เคฎिเคฒ เคœाเคฏेเค—ा 

Wednesday, March 10, 2021

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 เคนोเคจे เคฒเค—ेเค—ा ।

Saturday, February 13, 2021

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..