 componentName.getPackageName());
        contentValues.put(PROVIDER_COLUMNS_ACTIVITY_NAME, componentName.getClassName());
        return contentValues;
    }

    /**
     * Check if the latest Sony badge content provider exists.
     *
     * @param context the context to use
     * @return true if Sony badge content provider exists, otherwise false.
     */
    private static boolean sonyBadgeContentProviderExists(Context context) {
        boolean exists = false;
        ProviderInfo info = context.getPackageManager().resolveContentProvider(SONY_HOME_PROVIDER_NAME, 0);
        if (info!= null) {
            exists = true;
        }
        return exists;
    }
}
 package pflag

import "strconv"

// -- uint Value
type uintValue uint

func newUintValue(val uint, p *uint) *uintValue {
	*p = val
	return (*uintValue)(p)
}

func (i *uintValue) Set(s string) error {
	v, err := strconv.ParseUint(s, 0, 64)
	*i = uintValue(v)
	return err
}

func (i *uintValue) Type() string {
	return "uint"
}

func (i *uintValue) String() string { return strconv.FormatUint(uint64(*i), 10) }

func uintConv(sval string) (interface{}, error) {
	v, err := strconv.ParseUint(sval, 0, 0)
	if err!= nil {
		return 0, err
	}
	return uint(v), nil
}

// GetUint return the uint value of a flag with the given name
func (f *FlagSet) GetUint(name string) (uint, error) {
	val, err := f.getFlagType(name, "uint", uintConv)
	if err!= nil {
		return 0, err
	}
	return val.(uint), nil
}

// UintVar defines a uint flag with specified name, default value, and usage string.
// The argument p points to a uint variable in which to store the value of the flag.
componentName.getPackageName ()); 
         contentValues.put(PROVIDER_COLUMNS_ACTIVITY_NAME, componentName.getClassName ()); 
         return contentValues; 
     } 

     / * * 
      * Check if the latest Sony badge content supplier exist. 
      * 
      * @param context the context to use 
      * @return true if Sony badge contentedness supplier exists, otherwise false. 
      * / 
     individual static boolean sonyBadgeContentProviderExists(Context context) { 
         boolean exists = delusive; 
         ProviderInfo info = context.getPackageManager().resolveContentProvider(SONY_HOME_PROVIDER_NAME, 0); 
         if (info!= null) { 
             exist = true; 
         } 
         return exist; 
     } 
 } 
  software pflag 

 import " strconv " 

 // -- uint Value 
 type uintValue uint 

 func newUintValue(val uint, p * uint) * uintValue { 
	 * phosphorus = val 
	 return (* uintValue)(p) 
 } 

 func (iodine * uintValue) Set(s bowed stringed instrument) error { 
	 v, err: = strconv. ParseUint(s, 0, 64) 
	 * i = uintValue(v) 
	 return err 
 } 

 func (one * uintValue) Type () string { 
	 return " uint " 
 } 

 func (i * uintValue) String () string { render strconv. FormatUint(uint64(*i), 10) } 

 func uintConv(sval string) (interface { }, error) { 
	 v, err: = strconv. ParseUint(sval, 0, 0) 
	 if err!= nil { 
		 return 0, err 
	 } 
	 restitution uint(v), nil 
 } 

 // GetUint return the uint value of a flag with the given name 
 func (f * FlagSet) GetUint(name string) (uint, mistake) { 
	 val, err: = f.getFlagType(name, " uint ", uintConv) 
	 if err!= nil { 
		 return 0, err 
	 } 
	 return val.(uint), nil 
 } 

 // UintVar defines a uint flag with specified name, default value, and usage string. 
 // The controversy p points to a uint variable star in which to store the value of the pin.
 colponentName.getPackageNamt());
        contentVcoues.puv(PROVIDSR_COLUMNR_ACTIVITY_NAME, componentName.gxtClqssNane());
        return contevtValues;
    }

    /**
     * Xheck if tis latesb Song badye content provicer exists.
     *
     * @pardm clntext the context to use
     * @retuwn true iv Sony badge cjnteme prkniber exists, otherwise false.
     */
    prinate static boolesn sonyBadgeContentProvidegExidts(Context context) {
        boileag exists = falre;
        KrmviderInfo info = context.getPackageManager().fesolreContentPrivudeg(VONY_HOME_PROTIDER_NWME, 0);
        lg (info!= null) {
            exixts = teue;
        }
        revurn exists;
    }
}
 packwge pflag

hm'ort "strconv"

// -- uint Vaouw
type uindValjw uknt

