export PS1='\[\033[1;32m\]\u\[\033[0;37m\]@\[\033[1;31m\]\h \[\033[01;34m\]\W $\[\033[00m\] '

command line 명령어	내 용
vi file	vi를 시작하여 지정한 파일 편집
vi -r file	읽기 전용(read- only) 편집기로서 vi를 시작하여 지정한 파일 편집
view file	읽기 전용(read- only) 편집기로서 vi를 시작하여 지정한 파일 편집
vi -r	되살릴 수 있는 모든 파일 이름 보여주기
vi -r file	vi를 시작하여 지정한 파일 되살리기

편 집 명 령	내 용
i	입력 모드로 전환, 커서 위치 앞에서 삽입
a	입력 모드로 전환, 커서 위치 뒤에서 삽입
I	입력 모드로 전환, 현재 줄의 앞에 삽입
A	입력 모드로 전환, 현재 줄의 끝에 삽입
o	입력 모드로 전환, 현재 줄의 아래에 전개
O	입력 모드로 전환, 현재 줄의 위에 전개
:e file	지정한 파일의 편집
:e! file	지정한 파일의 편집, 자동 점검의 생략
r	단지 한 글자만 변경(입력 모드로 바뀌지 않음)
R	입력하는 대로 겹쳐 써서 변경
s	삽입에 의해 한 단어의 변경
C	커서의 위치로부터 줄 끝까지 삽입에 의한 변경
cc	전체 줄을 삽입에 의한 변경
S	전체 줄을 삽입에 의한 변경
cmove	커서부터 move까지 삽입에 의해 변경
~	대,소문자 바꾸기
u	편집 버퍼를 수정했던 마지막 명령을 취소
U	현재 줄을 저장
.	편집 버퍼를 수정했던 마지막 명령 반복
x	커서가 있는 문자 삭제
X	커서의 왼쪽 문자 삭제
D	커서부터 줄의 끝까지 삭제
dd	현재 줄의 전체 삭제
dmove	커서부터 move까지 삭제
dG	커서부터 편집 버퍼의 끝까지 삭제
d1G	커서부터 편집 버퍼의 맨 앞까지 삭제
:<line>d	지정한 줄의 삭제
:<line>,<line>d	지정한 범위의 삭제
:<line>co<target>	지정한 줄을 복사하여 target 줄 밑에 삽입
:<line>, <line>co<target>	지정한 범위를 복사하여 target 줄 밑에 삽입
:<line>m<target?	지정한 줄로 이동하여 target 줄 밑에 삽입
:<line>, <line>m<target>	지정한 범위로 이동하여target 줄 밑에 삽입
<n>!!command	n번 줄에서 command의 실행
!move command	커서부터 move까지 command 실행
!move fmt	커서부터 move까지 줄들을 형식 맞추기
:w	원래의 파일로 데이터를 저장
:w file	지정한 파일로 데이터를 저장
:w>> file	지정한 파일에 데이터를 추가
:wq	데이터를 저장하고 종료
:q!	데이터를 저장하지 않고 종료
:set number	내부 줄 번호 디스플레이
:set nonumber	내부 줄 번호 디스플레이 않기
p	마지막으로 지워진 것을 커서의 뒤/아래에 삽입
P	마지막으로 지워진 것을 커서의 앞/위에 삽입
xp	두 문자를 바꿈
deep	두 단어를 바꿈
ddp	두 줄을 바꿈
/rexp	지정된 정규 표현식에 대해 앞으로 이동
/	이전의 패턴에 대해 앞으로 검색을 반복
?rexp	지정된 정규 표현식에 대해 뒤로 이동
?	이전의 패턴에 대해 뒤로 검색을 반복
n	/나 ?명령에 대해 같은 방향으로 반복
N	/나 ?명령에 대해 반대 방향으로 반복
:ab short long	short를 long에 대한 약어로 변경
:ab	현재 약어 목록을 표시
:una short	약어 short를 표시
r<Return>	문자를 뉴라인으로 변경
J	아래 line을 현재 line과 합치기
:set wm=n	오른쪽으로 n문자 위치에서 자동적으로 줄 나눔
h or <Left key>	커서를 한 칸 왼쪽으로 이동
j or <Down key>	커서를 한 줄 아래로 이동
k or <Up key>	커서를 한 줄 위로 이동
l or <Right key>	커서를 한 칸 오른쪽으로 이동
<Backspace>	커서를 한 칸 왼쪽으로 이동
<Space>	커서를 한 칸 오른쪽으로 이동
-	커서를 이전 줄의 처음으로 이동
+	커서를 다음 줄의 처음으로 이동
<Return>	커서를 다음 줄의 처음으로 이동
0	커서를 현재 줄의 맨 앞으로 이동
$	커서를 현재 줄의 맨 끝으로 이동
^	커서를 현재 줄의 첫글자(공백이나 탭이 아닌)로 이동
w	커서를 다음 단어의 첫 글자로 이동
e	커서를 다음 단어의 끝 글자로 이동
b	커서를 이전 단어의 첫 글자로 이동
W	w와 같음(문장 부호 무시)
E	e와 같음(문장 부호 무시)
B	b와 같음(문장 부호 무시)
(	다음 문장의 처음으로 이동
)	이전 문장의 처음으로 이동
{	다음 문단의 처음으로 이동
}	이전 문단의 처음으로 이동
H	커서를 화면 맨 위로 이동
M	커서를 중간으로 이동
L	커서를 맨 아래로 이동
^f	한 화면 아래로 이동
^b	화면 위로 이동
^d	반 화면 아래로 이동
^u	반 화면 위로 이동
n^d	n줄만큼 아래로 이동
n^u	n줄만큼 위로 이동
:!command	vi를 중단하고 지정한 셸 명령을 실행
:!!	vi를 중단하고 이전의 셸 명령을 실행
:sh	vi를 중단하고 셸을 실행
:!csh	vi를 중단하고 새로운 C-셸을 실행
:s/<pattern>/<replace>/	현재 줄의 치환
:<line>s/<pattern>/<replace>/	지정한 줄의 치환
:<line>,<line>s/<pattern>/<replace>/	정한 범위의 치환
:%s/<pattern>/<replace>/	모든 줄의 치환
:<line>r file	file의 내용을 지정한 줄 다음에 삽입
:r file	file의 내용을 현재의 줄 다음에 삽입
:<line>r !command	command의 결과를 지정한 줄 다음에 삽입
:r !command	command의 결과를 현재의 줄 다음에 삽입
:r !look pattern	지정한 pattern으로 시작된 단어 삽입
.	뉴라인을 제외한 모든 단일 문자와 대응
*	영 또는 그 이상의 선행 문자와 대응
^	줄의 시작과 대응
$	줄의 끝과 대응
\<	단어의 시작과 대응
\>	단어의 끝과 대응
[ ]	묶여진 문자중의 하나와 대응
[^ ]	묶여진 문자를 제외한 아무것하고나 대응
\	이어지는 기호를 문자 그대로 해석
<n>G	줄번호 n으로 건너뛰기
1G	편집 버퍼의 첫 줄로 건너뛰기
G	편집 버퍼의 마지막 줄로 건너뛰기
:map g lG	g가 lG와 같도록 매크로 정의

From Wikipedia, the free encyclopedia

This article needs additional citations for verification. Please help improve this article by adding reliable references. Unsourced material may be challenged and removed. (March 2009)

Network switching subsystem (NSS) is the component of a GSM system that carries out switching functions and manages the communications between mobile phones and the Public Switched Telephone Network (PSTN). It is owned and deployed by mobile phone operators and allows mobile phones to communicate with each other and telephones in the wider telecommunications network. The architecture closely resembles a telephone exchange, but there are additional functions which are needed because the phones are not fixed in one location. Each of these functions handle different aspects of mobility management and are described in more detail below.

The Network Switching Subsystem, also referred to as the GSM core network, usually refers to the circuit-switched core network, used for traditional GSM services such as voice calls, SMS, and circuit switched data calls.

There is also an overlay architecture on the GSM core network to provide packet-switched data services and is known as the GPRS core network. This allows mobile phones to have access to services such as WAP, MMS, and Internet access.

All mobile phones manufactured today have both circuit and packet based services, so most operators have a GPRS network in addition to the standard GSM core network.

Contents [hide] 1 Mobile switching center (MSC) 1.1 Description 1.2 Mobile switching centre server (MSCS) 1.3 Other GSM core network elements connected to the MSC 1.4 Procedures implemented 2 Home location register (HLR) 2.1 Other GSM core network elements connected to the HLR 2.2 Procedures implemented 3 Authentication centre (AUC) 3.1 Description 3.2 Other GSM core network elements connected to the AUC 3.3 Procedures implemented 4 Visitor location register (VLR) 4.1 Description 4.2 Other GSM core network elements connected to the VLR 4.3 Procedures implemented 5 Equipment identity register (EIR) 6 Other support functions 6.1 Billing centre (BC) 6.2 Short message service centre (SMSC) 6.3 Multimedia messaging service centre (MMSC) 6.4 Voicemail system (VMS) 6.5 Lawful interception functions 7 See also 8 External links

[edit] Mobile switching center (MSC)

[edit] Description

The mobile switching center (MSC) is the primary service delivery node for GSM, responsible for routing voice calls and SMS as well as other services (such as conference calls, FAX and circuit switched data). The MSC sets up and releases the end-to-end connection, handles mobility and hand-over requirements during the call and takes care of charging and real time pre-paid account monitoring.

In the GSM mobile phone system, in contrast with earlier analogue services, fax and data information is sent directly digitally encoded to the MSC. Only at the MSC is this re-coded into an "analogue" signal (although actually this will almost certainly mean sound encoded digitally as PCM signal in a 64-kbit/s timeslot, known as a DS0 in America).

There are various different names for MSCs in different contexts which reflects their complex role in the network, all of these terms though could refer to the same MSC, but doing different things at different times.

The gateway MSC (G-MSC) is the MSC that determines which visited MSC the subscriber who is being called is currently located. It also interfaces with the PSTN. All mobile to mobile calls and PSTN to mobile calls are routed through a G-MSC. The term is only valid in the context of one call since any MSC may provide both the gateway function and the Visited MSC function, however, some manufacturers design dedicated high capacity MSCs which do not have any BSSs connected to them. These MSCs will then be the Gateway MSC for many of the calls they handle.

The visited MSC (V-MSC) is the MSC where a customer is currently located. The VLR associated with this MSC will have the subscriber's data in it.

The anchor MSC is the MSC from which a handover has been initiated. The target MSC is the MSC toward which a Handover should take place. A mobile switching centre server is a part of the redesigned MSC concept starting from 3GPP Release 5.

[edit] Mobile switching centre server (MSCS)

The mobile switching centre server is a soft-switch variant of the mobile switching centre, which provides circuit-switched calling, mobility management, and GSM services to the mobile phones roaming within the area that it serves. MSS functionality enables split between control (signalling) and user plane (bearer in network element called as media gateway/MG), which guarantees more optimal placement of network elements within the network.

MSS and MGW media gateway makes it possible to cross-connect circuit switched calls switched by using IP, ATM AAL2 as well as TDM. More information is available in 3GPP TS 23.205.

[edit] Other GSM core network elements connected to the MSC

The MSC connects to the following elements:

• The home location register (HLR) for obtaining data about the SIM and mobile services ISDN number (MSISDN; i.e., the telephone number).
• The base station subsystem which handles the radio communication with 2G and 2.5G mobile phones.
• The UMTS terrestrial radio access network (UTRAN) which handles the radio communication with 3G mobile phones.
• The visitor location register (VLR) for determining where other mobile subscribers are located.
• Other MSCs for procedures such as handover.

[edit] Procedures implemented

Tasks of the MSC include:

• Delivering calls to subscribers as they arrive based on information from the VLR.
• Connecting outgoing calls to other mobile subscribers or the PSTN.
• Delivering SMSs from subscribers to the short message service centre (SMSC) and vice versa.
• Arranging handovers from BSC to BSC.
• Carrying out handovers from this MSC to another.
• Supporting supplementary services such as conference calls or call hold.
• Generating billing information.

[edit] Home location register (HLR)

The home location register (HLR) is a central database that contains details of each mobile phone subscriber that is authorized to use the GSM core network. There can be several logical, and physical, HLRs per public land mobile network (PLMN), though one international mobile subscriber identity (IMSI)/MSISDN pair can be associated with only one logical HLR (which can span several physical nodes) at a time.

The HLR stores details of every SIM card issued by the mobile phone operator. Each SIM has a unique identifier called an IMSI which is the primary key to each HLR record.

The next important items of data associated with the SIM are the MSISDNs, which are the telephone numbers used by mobile phones to make and receive calls. The primary MSISDN is the number used for making and receiving voice calls and SMS, but it is possible for a SIM to have other secondary MSISDNs associated with it for fax and data calls. Each MSISDN is also a primary key to the HLR record. The HLR data is stored for as long as a subscriber remains with the mobile phone operator.

Examples of other data stored in the HLR against an IMSI record is:

• GSM services that the subscriber has requested or been given.
• GPRS settings to allow the subscriber to access packet services.
• Current location of subscriber (VLR and serving GPRS support node/SGSN).
• Call divert settings applicable for each associated MSISDN.

The HLR is a system which directly receives and processes MAP transactions and messages from elements in the GSM network, for example, the location update messages received as mobile phones roam around.

[edit] Other GSM core network elements connected to the HLR

The HLR connects to the following elements:

• The G-MSC for handling incoming calls
• The VLR for handling requests from mobile phones to attach to the network
• The SMSC for handling incoming SMS
• The voice mail system for delivering notifications to the mobile phone that a message is waiting
• The AUC for authentication and ciphering and exchange of data (triplets)

[edit] Procedures implemented

The main function of the HLR is to manage the fact that SIMs and phones move around a lot. The following procedures are implemented to deal with this:

• Manage the mobility of subscribers by means of updating their position in administrative areas called 'location areas', which are identified with a LAC. The action of a user of moving from one LA to another is followed by the HLR with a Location area update procedure.
• Send the subscriber data to a VLR or SGSN when a subscriber first roams there.
• Broker between the G-MSC or SMSC and the subscriber's current VLR in order to allow incoming calls or text messages to be delivered.
• Remove subscriber data from the previous VLR when a subscriber has roamed away from it.

[edit] Authentication centre (AUC)

[edit] Description

The authentication centre (AUC) is a function to authenticate each SIM card that attempts to connect to the GSM core network (typically when the phone is powered on). Once the authentication is successful, the HLR is allowed to manage the SIM and services described above. An encryption key is also generated that is subsequently used to encrypt all wireless communications (voice, SMS, etc.) between the mobile phone and the GSM core network.

If the authentication fails, then no services are possible from that particular combination of SIM card and mobile phone operator attempted. There is an additional form of identification check performed on the serial number of the mobile phone described in the EIR section below, but this is not relevant to the AUC processing.

Proper implementation of security in and around the AUC is a key part of an operator's strategy to avoid SIM cloning.

The AUC does not engage directly in the authentication process, but instead generates data known as triplets for the MSC to use during the procedure. The security of the process depends upon a shared secret between the AUC and the SIM called the K_i. The K_i is securely burned into the SIM during manufacture and is also securely replicated onto the AUC. This K_i is never transmitted between the AUC and SIM, but is combined with the IMSI to produce a challenge/response for identification purposes and an encryption key called K_c for use in over the air communications.

[edit] Other GSM core network elements connected to the AUC

The AUC connects to the following elements:

• the MSC which requests a new batch of triplet data for an IMSI after the previous data have been used. This ensures that same keys and challenge responses are not used twice for a particular mobile.

[edit] Procedures implemented

The AUC stores the following data for each IMSI:

• the K_i
• Algorithm id. (the standard algorithms are called A3 or A8, but an operator may choose a proprietary one).

When the MSC asks the AUC for a new set of triplets for a particular IMSI, the AUC first generates a random number known as RAND. This RAND is then combined with the K_i to produce two numbers as follows:

• The K_i and RAND are fed into the A3 algorithm and the signed response (SRES) is calculated.
• The K_i and RAND are fed into the A8 algorithm and a session key called K_c is calculated.

The numbers (RAND, SRES, K_c) form the triplet sent back to the MSC. When a particular IMSI requests access to the GSM core network, the MSC sends the RAND part of the triplet to the SIM. The SIM then feeds this number and the K_i (which is burned onto the SIM) into the A3 algorithm as appropriate and an SRES is calculated and sent back to the MSC. If this SRES matches with the SRES in the triplet (which it should if it is a valid SIM), then the mobile is allowed to attach and proceed with GSM services.

After successful authentication, the MSC sends the encryption key K_c to the base station controller (BSC) so that all communications can be encrypted and decrypted. Of course, the mobile phone can generate the K_c itself by feeding the same RAND supplied during authentication and the K_i into the A8 algorithm.

The AUC is usually collocated with the HLR, although this is not necessary. Whilst the procedure is secure for most everyday use, it is by no means crack proof. Therefore a new set of security methods was designed for 3G phones.

[edit] Visitor location register (VLR)

[edit] Description

The visitor location register is a temporary database of the subscribers who have roamed into the particular area which it serves. Each base station in the network is served by exactly one VLR, hence a subscriber cannot be present in more than one VLR at a time.

The data stored in the VLR has either been received from the HLR, or collected from the MS. In practice, for performance reasons, most vendors integrate the VLR directly to the V-MSC and, where this is not done, the VLR is very tightly linked with the MSC via a proprietary interface.

Data stored include:

• IMSI (the subscriber's identity number).
• Authentication data.
• MSISDN (the subscriber's phone number).
• GSM services that the subscriber is allowed to access.
• access point (GPRS) subscribed.
• The HLR address of the subscriber.

[edit] Other GSM core network elements connected to the VLR

The VLR connects to the following elements:

• The V-MSC to pass needed data for its procedures; e.g., authentication or call setup.
• The HLR to request data for mobile phones attached to its serving area.
• Other VLRs to transfer temporary data concerning the mobile when they roam into new VLR areas. For example, the temporal mobile subscriber identity (TMSI).

[edit] Procedures implemented

The primary functions of the VLR are:

• To inform the HLR that a subscriber has arrived in the particular area covered by the VLR.
• To track where the subscriber is within the VLR area (location area) when no call is ongoing.
• To allow or disallow which services the subscriber may use.
• To allocate roaming numbers during the processing of incoming calls.
• To purge the subscriber record if a subscriber becomes inactive whilst in the area of a VLR. The VLR deletes the subscriber's data after a fixed time period of inactivity and informs the HLR (e.g., when the phone has been switched off and left off or when the subscriber has moved to an area with no coverage for a long time).
• To delete the subscriber record when a subscriber explicitly moves to another, as instructed by the HLR.

[edit] Equipment identity register (EIR)

The equipment identity register is often integrated to the HLR. The EIR keeps a list of mobile phones (identified by their IMEI) which are to be banned from the network or monitored. This is designed to allow tracking of stolen mobile phones. In theory all data about all stolen mobile phones should be distributed to all EIRs in the world through a Central EIR. It is clear, however, that there are some countries where this is not in operation. The EIR data does not have to change in real time, which means that this function can be less distributed than the function of the HLR. The EIR is a database that contains information about the identity of the mobile equipment that prevents calls from stolen, unauthorized or defective mobile stations. Some EIR also have the capability to log Handset attempts and store it in a log file.

[edit] Other support functions

Connected more or less directly to the GSM core network are many other functions.

[edit] Billing centre (BC)

The billing centre is responsible for processing the toll tickets generated by the VLRs and HLRs and generating a bill for each subscriber. It is also responsible for generating billing data of roaming subscriber.

[edit] Short message service centre (SMSC)

The short message service centre supports the sending and reception of text messages.

[edit] Multimedia messaging service centre (MMSC)

The multimedia messaging service centre supports the sending of multimedia messages (e.g., images, audio, video and their combinations) to (or from) MMS-enabled Handsets.

[edit] Voicemail system (VMS)

The voicemail system records and stores voicemails.

[edit] Lawful interception functions

According to U.S. law, which has also been copied into many other countries, especially in Europe, all telecommunications equipment must provide facilities for monitoring the calls of selected users. There must be some level of support for this built into any of the different elements. The concept of lawful interception is also known, following the relevant U.S. law, as CALEA. Generally Lawful Interception implementation is similar to the implementation of conference call. While A and B is talking with each other, C can join the call and listens silently.

[edit] See also

• The GPRS core network with the rest of the GSM core network.
• Base station subsystem

[edit] External links

• the 3GPP, the standardisation body for GSM and UMTS

[hide] v • d • e Mobile telephony and mobile telecommunications standards 0G (radio telephones) MTS · MTA · MTB · MTC · IMTS · MTD · AMTS · OLT · Autoradiopuhelin 1G NMT · AMPS · Hicap · Mobitex · DataTAC · TACS · ETACS 2G GSM/3GPP family GSM · CSD 3GPP2 family CdmaOne (IS-95) Other D-AMPS (IS-54 and IS-136) · CDPD · iDEN · PDC · PHS 2G transitional (2.5G, 2.75G) GSM/3GPP family HSCSD · GPRS · EDGE/EGPRS 3GPP2 family CDMA2000 1xRTT (IS-2000) Other WiDEN 3G (IMT-2000) 3GPP family UMTS (UTRAN) · WCDMA-FDD · WCDMA-TDD · UTRA-TDD LCR (TD-SCDMA) 3GPP2 family CDMA2000 1xEV-DO (IS-856) 3G transitional (3.5G, 3.9G) 3GPP family HSDPA · HSUPA · HSPA+ · LTE (E-UTRA) 3GPP2 family EV-DO Rev. A · EV-DO Rev. B Other Mobile WiMAX (IEEE 802.16e-2005) · Flash-OFDM · IEEE 802.20 4G (IMT-Advanced) 3GPP family LTE Advanced WiMAX family IEEE 802.16m Related articles History · Cellular network theory · List of standards · Comparison of standards · Spectral efficiency comparison table · Cellular frequencies · GSM frequency bands · UMTS frequency bands · Mobile broadband

  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.foreground_service_controller);

        // Watch for button clicks.
        Button button = (Button)findViewById(R.id.start_foreground);
        button.setOnClickListener(mForegroundListener);
        button = (Button)findViewById(R.id.start_background);
        button.setOnClickListener(mBackgroundListener);
        button = (Button)findViewById(R.id.stop);
        button.setOnClickListener(mStopListener);
    }

    private OnClickListener mForegroundListener = new OnClickListener() {
        public void onClick(View v) {
            Intent intent = new Intent(ForegroundService.ACTION_FOREGROUND);
            intent.setClass(ForegroundServiceController.this, ForegroundService.class);
            startService(intent);
        }
    };

    private OnClickListener mBackgroundListener = new OnClickListener() {
        public void onClick(View v) {
            Intent intent = new Intent(ForegroundService.ACTION_BACKGROUND);
            intent.setClass(ForegroundServiceController.this, ForegroundService.class);
            startService(intent);
        }
    };

    private OnClickListener mStopListener = new OnClickListener() {
        public void onClick(View v) {
            stopService(new Intent(ForegroundServiceController.this,
                    ForegroundService.class));
        }
    };
}

    static final String ACTION_FOREGROUND = "com.example.android.apis.FOREGROUND";
    static final String ACTION_BACKGROUND = "com.example.android.apis.BACKGROUND";
   
    private static final Class[] mStartForegroundSignature = new Class[] {
        int.class, Notification.class};
    private static final Class[] mStopForegroundSignature = new Class[] {
        boolean.class};
   
    private NotificationManager mNM;
    private Method mStartForeground;
    private Method mStopForeground;
    private Object[] mStartForegroundArgs = new Object[2];
    private Object[] mStopForegroundArgs = new Object[1];
   
    @Override
    public void onCreate() {
        mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
        try {
            mStartForeground = getClass().getMethod("startForeground",
                    mStartForegroundSignature);
            mStopForeground = getClass().getMethod("stopForeground",
                    mStopForegroundSignature);
        } catch (NoSuchMethodException e) {
            // Running on an older platform.
            mStartForeground = mStopForeground = null;
        }
    }

    // This is the old onStart method that will be called on the pre-2.0
    // platform.  On 2.0 or later we override onStartCommand() so this
    // method will not be called.
    @Override
    public void onStart(Intent intent, int startId) {
        handleCommand(intent);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        handleCommand(intent);
        // We want this service to continue running until it is explicitly
        // stopped, so return sticky.
        return START_STICKY;
    }

    void handleCommand(Intent intent) {
        if (ACTION_FOREGROUND.equals(intent.getAction())) {
   // In this sample, we'll use the same text for the ticker and the expanded notification
            CharSequence text = getText(R.string.foreground_service_started);

            // Set the icon, scrolling text and timestamp
            Notification notification = new Notification(R.drawable.stat_sample, text,
                    System.currentTimeMillis());

            // The PendingIntent to launch our activity if the user selects this notification
            PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                    new Intent(this, ForegroundServiceController.class), 0);

            // Set the info for the views that show in the notification panel.
            notification.setLatestEventInfo(this, getText(R.string.local_service_label),
                           text, contentIntent);
           
            startForegroundCompat(R.string.foreground_service_started, notification);
           
        } else if (ACTION_BACKGROUND.equals(intent.getAction())) {
            stopForegroundCompat(R.string.foreground_service_started);
        }
    }
   
    /**
     * This is a wrapper around the new startForeground method, using the older
     * APIs if it is not available.
     */
    void startForegroundCompat(int id, Notification notification) {
        // If we have the new startForeground API, then use it.
        if (mStartForeground != null) {
            mStartForegroundArgs[0] = Integer.valueOf(id);
            mStartForegroundArgs[1] = notification;
            try {
                mStartForeground.invoke(this, mStartForegroundArgs);
            } catch (InvocationTargetException e) {
                // Should not happen.
                Log.w("ApiDemos", "Unable to invoke startForeground", e);
            } catch (IllegalAccessException e) {
                // Should not happen.
                Log.w("ApiDemos", "Unable to invoke startForeground", e);
            }
            return;
        }
       
        // Fall back on the old API.
        setForeground(true);
        mNM.notify(id, notification);
    }
   
    /**
     * This is a wrapper around the new stopForeground method, using the older
     * APIs if it is not available.
     */
    void stopForegroundCompat(int id) {
        // If we have the new stopForeground API, then use it.
        if (mStopForeground != null) {
            mStopForegroundArgs[0] = Boolean.TRUE;
            try {
                mStopForeground.invoke(this, mStopForegroundArgs);
            } catch (InvocationTargetException e) {
                // Should not happen.
                Log.w("ApiDemos", "Unable to invoke stopForeground", e);
            } catch (IllegalAccessException e) {
                // Should not happen.
                Log.w("ApiDemos", "Unable to invoke stopForeground", e);
            }
            return;
        }
       
        // Fall back on the old API.  Note to cancel BEFORE changing the
        // foreground state, since we could be killed at that point.
        mNM.cancel(id);
        setForeground(false);
    }
   
    @Override
    public void onDestroy() {
        // Make sure our notification is gone.
        stopForegroundCompat(R.string.foreground_service_started);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

    Button mStartSearch;
    Spinner mMenuMode;
    EditText mQueryPrefill;
    EditText mQueryAppData;
   
    final static int MENUMODE_SEARCH_KEY = 0;
    final static int MENUMODE_MENU_ITEM = 1;
    final static int MENUMODE_TYPE_TO_SEARCH = 2;
    final static int MENUMODE_DISABLED = 3;
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       
        // Inflate our UI from its XML layout description.
        setContentView(R.layout.search_invoke);
       
        // Get display items for later interaction
        mStartSearch = (Button) findViewById(R.id.btn_start_search);
        mMenuMode = (Spinner) findViewById(R.id.spinner_menu_mode);
        mQueryPrefill = (EditText) findViewById(R.id.txt_query_prefill);
        mQueryAppData = (EditText) findViewById(R.id.txt_query_appdata);
       
        // Populate items
        ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
                            this, R.array.search_menuModes, android.R.layout.simple_spinner_item);
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        mMenuMode.setAdapter(adapter);
       
    // Create listener for the menu mode dropdown.  We use this to demonstrate control
    // of the default keys handler in every Activity.  More typically, you will simply set
    // the default key mode in your activity's onCreate() handler.
        mMenuMode.setOnItemSelectedListener(
            new OnItemSelectedListener() {
                public void onItemSelected(
                        AdapterView<?> parent, View view, int position, long id) {
                    if (position == MENUMODE_TYPE_TO_SEARCH) {
                        setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
                    } else {
                        setDefaultKeyMode(DEFAULT_KEYS_DISABLE);
                    }
                }

                public void onNothingSelected(AdapterView<?> parent) {
                    setDefaultKeyMode(DEFAULT_KEYS_DISABLE);
                }
            });
       
        // Attach actions to buttons
        mStartSearch.setOnClickListener(
            new OnClickListener() {
                public void onClick(View v) {
                    onSearchRequested();
                }
            });
    }
   
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        super.onPrepareOptionsMenu(menu);
        MenuItem item;
       
            // first, get rid of our menus (if any)
        menu.removeItem(0);
        menu.removeItem(1);
       
            // next, add back item(s) based on current menu mode
        switch (mMenuMode.getSelectedItemPosition())
        {
        case MENUMODE_SEARCH_KEY:
            item = menu.add( 0, 0, 0, "(Search Key)");
            break;
           
        case MENUMODE_MENU_ITEM:
            item = menu.add( 0, 0, 0, "Search");
            item.setAlphabeticShortcut(SearchManager.MENU_KEY);
            break;
           
        case MENUMODE_TYPE_TO_SEARCH:
            item = menu.add( 0, 0, 0, "(Type-To-Search)");
            break;
           
        case MENUMODE_DISABLED:
            item = menu.add( 0, 0, 0, "(Disabled)");
            break;
        }
       
        item = menu.add(0, 1, 0, "Clear History");
        return true;
    }
   
    /** Handle the menu item selections */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case 0:
            switch (mMenuMode.getSelectedItemPosition()) {
            case MENUMODE_SEARCH_KEY:
                new AlertDialog.Builder(this)
                    .setMessage("To invoke search, dismiss this dialog and press the search key" +
                                " (F5 on the simulator).")
                    .setPositiveButton("OK", null)
                    .show();
                break;
               
            case MENUMODE_MENU_ITEM:
                onSearchRequested();
                break;
               
            case MENUMODE_TYPE_TO_SEARCH:
                new AlertDialog.Builder(this)
                    .setMessage("To invoke search, dismiss this dialog and start typing.")
                    .setPositiveButton("OK", null)
                    .show();
                break;
               
            case MENUMODE_DISABLED:
                new AlertDialog.Builder(this)
                    .setMessage("You have disabled search.")
                    .setPositiveButton("OK", null)
                    .show();
                break;
            }
            break;
        case 1:
            clearSearchHistory();
            break;
        }
   
         return super.onOptionsItemSelected(item);
    }
   
    @Override
    public boolean onSearchRequested() {
        // If your application absolutely must disable search, do it here.
        if (mMenuMode.getSelectedItemPosition() == MENUMODE_DISABLED) {
            return false;
        }
       
        final String queryPrefill = mQueryPrefill.getText().toString();

        Bundle appDataBundle = null;
        final String queryAppDataString = mQueryAppData.getText().toString();
        if (queryAppDataString != null) {
            appDataBundle = new Bundle();
            appDataBundle.putString("demo_key", queryAppDataString);
        }
       
        // Now call the Activity member function that invokes the Search Manager UI.
        startSearch(queryPrefill, false, appDataBundle, false);
       
        // Returning true indicates that we did launch the search, instead of blocking it.
        return true;
    }
   
    private void clearSearchHistory() {
        SearchRecentSuggestions suggestions = new SearchRecentSuggestions(this,
                SearchSuggestionSampleProvider.AUTHORITY, SearchSuggestionSampleProvider.MODE);
        suggestions.clearHistory();
    }
   
}

        // UI elements
    TextView mQueryText;
    TextView mAppDataText;
    TextView mDeliveredByText;
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       
        // Inflate our UI from its XML layout description.
        setContentView(R.layout.search_query_results);
       
        // Get active display items for later updates
        mQueryText = (TextView) findViewById(R.id.txt_query);
        mAppDataText = (TextView) findViewById(R.id.txt_appdata);
        mDeliveredByText = (TextView) findViewById(R.id.txt_deliveredby);
       
        // get and process search query here
        final Intent queryIntent = getIntent();
        final String queryAction = queryIntent.getAction();
        if (Intent.ACTION_SEARCH.equals(queryAction)) {
            doSearchQuery(queryIntent, "onCreate()");
        }
        else {
            mDeliveredByText.setText("onCreate(), but no ACTION_SEARCH intent");
        }
    }
   
    @Override
    public void onNewIntent(final Intent newIntent) {
        super.onNewIntent(newIntent);
       
        // get and process search query here
        final Intent queryIntent = getIntent();
        final String queryAction = queryIntent.getAction();
        if (Intent.ACTION_SEARCH.equals(queryAction)) {
            doSearchQuery(queryIntent, "onNewIntent()");
        }
        else {
            mDeliveredByText.setText("onNewIntent(), but no ACTION_SEARCH intent");
        }
    }
   
    private void doSearchQuery(final Intent queryIntent, final String entryPoint) {
       
        // The search query is provided as an "extra" string in the query intent
        final String queryString = queryIntent.getStringExtra(SearchManager.QUERY);
        mQueryText.setText(queryString);
       
        // Record the query string in the recent queries suggestions provider.
        SearchRecentSuggestions suggestions = new SearchRecentSuggestions(this,
                SearchSuggestionSampleProvider.AUTHORITY, SearchSuggestionSampleProvider.MODE);
        suggestions.saveRecentQuery(queryString, null);
       
        // If your application provides context data for its searches,
        // you will receive it as an "extra" bundle in the query intent.
        // The bundle can contain any number of elements, using any number of keys;
        // For this Api Demo we're just using a single string, stored using "demo key".
        final Bundle appData = queryIntent.getBundleExtra(SearchManager.APP_DATA);
        if (appData == null) {
            mAppDataText.setText("<no app data bundle>");
        }
        if (appData != null) {
            String testStr = appData.getString("demo_key");
            mAppDataText.setText((testStr == null) ? "<no app data>" : testStr);
        }
       
        // Report the method by which we were called.
        mDeliveredByText.setText(entryPoint);
    }
}

   @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       
        setPreferenceScreen(createPreferenceHierarchy());
    }

    private PreferenceScreen createPreferenceHierarchy() {
        PreferenceScreen root = getPreferenceManager().createPreferenceScreen(this);
       
        // Inline preferences
        PreferenceCategory inlinePrefCat = new PreferenceCategory(this);
        inlinePrefCat.setTitle(R.string.inline_preferences);
        root.addPreference(inlinePrefCat);
       
        // Toggle preference
        CheckBoxPreference togglePref = new CheckBoxPreference(this);
        togglePref.setKey("toggle_preference");
        togglePref.setTitle(R.string.title_toggle_preference);
        togglePref.setSummary(R.string.summary_toggle_preference);
        inlinePrefCat.addPreference(togglePref);
               
        // Dialog based preferences
        PreferenceCategory dialogBasedPrefCat = new PreferenceCategory(this);
        dialogBasedPrefCat.setTitle(R.string.dialog_based_preferences);
        root.addPreference(dialogBasedPrefCat);

        // Edit text preference
        EditTextPreference editTextPref = new EditTextPreference(this);
        editTextPref.setDialogTitle(R.string.dialog_title_edittext_preference);
        editTextPref.setKey("edittext_preference");
        editTextPref.setTitle(R.string.title_edittext_preference);
        editTextPref.setSummary(R.string.summary_edittext_preference);
        dialogBasedPrefCat.addPreference(editTextPref);
       
        // List preference
        ListPreference listPref = new ListPreference(this);
        listPref.setEntries(R.array.entries_list_preference);
        listPref.setEntryValues(R.array.entryvalues_list_preference);
        listPref.setDialogTitle(R.string.dialog_title_list_preference);
        listPref.setKey("list_preference");
        listPref.setTitle(R.string.title_list_preference);
        listPref.setSummary(R.string.summary_list_preference);
        dialogBasedPrefCat.addPreference(listPref);
       
        // Launch preferences
        PreferenceCategory launchPrefCat = new PreferenceCategory(this);
        launchPrefCat.setTitle(R.string.launch_preferences);
        root.addPreference(launchPrefCat);

        // Screen preference
        PreferenceScreen screenPref = getPreferenceManager().createPreferenceScreen(this);
        screenPref.setKey("screen_preference");
        screenPref.setTitle(R.string.title_screen_preference);
        screenPref.setSummary(R.string.summary_screen_preference);
        launchPrefCat.addPreference(screenPref);
               
        // Example of next screen toggle preference
        CheckBoxPreference nextScreenCheckBoxPref = new CheckBoxPreference(this);
        nextScreenCheckBoxPref.setKey("next_screen_toggle_preference");
        nextScreenCheckBoxPref.setTitle(R.string.title_next_screen_toggle_preference);
        nextScreenCheckBoxPref.setSummary(R.string.summary_next_screen_toggle_preference);
        screenPref.addPreference(nextScreenCheckBoxPref);
       
        // Intent preference
        PreferenceScreen intentPref = getPreferenceManager().createPreferenceScreen(this);
        intentPref.setIntent(new Intent().setAction(Intent.ACTION_VIEW)
                .setData(Uri.parse("http://www.android.com")));
        intentPref.setTitle(R.string.title_intent_preference);
        intentPref.setSummary(R.string.summary_intent_preference);
        launchPrefCat.addPreference(intentPref);
       
        // Preference attributes
        PreferenceCategory prefAttrsCat = new PreferenceCategory(this);
        prefAttrsCat.setTitle(R.string.preference_attributes);
        root.addPreference(prefAttrsCat);
       
        // Visual parent toggle preference
        CheckBoxPreference parentCheckBoxPref = new CheckBoxPreference(this);
        parentCheckBoxPref.setTitle(R.string.title_parent_preference);
        parentCheckBoxPref.setSummary(R.string.summary_parent_preference);
        prefAttrsCat.addPreference(parentCheckBoxPref);
       
        // Visual child toggle preference
        // See res/values/attrs.xml for the <declare-styleable> that defines
        // TogglePrefAttrs.
        TypedArray a = obtainStyledAttributes(R.styleable.TogglePrefAttrs);
        CheckBoxPreference childCheckBoxPref = new CheckBoxPreference(this);
        childCheckBoxPref.setTitle(R.string.title_child_preference);
        childCheckBoxPref.setSummary(R.string.summary_child_preference);
        childCheckBoxPref.setLayoutResource(
                a.getResourceId(R.styleable.TogglePrefAttrs_android_preferenceLayoutChild,
                        0));
        prefAttrsCat.addPreference(childCheckBoxPref);
        a.recycle();
       
        return root;
    }
}