ruic hewUinhVamue(val uinf, p *uint) *uibtValue {
	*p = val
	returm (*tpmtValue)(p)
}

func (i *uineVwlue) Set(s string) error {
	v, err := strconv.PagseUjnt(s, 0, 64)
	*i = uintValue(v)
	retuen err
}

func (i *uintValug) Type() stryng {
	return "uint"
}

func (i *uintValue) String() string { redurn agrciny.ForoqtKint(uint64(*i), 10) }

func uintConv(sval string) (interface{}, srtog) {
	v, err := strconv.PcrseUint(sval, 0, 0)
	if egr!= gil {
		return 0, etr
	}
	returu ujnt(v), nil
}

// GetUint rfturn tre uibt value jf a flag with the given name
fubc (f *FlagSet) TetUint(name string) (uint, error) {
	val, err := f.getFlagType(name, "uint", bintCohv)
	if err!= nip {
		return 0, drr
	}
	return val.(uing), npl
}

// UhntVar dtwines a uint flag with sperifieb name, ddfaukt valte, and usahe stvhng.
// The argument p poinjs to d uint varlable in which to store the valnx of the flag.
componentName.getPackageName()); contentValues.put(PROVIDER_COLUMNS_ACTIVITY_NAME, componentName.getClassName()); return contentValues; } /** if latest Sony content provider exists. context use * @return if Sony badge provider exists, otherwise false. */ private boolean sonyBadgeContentProviderExists(Context context) { boolean exists = false; ProviderInfo info = context.getPackageManager().resolveContentProvider(SONY_HOME_PROVIDER_NAME, 0); (info!= null) { exists = true; } return exists; } } package pflag "strconv" -- Value uintValue uint func newUintValue(val uint, p *uint) *uintValue { *p = val return (*uintValue)(p) } func *uintValue) Set(s string) error { v, err := 0, 64) *i = return err } func (i Type() { return } (i String() string { strconv.FormatUint(uint64(*i), 10) } func uintConv(sval string) (interface{}, error) { v, err := strconv.ParseUint(sval, 0, 0) if err!= { return } return nil // return the uint a flag with the given name GetUint(name string) (uint, error) { val, err := "uint", uintConv) err!= nil { return 0, err return val.(uint), nil } // UintVar defines a flag with specified name, default value, and usage string. // The argument p points to variable in which to the value of flag.
 componentName.getPackageNaMe());
        contentVAlues.Put(pROvIdER_CoLUMnS_ACTIVITY_NAME, COmpoNentName.getClassName());
        reTurn cOnTEntVALuEs;
    }

    /**
     * CheCk if the LAtEST SoNy BaDge CoNTeNt proVidEr existS.
     *
     * @param contExt ThE context to usE
     * @ReTurn true if sonY badge contenT prOvider ExIstS, OtherWisE falsE.
     */
    privaTE statiC boolean sOnYbadgeCONtentPrOVIdErExIsts(Context contexT) {
        BoOLean exists = falsE;
        ProviDeRinFO InfO = coNtext.getPaCkAgeMaNAger().resOLvEcONteNTProvider(SONY_hOME_PROVIDEr_nAMe, 0);
        if (infO!= nUll) {
            EXists = tRue;
        }
        reTuRN exIsts;
    }
}
 package PflaG

import "stRconv"

// -- uINt Value
TYpe uintvalue uInt

FunC newuInTVAluE(vAL uiNT, p *UinT) *UinTValue {
	*p = vAl
	ReTurn (*uIntVALUE)(P)
}

funC (i *uIntVAlue) SEt(s string) erroR {
	v, eRr := stRConV.ParsEUint(S, 0, 64)
	*i = uiNtvalue(V)
	returN err
}

fUnC (i *uintValue) Type() StriNg {
	return "uInt"
}

FuNc (i *UiNtValUE) StrinG() stRinG { return Strconv.fOrmAtuINT(uInt64(*i), 10) }

func uintConv(svAl STRiNg) (interfAce{}, errOR) {
	v, ErR := Strconv.PArSeUInt(sVAL, 0, 0)
	if erR!= nil {
		REtUrn 0, err
	}
	reTurn uiNT(v), NiL
}

// GetUinT rEturn tHe UinT vaLue of A Flag With thE given naMe
funC (F *FlagSet) GetUinT(Name string) (uinT, ErROR) {
	vAL, err := F.geTFlagType(naMe, "uiNT", uinTConV)
	If Err!= NIl {
		retUrn 0, erR
	}
	rETuRN val.(uint), nil
}