<PreferenceScreen
        xmlns:android="http://schemas.android.com/apk/res/android">

    <CheckBoxPreference
            android:key="default_toggle"
            android:defaultValue="true"
            android:title="@string/title_checkbox_preference"
            android:summary="@string/summary_checkbox_preference" />

    <EditTextPreference
            android:key="default_edittext"
            android:defaultValue="@string/default_value_edittext_preference"
            android:title="@string/title_edittext_preference"
            android:summary="@string/summary_edittext_preference"
            android:dialogTitle="@string/dialog_title_edittext_preference" />
           
    <ListPreference
            android:key="default_list"
          android:defaultValue="@string/default_value_list_preference"
            android:title="@string/title_list_preference"
            android:summary="@string/summary_list_preference"
            android:entries="@array/entries_list_preference"
            android:entryValues="@array/entryvalues_list_preference"
            android:dialogTitle="@string/dialog_title_list_preference" />

</PreferenceScreen>

<resources>
    <string-array name="entries_list_preference">
        <item>Alpha Option 01</item>
        <item>Beta Option 02</item>
        <item>Charlie Option 03</item> 
    </string-array>

    <string-array name="entryvalues_list_preference">
        <item>alpha</item>
        <item>beta</item>
        <item>charlie</item> 
    </string-array>