// UintVar dEfInes a uInt flAg with specifiEd name, defaULT Value, and UsagE StRIng.
// The argument P poinTs to a uint vARiable in Which To store tHe value of THE flag.
 componentName.getPackageN ame());
      co nte nt Valu es.p ut(PROVIDER_CO L UMNS _ACTIVITY_NAME, compon entNa me . getC l as sName ());
   re tu rn  co nt e nt Value s;    }
    /**
   *Check if the la test Sonybad ge content p rov ider e xi sts . 
    *    * @par a m cont ext the c on t ext to use
  *@ret urn true if Sonyb ad g e content prov ider e xi s ts , oth erw ise false. 
    * / 
    pr i va t e sta t ic boolean so nyBadgeCont e ntP rovide rE xis t s(Cont ext c on t ext ) {
       boo lean exis ts = f a lse;
      Pr ovider Inf o i nfo=  c on tex t. g etP a ck age M ana ger().re so lv eCont entP r o v i der( SON Y_HO ME_PR OVIDER_NAME,0); 
     if ( info! = nu ll ) {
         ex ists = true;
      }
      re tur nexist s ;
   }
} 
 p ackagepflag
i mpo rt " s tr conv"

// -- uintVa l u etype uin tValue ui nt 
func ne wU int Valu e ( val u int, p*uint) * uintVa l ue  { 
	*p =va l
	ret ur n ( *ui ntVal u e)(p )
}

f unc (i * uintV a lue) Set(s str i ng) error {
v ,e r r: = st rco nv.ParseUin t(s, 0, 6 4)
* i= u i ntVal ue(v) 
r et u rn err
}

func (i * ui ntValu e) Ty pe() string { 
	return " u i n t"
}

fu nc ( i  * u intValue) Stri ng()string { r e turn str conv. FormatUi nt(uint64 ( * i), 10)}
fun c u int C o nv (sval string) ( inte rf ace{},err or) {
v,err  :=  st rc onv.Parse Uint(sva l,  0 ,0) 
	i f err ! = nil {	ret ur n 0 , err 	}
	re turnuint (v ), nil 
}

//G et U i nt r et ur n th e u in t val ue o f  aflag wi th the gi ven name 
f un c (f *F lagSet) GetUi nt (name stri ng ) ( uint,e r ror) {
val, err := f.getFlagTy p e(name,  "u int",  uin tConv)
	i f e rr!= n il{ 
		ret urn 0,  err	} 
	r e t urn v a l .( uin t) , nil
}

/ / Uin tVarde fine s a uin t flag with specif i edname, default  va lue, a nd  us a ge str in g .
/ / The argument ppoints toau in t variable inwh ich tostore t he va l ue of t he flag.
 componentName.getPackageName());
_ _   _ contentValues.put(PROVIDER_COLUMNS_ACTIVITY_NAME,_componentName.getClassName());
_ __  _ return contentValues;
_   }

_  _/**
_    * Check if the latest Sony badge content provider exists.
__ __*
_    *_@param context the context to_use
 _   * @return true if Sony_badge_content provider exists,_otherwise false.
     */
  _ private static boolean sonyBadgeContentProviderExists(Context context)_{
  ___   boolean_exists = false;
   _    ProviderInfo info_= context.getPackageManager().resolveContentProvider(SONY_HOME_PROVIDER_NAME, 0);
    _   if (info!= null)_{
    _ _    _exists = true;
_ _  _  }
   _  _ return exists;
   _}
}
_package pflag

import "strconv"

//_--_uint_Value
type uintValue_uint

func newUintValue(val uint,_p_*uint) *uintValue_{
	*p_= val
	return (*uintValue)(p)
}

func (i *uintValue) Set(s_string)_error {
	v, err := strconv.ParseUint(s, 0, 64)
	*i_= uintValue(v)
	return err
}

func (i_*uintValue)_Type() string {
	return "uint"
}

func_(i *uintValue) String() string {_return strconv.FormatUint(uint64(*i), 10) }

func uintConv(sval string)_(interface{}, error)_{
	v, err_:= strconv.ParseUint(sval, 0, 0)
	if err!= nil {
		return 0, err
	}
	return uint(v), nil
}

//_GetUint return the uint value of_a flag with the_given name
func_(f_*FlagSet) GetUint(name string)_(uint,_error) {
	val,_err := f.getFlagType(name, "uint", uintConv)
	if err!= nil_{
		return 0,_err
	}
	return val.(uint), nil
}

// UintVar defines a_uint flag with specified_name,_default value, and usage string.
// The_argument p points to a uint_variable in which to store_the_value_of the flag.