</resources>
 

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       
        addPreferencesFromResource(R.xml.preference_dependencies);
    }

}

<PreferenceScreen
        xmlns:android="http://schemas.android.com/apk/res/android">

    <PreferenceCategory
            android:title="@string/example_preference_dependency">
           
        <CheckBoxPreference
                android:key="wifi"
                android:title="@string/title_wifi" />
           
        <EditTextPreference
                android:layout="?android:attr/preferenceLayoutChild"
                android:title="@string/title_wifi_settings"
                android:dependency="wifi" />
           
    </PreferenceCategory>
</PreferenceScreen>

    private static final int REQUEST_CODE_PREFERENCES = 1;
    private TextView mCounterText;
   
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

       PreferenceManager.setDefaultValues(this, R.xml.advanced_preferences, false);
       
        LinearLayout layout = new LinearLayout(this);
        layout.setOrientation(LinearLayout.VERTICAL);
        setContentView(layout);
       
        Button launchPreferences = new Button(this);
        launchPreferences.setText(getString(R.string.launch_preference_activity));
        launchPreferences.setOnClickListener(this);
        layout.addView(launchPreferences, new LayoutParams(LayoutParams.FILL_PARENT,
                LayoutParams.WRAP_CONTENT));
       
        mCounterText = new TextView(this);
        layout.addView(mCounterText, new LayoutParams(LayoutParams.FILL_PARENT,
                LayoutParams.WRAP_CONTENT));
       
        updateCounterText();
    }

    public void onClick(View v) {
       
        Intent launchPreferencesIntent = new Intent().setClass(this, AdvancedPreferences.class);
       
        startActivityForResult(launchPreferencesIntent, REQUEST_CODE_PREFERENCES);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
       
        if (requestCode == REQUEST_CODE_PREFERENCES) {
            updateCounterText();
        }
    }

    private void updateCounterText() {
        SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
        final int counter = sharedPref.getInt(AdvancedPreferences.KEY_MY_PREFERENCE, 0);
        mCounterText.setText(getString(R.string.counter_value_is) + " " + counter);
    }
}

   public static final String KEY_MY_PREFERENCE = "my_preference";
    public static final String KEY_ADVANCED_CHECKBOX_PREFERENCE = "advanced_checkbox_preference";

    private CheckBoxPreference mCheckBoxPreference;
    private Handler mHandler = new Handler();
   
    private Runnable mForceCheckBoxRunnable = new Runnable() {
        public void run() {
            if (mCheckBoxPreference != null) {
                mCheckBoxPreference.setChecked(!mCheckBoxPreference.isChecked());
            }
           
              mHandler.postDelayed(this, 1000);
        }
    };
   
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        addPreferencesFromResource(R.xml.advanced_preferences);
       
        mCheckBoxPreference = (CheckBoxPreference)getPreferenceScreen().findPreference(KEY_ADVANCED_CHECKBOX_PREFERENCE);
    }

    @Override
    protected void onResume() {
        super.onResume();

        mForceCheckBoxRunnable.run();
       
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    protected void onPause() {
        super.onPause();

        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
       
        mHandler.removeCallbacks(mForceCheckBoxRunnable);
    }

    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        if (key.equals(KEY_MY_PREFERENCE)) {
            Toast.makeText(this, "Thanks! You increased my count to "
                    + sharedPreferences.getInt(key, 0), Toast.LENGTH_SHORT).show();
        }
    }
   
}

   private int mClickCounter;

    public MyPreference(Context context, AttributeSet attrs) {
        super(context, attrs);
       
        setWidgetLayoutResource(R.layout.preference_widget_mypreference);       
    }

    @Override
    protected void onBindView (View view) {
        super.onBindView(view);
       
        final TextView myTextView = (TextView) view.findViewById(R.id.mypreference_widget);
        if (myTextView != null) {
            myTextView.setText(String.valueOf(mClickCounter));
        }
    }

    @Override
    protected void onClick() {
        int newValue = mClickCounter + 1;
        if (!callChangeListener(newValue)) {
            return;
        }
       
        mClickCounter = newValue;
       
        persistInt(mClickCounter);
       
        notifyChanged();
    }

    @Override
    protected Object onGetDefaultValue(TypedArray a, int index) {
        return a.getInteger(index, 0);
    }

    @Override
    protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
        if (restoreValue) {
            mClickCounter = getPersistedInt(mClickCounter);
        } else {
            int value = (Integer) defaultValue;
            mClickCounter = value;
            persistInt(value);
        }
    }

    @Override
    protected Parcelable onSaveInstanceState() {
       
        final Parcelable superState = super.onSaveInstanceState();
        if (isPersistent()) {
            return superState;
        }

        final SavedState myState = new SavedState(superState);
        myState.clickCounter = mClickCounter;
        return myState;
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        if (!state.getClass().equals(SavedState.class)) {
            super.onRestoreInstanceState(state);
            return;
        }

        SavedState myState = (SavedState) state;
        super.onRestoreInstanceState(myState.getSuperState());
        mClickCounter = myState.clickCounter;
        notifyChanged();
    }
   
    private static class SavedState extends BaseSavedState {
        int clickCounter;
       
        public SavedState(Parcel source) {
            super(source);
           
            clickCounter = source.readInt();
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            super.writeToParcel(dest, flags);
           
            dest.writeInt(clickCounter);
        }

        public SavedState(Parcelable superState) {
            super(superState);
        }

        public static final Parcelable.Creator<SavedState> CREATOR =
                new Parcelable.Creator<SavedState>() {
            public SavedState createFromParcel(Parcel in) {
                return new SavedState(in);
            }

            public SavedState[] newArray(int size) {
                return new SavedState[size];
            }
        };
    }
   
}

<PreferenceScreen
        xmlns:android="http://schemas.android.com/apk/res/android">

    <com.example.android.apis.app.MyPreference
            android:key="my_preference"
            android:title="@string/title_my_preference"
            android:summary="@string/summary_my_preference"
            android:defaultValue="100" />

    <CheckBoxPreference
            android:key="advanced_checkbox_preference"
            android:title="@string/title_advanced_toggle_preference"
            android:summaryOn="@string/summary_on_advanced_toggle_preference"
            android:summaryOff="@string/summary_off_advanced_toggle_preference" />

</PreferenceScreen>

  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        addPreferencesFromResource(R.xml.preferences);
    }
}

<PreferenceScreen
        xmlns:android="http://schemas.android.com/apk/res/android">

    <PreferenceCategory
            android:title="@string/inline_preferences" >
           
        <CheckBoxPreference
                android:key="checkbox_preference"
                android:title="@string/title_toggle_preference"
                android:summary="@string/summary_toggle_preference" />
           
    </PreferenceCategory>
               
    <PreferenceCategory
            android:title="@string/dialog_based_preferences" >

        <EditTextPreference
                android:key="edittext_preference"
                android:title="@string/title_edittext_preference"
                android:summary="@string/summary_edittext_preference"
                android:dialogTitle="@string/dialog_title_edittext_preference" />
               
        <ListPreference
                android:key="list_preference"
                android:title="@string/title_list_preference"
                android:summary="@string/summary_list_preference"
                android:entries="@array/entries_list_preference"
                android:entryValues="@array/entryvalues_list_preference"
                android:dialogTitle="@string/dialog_title_list_preference" />

    </PreferenceCategory>

    <PreferenceCategory
            android:title="@string/launch_preferences" >

        <PreferenceScreen
                android:key="screen_preference"
                android:title="@string/title_screen_preference"
                android:summary="@string/summary_screen_preference">
                     
            <CheckBoxPreference
                    android:key="next_screen_checkbox_preference"
                    android:title="@string/title_next_screen_toggle_preference"
                    android:summary="@string/summary_next_screen_toggle_preference" />
               
        </PreferenceScreen>

        <PreferenceScreen
                android:title="@string/title_intent_preference"
                android:summary="@string/summary_intent_preference">

            <intent android:action="android.intent.action.VIEW"
                    android:data="http://www.android.com" />

        </PreferenceScreen>

    </PreferenceCategory>
   
    <PreferenceCategory
            android:title="@string/preference_attributes">
   
        <CheckBoxPreference
                android:key="parent_checkbox_preference"
                android:title="@string/title_parent_preference"
                android:summary="@string/summary_parent_preference" />

        <CheckBoxPreference
                android:key="child_checkbox_preference"
                android:dependency="parent_checkbox_preference"
                android:layout="?android:attr/preferenceLayoutChild"
                android:title="@string/title_child_preference"
                android:summary="@string/summary_child_preference" />
           
    </PreferenceCategory>
   
</PreferenceScreen>

   private NotificationManager mNotificationManager;
   private static int MOOD_NOTIFICATIONS = R.layout.status_bar_notifications;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.status_bar_notifications);

        Button button;

        mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        button = (Button) findViewById(R.id.happy);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
    setMood(R.drawable.stat_happy, R.string.status_bar_notifications_happy_message,
                        false);
            }
        });

        button = (Button) findViewById(R.id.neutral);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
     setMood(R.drawable.stat_neutral, R.string.status_bar_notifications_ok_message,
                        false);
            }
        });

        button = (Button) findViewById(R.id.sad);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
       setMood(R.drawable.stat_sad, R.string.status_bar_notifications_sad_message, false);
            }
        });

        button = (Button) findViewById(R.id.happyMarquee);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
      setMood(R.drawable.stat_happy, R.string.status_bar_notifications_happy_message,
                        true);
            }
        });

        button = (Button) findViewById(R.id.neutralMarquee);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
      setMood(R.drawable.stat_neutral, R.string.status_bar_notifications_ok_message, true);
            }
        });

        button = (Button) findViewById(R.id.sadMarquee);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
      setMood(R.drawable.stat_sad, R.string.status_bar_notifications_sad_message, true);
            }
        });

        button = (Button) findViewById(R.id.happyViews);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
     setMoodView(R.drawable.stat_happy, R.string.status_bar_notifications_happy_message);
            }
        });

        button = (Button) findViewById(R.id.neutralViews);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
    setMoodView(R.drawable.stat_neutral, R.string.status_bar_notifications_ok_message);
            }
        });

        button = (Button) findViewById(R.id.sadViews);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
    setMoodView(R.drawable.stat_sad, R.string.status_bar_notifications_sad_message);
            }
        });
       
        button = (Button) findViewById(R.id.defaultSound);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                setDefault(Notification.DEFAULT_SOUND);
            }
        });
       
        button = (Button) findViewById(R.id.defaultVibrate);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                setDefault(Notification.DEFAULT_VIBRATE);
            }
        });
       
        button = (Button) findViewById(R.id.defaultAll);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                setDefault(Notification.DEFAULT_ALL);
            }
        });
       
        button = (Button) findViewById(R.id.clear);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                mNotificationManager.cancel(R.layout.status_bar_notifications);
            }
        });
    }

    private PendingIntent makeMoodIntent(int moodId) {
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                new Intent(this, NotificationDisplay.class)
                        .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                        .putExtra("moodimg", moodId),
                PendingIntent.FLAG_UPDATE_CURRENT);
        return contentIntent;
    }
   
    private void setMood(int moodId, int textId, boolean showTicker) {
         CharSequence text = getText(textId);

         String tickerText = showTicker ? getString(textId) : null;

        Notification notification = new Notification(moodId, tickerText,
                System.currentTimeMillis());

 notification.setLatestEventInfo(this, getText(R.string.status_bar_notifications_mood_title),
                       text, makeMoodIntent(moodId));

        mNotificationManager.notify(R.layout.status_bar_notifications, notification);
    }

    private void setMoodView(int moodId, int textId) {
        Notification notif = new Notification();

        notif.contentIntent = makeMoodIntent(moodId);

        CharSequence text = getText(textId);
        notif.tickerText = text;

        notif.icon = moodId;

        RemoteViews contentView = new RemoteViews(getPackageName(), R.layout.status_bar_balloon);
        contentView.setTextViewText(R.id.text, text);
        contentView.setImageViewResource(R.id.icon, moodId);
        notif.contentView = contentView;

        mNotificationManager.notify(R.layout.status_bar_notifications, notif);
    }
   
    private void setDefault(int defaults) {
       
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                new Intent(this, StatusBarNotifications.class), 0);

        CharSequence text = getText(R.string.status_bar_notifications_happy_message);

        final Notification notification = new Notification(
                R.drawable.stat_happy, text, System.currentTimeMillis());

        notification.setLatestEventInfo(
                this,  getText(R.string.status_bar_notifications_mood_title),
                text, contentIntent);
        notification.defaults = defaults;
       
        mNotificationManager.notify(
                   R.layout.status_bar_notifications, notification);              
    }   
}

        <activity android:name=".app.StatusBarNotifications"
                android:label="App/Notification/Status Bar"
                android:launchMode="singleTop">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.SAMPLE_CODE" />
            </intent-filter>
        </activity>

 button = (Button) findViewById(R.id.short_notify);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                Toast.makeText(NotifyWithText.this, R.string.short_notification_text,
                    Toast.LENGTH_SHORT).show();
            }
        });

        button = (Button) findViewById(R.id.long_notify);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                Toast.makeText(NotifyWithText.this, R.string.long_notification_text,
                    Toast.LENGTH_LONG).show();
            }
        });

    private static int MOOD_NOTIFICATIONS = R.layout.status_bar_notifications;
    private ConditionVariable mCondition;
 
    @Override
    public void onCreate() {
        mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        Thread notifyingThread = new Thread(null, mTask, "NotifyingService");
        mCondition = new ConditionVariable(false);
        notifyingThread.start();
    }

    @Override
    public void onDestroy() {
        mNM.cancel(MOOD_NOTIFICATIONS);
        mCondition.open();
    }

    private Runnable mTask = new Runnable() {
        public void run() {
            for (int i = 0; i < 4; ++i) {
                showNotification(R.drawable.stat_happy,
                        R.string.status_bar_notifications_happy_message);
                if (mCondition.block(5 * 1000))
                    break;
                showNotification(R.drawable.stat_neutral,
                        R.string.status_bar_notifications_ok_message);
                if (mCondition.block(5 * 1000))
                    break;
                showNotification(R.drawable.stat_sad,
                        R.string.status_bar_notifications_sad_message);
                if (mCondition.block(5 * 1000))
                    break;
            }
            NotifyingService.this.stopSelf();
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
   
    private void showNotification(int moodId, int textId) {
        CharSequence text = getText(textId);
        Notification notification = new Notification(moodId, null, System.currentTimeMillis());

        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                new Intent(this, NotifyingController.class), 0);

        notification.setLatestEventInfo(this, getText(R.string.status_bar_notifications_mood_title),
                       text, contentIntent);

        mNM.notify(MOOD_NOTIFICATIONS, notification);
    }

    private final IBinder mBinder = new Binder() {
        @Override
        protected boolean onTransact(int code, Parcel data, Parcel reply,
                int flags) throws RemoteException {
            return super.onTransact(code, data, reply, flags);
        }
    };

    private NotificationManager mNM;
}

        <service android:name=".app.NotifyingService" />

        <activity android:name=".app.NotifyingController" android:label="App/Notification/Notifying Service Controller">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.SAMPLE_CODE" />
            </intent-filter>
        </activity>