프쟁이

[android] 프리퍼런스 액티비티 레이아웃을 코드에서 구성하기

2011-05-15T14:19:00.001-07:00

안녕하세요?
프쟁이 입니다.

이 샘플소스는 안드로이드 설치폴더에 android-sdk-windows\samples\android-8\ApiDemos 위치에 원본소스가 있습니다.

지금까지는 프리퍼런스 액티비티의 항목들을 /res/xml/레이아웃.xml 파일에

정의를 하여, 액티비티 클래스 파일에서 addPreferencesFromResource(..)

메소드로 가져와서 레이아웃을 적용시켰습니다.

여기서는 xml 파일에 프리퍼런스 항목들을 정의하지 않고, 코드에서 각 항목들을

객체로 생성하여 동적으로 레이아웃을 구성하도록 합니다.

먼저 원하는 패키지 경로에 프리퍼런스 액티비티 클래스 파일을 추가합니다.

PreferencesFromCode.java 파일명으로 하나 추가합니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package 패키지경로;
import android.content.Intent;
import android.content.res.TypedArray;
import android.net.Uri;
import android.os.Bundle;
import android.preference.CheckBoxPreference;
import android.preference.EditTextPreference;
import android.preference.ListPreference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceCategory;
import android.preference.PreferenceScreen;
import korsoft.net.Test006.R;
public class PreferencesFromCode extends PreferenceActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        /*
         * 밑에 정의한 메소드로, 프리퍼런스 항목들을 객체로 생성하여
         * PreferenceScreen 객체에 추가하여, 최종적으로 PreferenceScreen
         * 객체를 반환합니다. 전에 xml로 구성할 때, 루트태그인
         * <PreferenceScreen>..</PreferenceScreen> 에 해당합니다.
         * 이 태그 안에 현재 액티비티 안에 표시될 모든 프리퍼런스 항목 태그들을
         * 정의 했었습니다. 마찬가지로 단지 여기서는 객체형태로 각 항목들을
         * 생성하여, 이 PreferenceScreen 객체에 추가하여, 같은 방식으로
         * 화면을 구성하게 됩니다.
         */
        setPreferenceScreen(createPreferenceHierarchy());
    }
    private PreferenceScreen createPreferenceHierarchy() {
        // Root
    // xml 로 구성했을때, <PreferenceScreen>..</PreferenceScreen> 태그에 해당하는
    // 액티비티 화면의 루트 객체입니다. 이 객체에 모든 프리퍼런스 카테고리와 프리퍼런스
    // 항목객체들이 추가됩니다.
        PreferenceScreen root = getPreferenceManager().createPreferenceScreen(this);

        // Inline preferences
        // 첫번째 프리퍼런스 카테고리 입니다. 카테고리는 프리퍼런스 액티비티에서
        // 제목을 가지고, 여러 프리퍼런스 항목들을 그룹짓는 역할을 하는 객체입니다.
        // 루트 PreferenceScreen 객체에 추가되고 있습니다.
        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 객체에
        // 추가하고 있습니다.
        PreferenceCategory dialogBasedPrefCat = new PreferenceCategory(this);
        dialogBasedPrefCat.setTitle(R.string.dialog_based_preferences);
        root.addPreference(dialogBasedPrefCat);
        // Edit text preference
        // 새로만든 다이얼로그 카테고리 객체에 에디트 프리퍼런스 항목을 추가하고 있습니다.
        // 현재 항목을 누르면, 입력 다이얼로그가 떠서 값을 입력하여 저장할 수 있습니다.
        // 다이얼로그의 제목을 setDialogTitle 메소드로 설정하였습니다.
        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
        // 다이얼로그 카테고리 객체에 리스트 프리퍼런스 항목을 추가하고 있습니다.
        // 위의 에디트 항목밑에 추가가 됩니다.
        // 현재 항목을 클릭하면 리스트에서 선택할 수 있는 다이얼로그가 뜹니다.
        // 이때 나올 리스트 항목들을 /res/values/arrays.xml 정의한 배열항목들을
        // 키배열과 값배열 두개 배열을 각각 setEntries,setEntryValues 메소드로
        // 설정하고 있습니다.
        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
        // 새 카테고리 객체를 생성하여, 루트 PreferenceScreen 객체에 추가하고 있습니다.
        PreferenceCategory launchPrefCat = new PreferenceCategory(this);
        launchPrefCat.setTitle(R.string.launch_preferences);
        root.addPreference(launchPrefCat);
        /*
         * The Preferences screenPref serves as a screen break (similar to page
         * break in word processing). Like for other preference types, we assign
         * a key here so that it is able to save and restore its instance state.
         */
        // Screen preference
        // 새로 생성된 호출 카테고리 객체에, PreferenceScreen 프리퍼런스 항목객체를 추가하고 있습니다.
        // PreferenceScreen 는 하나의 독립된 프리퍼런스 액티비티 화면입니다.
        // 그래서 현재 프리퍼런스 항목을 클릭하면, 독립된 프리퍼런스 액티비티 화면이 뜨게 됩니다.
        // 이 프리퍼런스 액티비티 화면에 표시될 프리퍼런스 항목을 밑에서 추가를 하고 있습니다.
        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);

        /*
         * You can add more preferences to screenPref that will be shown on the
         * next screen.
         */

        // Example of next screen toggle preference
        // 체크박스 프리퍼런스 항목객체를 하나 생성해서, 위에서 만든 프리퍼런스 액티비티 객체에
        // 추가하고 있습니다. 즉 위에서 추가한 프리퍼런스 액티비티 항목을 클릭하면,
        // 독립된 액티비티가 뜨고, 그 안에는 현재의 체크박스 항목이 나오게 됩니다.
        // 다른 항목들을 PreferenceScreen 객체에 더 추가하게 되면, 추가한 대로
        // 독립된 프리퍼런스 액티비티 화면에 나오게 됩니다.
        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
        // 독립된 프리퍼런스 액티비티 항목객체를 하나 생성하여, 호출카테고리에 추가하여,
        // 현재 항목을 누르면, 인텐트를 방송하여 Intent.ACTION_VIEW 액션을 수행하는
        // 내부프로그램에 전달하여, 특정 데이터를 설정하여 실행이 되도록 합니다.
        // 독립된 액티비티가 뜨면서, 웹뷰가 http://www.android.com 경로를 띄우도록 실행이 됩니다.
        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.
        // 체크박스 프리퍼런스 항목을 생성하여 위의 속성 카테고리에 추가하고 있습니다.
        // /res/values/attrs.xml 파일에 정의된 <declare-styleable> 태그안에 정의된
        // <attr name="android:preferenceLayoutChild" /> 속성을 읽어와서,
        // 체크박스의 레이아웃을 설정하고 있습니다.
        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;
    }
}
문자열 리소스들을 /res/values/strings.xml 파일에 추가합니다.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, Test006!</string>
    <string name="app_name">Test006</string>

    <string name="inline_preferences">In-line preferences</string>
    <string name="dialog_based_preferences">Dialog-based preferences</string>
    <string name="launch_preferences">Launch preferences</string>
    <string name="preference_attributes">Preference attributes</string>
    <string name="title_toggle_preference">Toggle preference</string>
    <string name="summary_toggle_preference">This is a toggle button</string>
    <string name="title_edittext_preference">Edit text preference</string>
    <string name="summary_edittext_preference">An example that uses an edit text dialog</string>
    <string name="dialog_title_edittext_preference">Enter your favorite animal</string>
    <string name="title_list_preference">List preference</string>
    <string name="summary_list_preference">An example that uses a list dialog</string>
    <string name="dialog_title_list_preference">Choose one</string>
    <string name="title_screen_preference">Screen preference</string>
    <string name="summary_screen_preference">Shows another screen of preferences</string>
    <string name="title_next_screen_toggle_preference">Toggle preference</string>
    <string name="summary_next_screen_toggle_preference">Preference that is on the next screen but same hierarchy</string>
    <string name="title_intent_preference">Intent preference</string>
    <string name="summary_intent_preference">Launches an Activity from an Intent</string>
    <string name="title_parent_preference">Parent toggle</string>
    <string name="summary_parent_preference">This is visually a parent</string>
    <string name="title_child_preference">Child toggle</string>
    <string name="summary_child_preference">This is visually a child</string>
<string name="preferences_from_code">App/Preferences/5. Preferences from code</string>

</resources>

배열항목들을 /res/values/arrays.xml 파일에 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>

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

속성항목들을 /res/values/attrs.xml 파일에 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>

<resources>
    
    <declare-styleable name="TogglePrefAttrs">
        <attr name="android:preferenceLayoutChild" />
    </declare-styleable>
</resources>
마지막으로 AndroidManifest.xml 파일에 다음과같이 설정해줍니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="korsoft.net.Test006"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".PreferencesFromCode" android:label="@string/preferences_from_code">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>
        </activity>
    </application>
</manifest>

그럼 모두 즐프하세요 ^^

[android] 프리퍼런스 액티비티 항목에 기본값 설정하기

2011-05-14T15:14:00.000-07:00

안녕하세요?
프쟁이 입니다.

이 샘플소스는 안드로이드 설치폴더에 android-sdk-windows\samples\android-8\ApiDemos 위치에 원본소스가 있습니다.

프리퍼런스 액티비티를 처음 실행했을때, 설정하고 싶은 기본값들이 있을 수 있습니다.

/res/xml/프리퍼런스레이아웃.xml 파일에 프리퍼런스 항목들을 설정할 때,

android:defaultValue="" 속성에다 원하시는 기본값을 설정하시면 됩니다.

먼저 프리퍼런스 액티비티 파일을 원하시는 패키지 경로에 추가합니다.

여기에서는 DefaultValues.java 파일로 추가 합니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package korsoft.net.Test005;
import korsoft.net.Test005.R;
import android.app.Application;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceActivity;
import android.preference.PreferenceManager;
/**
* This activity is an example of a simple settings screen that has default
* values.
* <p>
* In order for the default values to be populated into the
* {@link SharedPreferences} (from the preferences XML file), the client must
* call
* {@link PreferenceManager#setDefaultValues(android.content.Context, int, boolean)}.
* <p>
* This should be called early, typically when the application is first created.
* This ensures any of the application's activities, services, etc. will have
* the default values present, even if the user has not wandered into the
* application's settings. For ApiDemos, this is {@link ApiDemosApplication},
* and you can find the call to
* {@link PreferenceManager#setDefaultValues(android.content.Context, int, boolean)}
* in its {@link ApiDemosApplication#onCreate() onCreate}.
*/
public class DefaultValues extends PreferenceActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        /*
         * This populates the default values from the preferences XML file. See
         * {@link DefaultValues} for more details.
         * 반드시 처음 시작하는 메인 액티비티에서 setDefaultValues 메소드가 실행되어야 합니다.
         * 프리퍼런스 레이아웃 xml 파일에서 읽어와서 현재 프리퍼런스 액티비티의 항목들에
         * 기본값을 셋팅합니다.
         */
        PreferenceManager.setDefaultValues(this, R.xml.default_values, false);

        /*
         * /res/xml/default_values.xml 프리퍼런스 액티비티 레이아웃 파일을 읽어와
         * 현재 프리퍼런스 액티비티에 레이아웃을 적용시킵니다.
         * 보통 액티비티는 /res/layout/~~.xml 파일을 setContentView(..) 함수로
         * 적용시킬 테지만, 프리퍼런스 액티비티는 xml 레이아웃 파일을 레이아웃으로
         * 정의하고, addPreferencesFromResource 함수로 이를 불러와 적용시킵니다.
         */
        addPreferencesFromResource(R.xml.default_values);
    }
}
위의 프리퍼런스 액티비티의 레이아웃을 정의하는 xml 파일을 추가합니다.

/res/xml/default_values.xml 파일을 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>


<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>
문자열 리소스들을 /res/values/strings.xml 파일에 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, Test005!</string>
    <string name="app_name">Test005</string>

    <string name="title_checkbox_preference">Checkbox preference</string>
    <string name="summary_checkbox_preference">This is a checkbox</string>
    <string name="default_value_list_preference">beta</string>
    <string name="default_value_edittext_preference">Default value</string>
    <string name="title_edittext_preference">Edit text preference</string>
    <string name="summary_edittext_preference">An example that uses an edit text dialog</string>
    <string name="dialog_title_edittext_preference">Enter your favorite animal</string>
    <string name="title_list_preference">List preference</string>
    <string name="summary_list_preference">An example that uses a list dialog</string>
    <string name="dialog_title_list_preference">Choose one</string>
    <string name="default_values">App/Preferences/4. Default values</string>

</resources>
프리퍼런스 액티비티 항목중 리스트 항목에 사용될 배열항목을 /res/values/arrays.xml 파일에 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>

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

마지막으로 AndroidManifest.xml 파일을 다음과 같이 설정합니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="korsoft.net.Test005"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".DefaultValues" android:label="@string/default_values">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

그럼 모두들즐프하세요. ^^

[android] 프리퍼런스 - 의존관계의 프리퍼런스 항목

2011-05-14T14:19:00.000-07:00

안녕하세요?
프쟁이 입니다.

이 샘플소스는 안드로이드 설치폴더에 android-sdk-windows\samples\android-8\ApiDemos 위치에 원본소스가 있습니다.

프리퍼런스 액티비티의 항목사이에 서로 의존적인 관계가 필요한 경우가 있을 수 있습니다.

예를들어, 폰트를 설정하는데, 먼저 폰트를 설정할 것인지 아닌지 체크항목이 있고,

그리고 폰트종류가 나오면서 폰트종류를 설정하는 항목 두개가 있다고 하면,

먼저 폰트종류 선택항목은 폰트설정여부 항목이 체크되어있을때만 활성화가 되고,

폰트설정항목이 체크가 되어있지 않으면, 폰트종류 선택항목은 비활성화 되어야 합니다.

이런 관계가 바로 항목들끼리 의존관계가 되는 것입니다.

현재 프로그램에서는 프리퍼런스 항목이 두개가 있습니다.

하나는 체크박스 항목과, 다른 하나는 이 체크박스가 체크되었을때 활성화 되어

내용을 입력받을 수 있는 에디트 항목입니다.

먼저 프리퍼런스 액티비티 클래스 파일을 원하시는 패키지경로에 추가합니다.

PreferenceDependencies.java 파일명으로 추가하면 됩니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package 원하시는패키지경로;

import 원하시는패키지경로.R;

import android.os.Bundle;
import android.preference.PreferenceActivity;

public class PreferenceDependencies extends PreferenceActivity {

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

// /res/xml/preference_dependencies.xml 파일에서 현재 액티비티의
// 레이아웃 정의를 가져와 적용을 합니다.
addPreferencesFromResource(R.xml.preference_dependencies);
}

}
이제 위의 프리퍼런스 액티비티에서 레이아웃을 정의하는 파일을
/res/xml/preference_dependencies.xml 경로로 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2008 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->

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

문자열 리소스를 /res/values/strings.xml 파일에 추가해줍니다.

<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello World, Test004!</string>
<string name="app_name">Test004</string>
<string name="example_preference_dependency">Example preference dependency</string>
<string name="title_wifi">WiFi</string>
<string name="title_wifi_settings">WiFi settings</string>
<string name="preference_dependencies">App/Preferences/3. Preference dependencies</string>
</resources>

마지막으로 AndroidManifest.xml 파일에 다음과 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="프로그램패키지경로명"
android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="8" />

</application>
</manifest>

그럼 모두들 즐프하세요. ^^

[android] 프리퍼런스 - 여러가지 기법들

2011-05-13T12:19:00.001-07:00

안녕하세요 ^^
프쟁이 입니다.

이 샘플소스는 안드로이드 설치폴더에 android-sdk-windows\samples\android-8\ApiDemos 위치에 원본소스가 있습니다.

프리퍼런스의 내용을 하나씩 값/쌍 형태로 불러오지 않고,

공유 프리퍼런스 객체를 모두 가져와서 처리를 하고 있습니다.

데이터를 가져올때 프리퍼런스 액티비티를 띄워서 처리를 하지 않고,

그 레이아웃 xml 파일을 인자로 넘겨서, 그 프리퍼런스 액티비티의

모든 공유 프리퍼런스의 값들을 가져와서 처리를 하고 있습니다.

먼저 메인 액티비티 클래스 파일을 원하시는 패키지 경로로 하나 추가합니다.
여기서는 LaunchingPreferences.java 파일이 메인 액티비티 클래스 파일입니다.

이 액티비티는 레이아웃xml 파일에서 레이아웃을 표시하지 않고,

onCrate 메소드에서 동적으로 코드상에서 레이아웃을 정의하여 표시하고 있습니다.

프리퍼런스 액티비티를 띄우는 버튼 하나와, 그 밑에 프리퍼런스 액티비티의

공유 프리퍼런스 값을 가져와서 그 값을 표시하는 처리를 합니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package 원하시는패키지경로;

import 원하시는패키지경로.R;

import android.content.Context;
import android.content.res.TypedArray;
import android.os.Parcel;
import android.os.Parcelable;
import android.preference.Preference;
import android.util.AttributeSet;
import android.view.View;
import android.widget.TextView;

/**
* This is an example of a custom preference type. The preference counts the
* number of clicks it has received and stores/retrieves it from the storage.
* 이 클래스는 프리퍼런스 항목클래스 입니다. Preference 클래스를 상속받아서 구현합니다.
* 프리퍼런스 항목은 프리퍼런스 액티비티의 리스트에 하나의 항목으로 배치가 됩니다.
* 기본적으로 체크박스, 에디트박스, 등의 프리퍼런스 항목이 있고,
* 지금의 클래스처럼, 사용자가 직접 레이아웃등을 정의하고, 이렇게 그 동작등을
* 정의하는 사용자 정의 프리퍼런스 항목을 만들 수 있습니다.
*/
public class MyPreference extends Preference {
// 이 프리퍼런스 항목을 클릭할때마다 증가할 값을 저장할 정수변수입니다.
private int mClickCounter;

// This is the constructor called by the inflater
// 생성자로서, 이 내용은 프리퍼런스 액티비티에서 레이아웃을
// 적용할때, 이 클래스로 정의된 프리퍼런스 객체들이 각각 이 생성자를
// 실행하게 됩니다.
public MyPreference(Context context, AttributeSet attrs) {
super(context, attrs);

// 레이아웃 xml 을 읽어와서, 이 프리퍼런스 항목의 레이아웃을 적용합니다.
// /res/layout/preference_widget_mypreference.xml 파일을
// 적용하고 있습니다. 텍스트뷰 하나가 정의되어 있습니다.
// 여기서 레이아웃은, 프리퍼런스 액티비티 안에는 리스트 형태로 각 프리퍼런스
// 항목들이 있구요, 이 프리퍼런스 항목은 제목과 내용이 기본적으로 표시되고,
// 이 레이아웃이 적용되는 부분은, 제목과 내용 우측에 조그만 사각영역안에
// 이 레이아웃이 표시됩니다. 전체 프리퍼런스 항목이 표시되는 것이 아닙니다.
// 체크박스 프리퍼런스 항목을 봐도, 우측에 체크박스 하나가 있고, 좌측에는
// 다른 프리퍼런스 항목들과 동일하게 제목 내용 등의 동일한 형태로 있습니다.
// 즉 우측의 영역에서만 이 레이아웃이 적용됩니다.
setWidgetLayoutResource(R.layout.preference_widget_mypreference);
}

/*
* (non-Javadoc)
* @see android.preference.Preference#onBindView(android.view.View)
* 현재 프리퍼런스 항목이 레이아웃이 프리퍼런스 액티비티에 표시가 완료되는 시점에,
* 내부의 객체들을 참조하기 위한 뷰객체를 파라미터로 넘겨주게 됩니다.
*/
@Override
protected void onBindView(View view) {
super.onBindView(view);

// Set our custom views inside the layout
// preference_widget_mypreference.xml 레이아웃 파일의 텍스트 뷰객체를 가져와서,
// 증가한 값을 뷰에 표시하고 있습니다. 이 프리퍼런스 항목의 제목과 내용의 우측에 보시면,
// 숫자가 계속해서 증가할 것입니다.
final TextView myTextView = (TextView) view.findViewById(R.id.mypreference_widget);
if (myTextView != null) {
myTextView.setText(String.valueOf(mClickCounter));
}
}

/*
* (non-Javadoc)
* @see android.preference.Preference#onClick()
* 현재 프리퍼런스 항목을 클릭했을때, 호출되는 메소드 입니다.
* 내부 정수변수의 값을 1증가합니다. 그리고 변경된 사실을 시스템에 알려서,
* 값이 변경되었음을 알립니다.
*/
@Override
protected void onClick() {
int newValue = mClickCounter + 1;

// Give the client a chance to ignore this change if they deem it
// invalid
// callChangeListener 메소드는 등록된 OnPreferenceChangeListener 메소드를
// 통해 값의 변했다고, 외부에 알리는 메소드 입니다.
// 이 프리퍼런스 클래스 안에서는 등록된 OnPreferenceChangeListener 메소드가
// 없으므로, 이 메소드는 동작을 안합니다.
if (!callChangeListener(newValue)) {
// They don't want the value to be set
return;
}

// Increment counter
mClickCounter = newValue;

// Save to persistent storage (this method will make sure this
// preference should be persistent, along with other useful checks)
// persistInt 메소드에 정수값을 넘겨서 공유된 프리퍼런스 영역에 영구저장하게 됩니다.
persistInt(mClickCounter);

// Data has changed, notify so UI can be refreshed!
// notifyChanged 메소드는 UI를 갱신하기 위한 메소드로, 현재 프리퍼런스 항목클래스의
// onBindView 메소드를 호출하게 됩니다. 즉 변경된 값이 텍스트 뷰에 표시되게 됩니다.
notifyChanged();
}

/*
* (non-Javadoc)
* @see android.preference.Preference#onGetDefaultValue(android.content.res.TypedArray, int)
* /res/layout/preference_widget_mypreference.xml 파일에 정의된 프리퍼런스 항목의 레이아웃 항목의
* defaultValue 속성값을 가져와서 디폴트값을 반환해 줍니다.
* 설정한 값의 데이터 종류에 따라서 정수형 등의 원하는 형태로 디폴트값을 반환해 주면 됩니다.
*/
@Override
protected Object onGetDefaultValue(TypedArray a, int index) {
// This preference type's value type is Integer, so we read the default
// value from the attributes as an Integer.
return a.getInteger(index, 0);
}

/*
* (non-Javadoc)
* @see android.preference.Preference#onSetInitialValue(boolean, java.lang.Object)
* 프리퍼런스 항목의 초기값을 설정하기 위한 메소드 입니다.
* restoreValue 가 true 이면 레이아웃 xml 로부터 현재 프리퍼런스 항목이 표시될때 입니다.
* 그리고 false 이면 반대로 레이아웃이 사라질때 호출됩니다.
* 그래서 true 일때 초기값을 설정하고, false 일때는 공유 프리퍼런스 영역에 값을 영구 저장합니다.
*/
@Override
protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
if (restoreValue) {
// Restore state
mClickCounter = getPersistedInt(mClickCounter);
} else {
// Set state
int value = (Integer) defaultValue;
mClickCounter = value;
persistInt(value);
}
}

/*
* (non-Javadoc)
* @see android.preference.Preference#onSaveInstanceState()
* 아래 두 함수는, 스마트폰의 화면이 세로로 보다가 가로로 바뀌면,
* 현재 값을 잃어버리기 때문에, 그런 예기치 못한 상황에서 현재값을
* 저장했다가, 다시 복구하는 두개의 메소드 입니다.
*/
@Override
protected Parcelable onSaveInstanceState() {
/*
* Suppose a client uses this preference type without persisting. We
* must save the instance state so it is able to, for example, survive
* orientation changes.
*/

final Parcelable superState = super.onSaveInstanceState();
if (isPersistent()) {
// No need to save instance state since it's persistent
return superState;
}

// Save the instance state
final SavedState myState = new SavedState(superState);
myState.clickCounter = mClickCounter;
return myState;
}

@Override
protected void onRestoreInstanceState(Parcelable state) {
if (!state.getClass().equals(SavedState.class)) {
// Didn't save state for us in onSaveInstanceState
super.onRestoreInstanceState(state);
return;
}

// Restore the instance state
SavedState myState = (SavedState) state;
super.onRestoreInstanceState(myState.getSuperState());
mClickCounter = myState.clickCounter;
notifyChanged();
}

/**
* SavedState, a subclass of {@link BaseSavedState}, will store the state
* of MyPreference, a subclass of Preference.
* <p>
* It is important to always call through to super methods.
*/
private static class SavedState extends BaseSavedState {
int clickCounter;

public SavedState(Parcel source) {
super(source);

// Restore the click counter
clickCounter = source.readInt();
}

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

// Save the click counter
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];
}
};
}

}

AdvancedPreferences.java 클래스 파일을 원하시는 패키지 경로에 추가해주십니다.

이 클래스는, 위의 메인 액티비티에서 버튼을 클릭했을때 뜨는 프리퍼런스 액티비티 클래스 입니다.

프리퍼런스 액티비티 클래스는 PreferenceActivity 클래스를 상속받아서 구현된 클래스 입니다.

이 클래스도 액티비티이기 때문에, 일반 액티비티처럼 뜨지만, 일단 리스트 형태로 뜨고,

각 리스트의 항목들은 모두 Preference 클래스를 상속받은 프리퍼런스 항목들입니다.

이 프리퍼런스 항목의 종류는 체크박스, 에디트, 등등 기본적인 형이 있구요,

그외에 사용자가 원하는 형태로 직접 Preference 클래스를 상속받아서 직접 구현을 하셔서

사용하실 수 있습니다. 그리고 이 프리퍼런스 항목은 프리퍼런스 액티비티에 표시될때,

형태가 정해져 있습니다. 리스트의 항목형태로 표시되고, 항목에 제목 내용이 표시되고,

그리고 그 우측에 체크박스나, 사용자 레이아웃등을 적용시킬 수 있습니다.

코드는 다음과 같습니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package korsoft.net.Test003;

import korsoft.net.Test003.R;

import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.os.Bundle;
import android.os.Handler;
import android.preference.PreferenceActivity;
import android.preference.CheckBoxPreference;
import android.widget.Toast;

/**
* Example that shows finding a preference from the hierarchy and a custom preference type.
* 메인 액티비티에서 프리퍼런스 액티비티를 띄우는 버튼을 눌렀을때 뜨는 프리퍼런스 액티비티 클래스 입니다.
* 사용자 정의 프리퍼런스 클래스를 만들려면, Preference 클래스를 상속받아서 클래스를 정의하면 됩니다.
* 여기서는 MyPrefeence.java 파일에 이 사용자 정의 프리퍼런스 클래스를 정의하고 있습니다.
* 공유프리퍼런스객체의 값의 변화를 감지하여 처리하기 위하여, OnSharedPreferenceChangeListener 인터페이스를
* 구현하고 있습니다.
*/
public class AdvancedPreferences extends PreferenceActivity implements OnSharedPreferenceChangeListener {
/*
* /res/xml/advanced_preferences.xml 파일에 정의되어 있는 사용자정의 프리퍼런스 클래스인
* MyPreference 타입의 Preference 클래스 객체와 기본 프리퍼런스 클래스중의 하나인
* CheckBoxPreference 타입의 Preference 클래스 객체의 키값들을 각각 지정하고 있습니다.
*
* MyPreference 클래스는 사용자가 직접 정의한 프리퍼런스 클래스로, 현재 프리퍼런스 항목을
* 클릭할때마다, 정수값을 1씩 증가시키는 처리를 하고 있습니다.
*
* 현재 액티비티는 프리퍼런스 액티비티이고, 이 액티비티 안에 배치되는 항목들은 프리퍼런스
* 항목들입니다. 즉 Preference 클래스를 상속받아 구현된 클래스들 입니다.
* 기본적으로 체크박스, 에디트박스, .. 등의 기본적인 프리퍼런스 항목들이 있구요..
* 사용자가 직접 Preference 클래스를 상속받아서 만든 항목을 사용할 수 도 있습니다.
*/
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();

/**
* This is a simple example of controlling a preference from code.
* 체크박스가 자동으로 토글되도록 처리를 하는 쓰레드 클래스 객체입니다.
*/
private Runnable mForceCheckBoxRunnable = new Runnable() {
public void run() {
if (mCheckBoxPreference != null) {
//체크박스 체크상태를 토글시킵니다.
mCheckBoxPreference.setChecked(!mCheckBoxPreference.isChecked());
}

// Force toggle again in a second
// 1초후에 다시 이 run 함수를 호출하게 합니다. 1초동안 지연시킵니다.
mHandler.postDelayed(this, 1000);
}
};

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

// Load the XML preferences file
// 일반 액티비티의 setContentView(..) 처럼, 프리퍼런스 액티비티에서,
// xml 리소스에서 정의된 액티비티내의 항목들을 가져와서,
// 현재 프리퍼런스 액티비티에 표시를 합니다.
addPreferencesFromResource(R.xml.advanced_preferences);

// Get a reference to the checkbox preference
// /res/xml/advanced_preferences.xml 파일에 정의된 체크박스 태그의 key 속성값을
// 이용하여, 체크박스객체의 참조값을 가져옵니다.
mCheckBoxPreference = (CheckBoxPreference)getPreferenceScreen().findPreference(
KEY_ADVANCED_CHECKBOX_PREFERENCE);
}

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

// Start the force toggle
// 위에서 체크박스가 토글되도록 정의한 Runnable 쓰레드 객체의 실행을 시작합니다.
mForceCheckBoxRunnable.run();

// Set up a listener whenever a key changes
// 현재 프리퍼런스의 공유 프리퍼런스가 변경될때마다 아래에 정의된 onSharedPreferenceChanged
// 메소드를 호출하도록, 공유 프리퍼런스 객체의 registerOnSharedPreferenceChangeListener
// 메소드를 호출합니다.
// 그러면 현재 액티비티 내의 항목들의 값이 바뀔때마다, 변경리스너가 감시하여, onSharedPreferenceChanged
// 메소드가 호출하여, 그 메소드 안에서 토스트 메시지를 띄우게 됩니다.
getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
}

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

// Unregister the listener whenever a key changes
// 현재 프리퍼런스 액티비티의 내의 공유 프리퍼런스의 값의 변경을 감시하는 리스너를 해제합니다.
// 즉 공유 프리퍼런스의 값의 변경을 더이상 감지하지 않습니다.
getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);

// 체크박스 토글 쓰레드의 실행을 해제합니다. 여기서 해제하지 않으면, 이 액티비티가 종료되어도
// 계속해서 실행되어, 오류가 발생하게 됩니다.
mHandler.removeCallbacks(mForceCheckBoxRunnable);
}

/*
* (non-Javadoc)
* @see android.content.SharedPreferences.OnSharedPreferenceChangeListener#onSharedPreferenceChanged(android.content.SharedPreferences, java.lang.String)
* 위에서 공유 프리퍼런스의 값의 변경을 감지하는 리스너를 등록하여, 값이 변경될때마다 이 메소드가
* 호출될 것입니다. 이 안에서 변경된 값을 가져와서 처리를 합니다.
* 여기서는 토스트 메시지를 띄우고 있습니다.
*/
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
// Let's do something when my counter preference value changes
if (key.equals(KEY_MY_PREFERENCE)) {
Toast.makeText(this, "Thanks! You increased my count to "
+ sharedPreferences.getInt(key, 0), Toast.LENGTH_SHORT).show();
}
}

}

위의 프리퍼런스 액티비티의 레이아웃 파일을 /res/xml/advanced_preferences.xml 파일을 추가합니다.

원래 일반 액티비티의 레이아웃 파일은 /res/layout/레이아웃파일.xml 형태로 정의해서, onCreate 메소드에서

setViewContent(..)식으로 레이아웃을 적용시키지만, 프리퍼런스 액티비티의 레이아웃 파일은 그냥 xml 리소스 파일로

정의를 합니다. 내용은 다음과 같습니다.

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2008 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

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

<사용자정의프리퍼런스객체패키지경로.MyPreference
android:key="my_preference"
android:title="@string/title_my_preference"
android:summary="@string/summary_my_preference"
android:defaultValue="100" />

</PreferenceScreen>

이제 위의 프리퍼런스 액티비티에 표시될 사용자 정의 프리퍼런스 항목의 클래스를 원하시는 패키지 경로에 파일을 MyPreference.java 이름으로 추가해 주세요.

이 프리퍼런스 항목 클래스는, 위의 프리퍼런스 액티비티의 리스트에서 첫번째 항목에 표시되는

항목입니다. Preference 객체를 상속받아서 클래스를 구현하게 됩니다.

항목을 클릭시마다 정수값을 1씩 증가하는 처리를 하는 사용자 정의 프리퍼런스 항목을 구현하고 있습니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package 원하시는패키지명;

import 원하시는패키지명.R;

// Save the instance state
final SavedState myState = new SavedState(superState);
myState.clickCounter = mClickCounter;
return myState;
}

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

// Save the click counter
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];
}
};
}

}

그리고 이 프리퍼런스 항목은 따로 레이아웃을 적용하고 있습니다.

텍스트 뷰 하나를 정의하고 있습니다.

/res/layout/preference_widget_mypreference.xml 파일을 추가하시고, 내용을 입력해주세요.

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2006 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->

<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/mypreference_widget"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical"
android:layout_marginRight="6sp"
android:focusable="false"
android:clickable="false" />

/res/values/strings.xml 파일내용을 다음과 같이 설정해줍니다.

<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello World, Test003!</string>
<string name="app_name">Test003</string>

<string name="title_my_preference">My preference</string>
<string name="summary_my_preference">This is a custom counter preference</string>

<string name="title_advanced_toggle_preference">Haunted preference</string>
<string name="summary_on_advanced_toggle_preference">I\'m on! :)</string>
<string name="summary_off_advanced_toggle_preference">I\'m off! :(</string>

<string name="launch_preference_activity">Launch PreferenceActivity</string>
<string name="counter_value_is">The counter value is</string>

<string name="preferences_from_xml">App/Preferences/1. Preferences from XML</string>
<string name="launching_preferences">App/Preferences/2. Launching preferences</string>
<string name="preference_dependencies">App/Preferences/3. Preference dependencies</string>
<string name="default_values">App/Preferences/4. Default values</string>
<string name="preferences_from_code">App/Preferences/5. Preferences from code</string>
<string name="advanced_preferences">App/Preferences/6. Advanced preferences</string>
</resources>

AndroidManifest.xml 파일을 다음과 같이 설정해줍니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="korsoft.net.Test003"
android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="8" />

<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />

<activity android:name=".LaunchingPreferences" android:label="@string/launching_preferences">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>


<activity android:name=".AdvancedPreferences" android:label="@string/advanced_preferences">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.SAMPLE_CODE" />
</intent-filter>
</activity>

</application>
</manifest>

그럼 모두들 즐프하세요!! ^^

[android] xml로 정의한 프리퍼런스(저장소) 연동 레이아웃

2011-05-10T11:12:00.000-07:00

안녕하세요?
프쟁이 입니다.
이 샘플소스는 안드로이드 설치폴더에 android-sdk-windows\samples\android-8\ApiDemos 위치에 원본소스가 있습니다.

안드로이드에서는 데이터를 저장하는 방식이, 디비/파일/프리퍼런스 이렇게

세가지가 있습니다. 프리퍼런스는 저장방식을 편리하고 다양하고 여러방식들을

제공하기 때문에, 상황에 따라서 프리퍼런스를 이용하여 저장하면, 편리하게

데이터를 저장하고 불러오실 수 있습니다.

기존에는 화면 레이아웃을 모두 /res/layout/레이아웃파일명.xml 파일에다

모두 설정을 해서 액티비티 클래스에서 가져다 적용을 했습니다.

그러나 이번엔 좀 다른방식으로, 화면 레이아웃을 레이아웃xml 파일이 아닌

Preference 저장소와 바로 연동되는 화면 레이아웃 xml 파일을 정의하여,

액티비티를 띄운 이후부터, 모든 화면안의 항목의 선택이라든지, 기타 등등의

선택액션들을 모두 자동으로 Preference 에 저장이 되는 방식의 액티비티를

구현해 보겠습니다. 전에는 Preference 를 객체를 생성하여, 키/값 쌍으로

저장했다가, 다시 객체를 생성하여 불러오는 식으로 일일이 수동으로 작업을

했지만, 이번에는 일체 그런 코드작업 없이, 그냥 xml 파일 하나만 정의를

해서 불러오기만 하면, 그 xml 파일에서 화면을 적용하고, 액티비티를 불러온

후 모든 액션들이 자동으로 저장되었다가, 액티비티를 종료했다가 다시 띄워도,

최종 상태를 계속 유지하는 방식의 액티비티를 구현하겠습니다.

먼저 그 Preference 화면 레이아웃 xml 파일을 정의하겠습니다.

/res/xml/preferences.xml 파일을 추가하고, 다음과 같이 입력합니다.

이 파일안에 화면 레이아웃정의도 모두 포함되어 있습니다.

이전에 /res/layout/ 폴더안에 xml 파일을 만든것과는 달리, 이 파일은 일단

/res/xml/ 폴더안에 xml 파일을 만듭니다.

<?xml version="1.0" encoding="utf-8"?>



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

이제 위와 같이 화면 레이아웃을 xml 파일로 정의를 하셨으면, 이제 액티비티 클래스 파일에서

위의 xml 파일을 읽어들여서 적용을 해야합니다.

그런데 지금까지와는 좀 방식이 다른점이 있습니다.

지금까지는 액티비티 클래스를 Activity 클래스를 상속받아서, onCreate 등에서 setContentView(..)

를 통해서, 화면 레이아웃을 적용시켰지만, 위의 xml 파일은 그런 방식이 아닌 PreferenceActivity

클래스를 상속받아서 처리를 하게 됩니다. 그리고 setContentView(..) 대신에, addPreferencesFromResource

메소드로 화면을 적용합니다.

public class 액티비티클래스명 extends PreferenceActivity {

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

        // Load the preferences from an XML resource
        addPreferencesFromResource(R.xml.preferences);
    }

}

/res/values/strings.xml 파일에 다음과 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, Test002!</string>
    <string name="app_name">Test002</string>
    <string name="inline_preferences">In-line preferences</string>
    <string name="dialog_based_preferences">Dialog-based preferences</string>
    <string name="launch_preferences">Launch preferences</string>
    <string name="preference_attributes">Preference attributes</string>
    <string name="title_toggle_preference">Toggle preference</string>
    <string name="summary_toggle_preference">This is a toggle button</string>
    <string name="title_edittext_preference">Edit text preference</string>
    <string name="summary_edittext_preference">An example that uses an edit text dialog</string>
    <string name="dialog_title_edittext_preference">Enter your favorite animal</string>
    <string name="title_list_preference">List preference</string>
    <string name="summary_list_preference">An example that uses a list dialog</string>
    <string name="dialog_title_list_preference">Choose one</string>
    <string name="title_screen_preference">Screen preference</string>
    <string name="summary_screen_preference">Shows another screen of preferences</string>
    <string name="title_next_screen_toggle_preference">Toggle preference</string>
    <string name="summary_next_screen_toggle_preference">Preference that is on the next screen but same hierarchy</string>
    <string name="title_intent_preference">Intent preference</string>
    <string name="summary_intent_preference">Launches an Activity from an Intent</string>
    <string name="title_parent_preference">Parent toggle</string>
    <string name="summary_parent_preference">This is visually a parent</string>
    <string name="title_child_preference">Child toggle</string>
    <string name="summary_child_preference">This is visually a child</string>
    <string name="preferences_from_xml">App/Preferences/1. Preferences from XML</string>
    <string name="launching_preferences">App/Preferences/2. Launching preferences</string>
    <string name="preference_dependencies">App/Preferences/3. Preference dependencies</string>
    <string name="default_values">App/Preferences/4. Default values</string>
    <string name="preferences_from_code">App/Preferences/5. Preferences from code</string>
    <string name="advanced_preferences">App/Preferences/6. Advanced preferences</string>
</resources>

/res/values/arrays.xml 파일을 추가하시고, 다음과 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>

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

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

이제 마지막으로 AndroidManifest.xml 파일에 다음과 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="패키지명.."
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />

    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".PreferencesFromXml" android:label="@string/preferences_from_xml">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

그럼 모두들 즐프하세요. ^^

[android] 상태바 알림 표시

2011-05-10T08:21:00.000-07:00

안녕하세요?
프쟁이 입니다. ^^

안드로이드 설치폴더에 android-sdk-windows\samples\android-8\ApiDemos 위치에 원본소스가 있습니다.

각종 알림을 옵션별로 실행하는 예제입니다.

알림바에 아이콘만 나오게 하고, 제목도 같이 나오게 하고, 진동/빛/사운드를 같이 발생시키기도 합니다.

먼저 가장먼저 시작되는 액티비티 클래스인, StatusBarNotifications.java 파일을
원하시는 위치에 만들어 주시고 다음과 같이 입력합니다.

StatusBarNotifications.java

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package 패키지경로;

import 패키지경로.R;

import android.app.Activity;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.RemoteViews;

/**
* Demonstrates adding notifications to the status bar
* 앱을 실행하면, 처음에 뜨는 액티비티 입니다.
* 화면의 첫번째 줄에는, 아이콘만 화면상단의 알림바에 표시를 하는 버튼이 세개가 있습니다.
* 화면의 두번째 줄에는, 아이콘과 텍스트를 알림바에 표시를 하는 버튼이 세가지가 있습니다.
* 화면의 서번째 줄에는, 아이콘과 텍스트를 알림바에 표시하고, 알림바를 밑으로 드래그한
*   알림 상세화면에서, 알림항목에 기본형태의 알림항목이 아닌, 사용자가 정의한 레이아웃을
*   적용한 알림항목을 표시하게 됩니다.
*   두번째 줄에서는, 메뉴항목이 기본적으로 아이콘/제목/내용 이 세가지가 표시되는 형식입니다.
* 화면의 네번째 줄에는, 소리를 내면서 알림을 표시하는 버튼과, 진동을 하면서 알림을 표시하는
*   버튼, 그리고 소리를 내면서 진동을 표시하는 버튼이 있습니다.
* 그리고 마지막줄에 clear~~ 버튼을 누르면, 위에서 생성했던 알림을 알림바에서 삭제를 합니다.
*/
public class StatusBarNotifications extends Activity {

    //알림매니저 객체변수입니다.
private NotificationManager mNotificationManager;

    // Use our layout id for a unique identifier
//생성할 알림의 고유아이디값으로 status_bar_notifications 레이아웃의 리소스
//아이디 값으로 설정합니다. 이후에 알림항목을 클릭했을때, 반투명 배경의 새로 뜨는
//NotificationDisplay 액티비티에서, 알람을 취소시키기 위해서, 이 아이디값을
//사용하게 됩니다.
    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;

        // Get the notification manager serivce.
        //시스템으로부터 알림매너저 객체를 가져옵니다.
        mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        //버튼객체를 클릭했을때, 알림을 발생시키는 함수인, setMood 함수를 호출합니다.
        //R.drawable.stat_happy 는 아이콘 리소스 아이디 입니다.(/res/drawable-hdpi/ 폴더에 위치)
        //R.string.status_bar_notifications_happy_message 는 알림바에 표시될 제목문자열 입니다.
        //마지막 true / false 인자는, 알림바에 제목을 표시할지 / 안할지 여부를 결정하는 값입니다.
        //여기서는 false 이므로 알림바에 제목문자열이 나오지 않고, 그냥 아이콘만 표시가 됩니다.
        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);
            }
        });

        //아래 세개의 버튼에서는, setMood 함수의 마지막 인자가 true를 넘기기 때문에,
        //알림바에 아이콘과 제목을 같이 출력을 합니다.
        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);
            }
        });

        //아래 세개의 버튼클릭 메서드에서는, setMoodView 함수를 호출하고 있습니다.
        //이 메소드는, 알림바에 아이콘과 제목을 표시하고, 알림바를 밑으로 드래그하여 확장시켜보면,
        //알림항목이 일반적인 알림항목과 다르게, 사용자정의 레이아웃을 적용한 상태인 것을 알 수 있습니다.
        // /res/layout/status_bar_balloon.xml 레이아웃 파일을 적용이 되었습니다.
        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);
            }
        });

        //위 버튼들에서 발생시킨 알림을 고유식별자인 R.layout.status_bar_notifications
        //값을 넘겨서, 알림을 해제시킵니다. 알림바에서 사라집니다.
        button = (Button) findViewById(R.id.clear);
        button.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                mNotificationManager.cancel(R.layout.status_bar_notifications);
            }
        });
    }

    //알림을 발생시킬때 사용할 인텐트를 설정하고, 반환합니다.
    //moodId 인자는, 알림바에 표시할 아이콘 이미지의 리소스 아이디값입니다.
    private PendingIntent makeMoodIntent(int moodId) {
        // The PendingIntent to launch our activity if the user selects this
        // notification. Note the use of FLAG_UPDATE_CURRENT so that if there
        // is already an active matching pending intent, we will update its
        // extras to be the ones passed in here.
    // 인텐트에 추가값을 .putExtra("moodimg", moodId) 이렇게 심어서,
    // 이후에 다른 액티비티에서 이 인텐트를 넘겨받아서, 저장한 값을
    // 불러와서 처리를 하게 됩니다.
    // 그리고 인텐트를 셋팅하는데, NotificationDisplay 클래스를 설정하고 있습니다.
    // 이 설정은, 알림바를 펼쳤을때, 알림항목을 클릭했을때, 뜨는 액티비티의
    // 클래스를 설정하는 것입니다.
        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;
    }

    /*
     * 알림을 생성하여, 알림바에 알림을 표시하게 됩니다.
     * moodId 인자는 알림바에 표시될 아이콘 이미지의 리소스 아이디값(R.drawable.이미지명)입니다.
     * showTicker 는 true / false 값으로, 알림바에 제목문자열을 표시할지 안할지를 결정합니다.
     */
    private void setMood(int moodId, int textId, boolean showTicker) {
        // In this sample, we'll use the same text for the ticker and the expanded notification
    // 알림바를 펼쳤을때 나오는 알림항목의 내용부분에 들어갈 텍스트 문자열값입니다.
    // 여기서는 제목과 동일하게 셋팅하고 있습니다.
        CharSequence text = getText(textId);

        // choose the ticker text
        // 알림바에 표시할 제목 문자열을 showTicker 변수값에 따라서 선택적으로 셋팅하고 있습니다.
        String tickerText = showTicker ? getString(textId) : null;

        // Set the icon, scrolling text and timestamp
        // 알림 객체를 생성합니다. 알림바에 표시될 아이콘과 제목문자열을 설정하고 있습니다.
        Notification notification = new Notification(moodId, tickerText,
                System.currentTimeMillis());

        // Set the info for the views that show in the notification panel.
        // 알림항목에 표시될 제목문자열, 내용문자열, 클릭시 실행될 액티비티 정보가 담긴,
        // PendingIntent 객체를 셋팅하고 있습니다.
        // 알림항목을 클릭하면, NotificationDisplay 클래스 액티비티가 뜹니다.
        // 배경이 반투명하고, 정중앙에 이미지 버튼 하나 있는 액티비티 입니다.
        notification.setLatestEventInfo(this, getText(R.string.status_bar_notifications_mood_title),
                       text, makeMoodIntent(moodId));

        // Send the notification.
        // We use a layout id because it is a unique number. We use it later to cancel.
        // 알림 매니저 객체의 notify 메소드에 알림 고유아이디 값인 status_bar_notifications 레이아웃의
        // 리소스 아이디 정수값을 넘기고, 위에서 설정한 알림객체를 넘겨서, 실제로 알림을
        // 알림바에 발생시킵니다.
        mNotificationManager.notify(R.layout.status_bar_notifications, notification);
    }

    /*
     * setMood 와 같이 알림을 발생시킵니다.
     * 차이점은, 이 메소드는, 알림바를 펼쳤을때 나오는 알림항목의 레이아웃이,
     * 기본적인 제목/내용/아이콘 식으로 출력되는 것이 아닌,
     * 사용자가 정의한 레이아웃을 적용한 알림항목이 출력됩니다.
     * 여기서는 status_bar_balloon.xml 레이아웃을 적용시키고 있습니다.
     * 글자색이 흰색이고~~~...(자세한건 레이아웃 파일을 보시면~~ ㅎ)
     */
    private void setMoodView(int moodId, int textId) {
        // Instead of the normal constructor, we're going to use the one with no args and fill
        // in all of the data ourselves. The normal one uses the default layout for notifications.
        // You probably want that in most cases, but if you want to do something custom, you
        // can set the contentView field to your own RemoteViews object.
    // 알림객체를 생성 합니다.
        Notification notif = new Notification();

        // This is who should be launched if the user selects our notification.
        // 아이콘 이미지 리소스 아이디인 moodId와 알림항목을 클릭시 실행될 액티비티 클래스가
        // 셋팅된 PendingIntent 객체를 setMood 메소드와는 다른 방식인,
        // contentIntent 속성값으로 셋팅하고 있습니다.
        notif.contentIntent = makeMoodIntent(moodId);

        // In this sample, we'll use the same text for the ticker and the expanded notification
        // 알림바에 표시될 제목을, 알림객체의 tickerText 속성값을 셋팅하는 방식으로 설정하고 있습니다.
        CharSequence text = getText(textId);
        notif.tickerText = text;

        // the icon for the status bar
        // 알림바에 표시될 아이콘 이미지를, 이미지 리소스아이디값을 알림객체의 icon 속성값에 설정하고 있습니다.
        notif.icon = moodId;

        // our custom view
        // 알림바를 펼쳤을때 나오는 알림항목을 사용자정의 레이아웃으로 적용하기 위해,
        // RemoteViews 객체를 생성하여, 생성자에서 status_bar_balloon 레이아웃 리소스 아이디를 넘기고 있습니다.
        RemoteViews contentView = new RemoteViews(getPackageName(), R.layout.status_bar_balloon);
        //status_bar_balloon 레이아웃 안의 아이디가 text 인 TextView 객체에 알림제목을 설정하고 있습니다.
        contentView.setTextViewText(R.id.text, text);
        //status_bar_balloon 레이아웃 안의 아이디가 icon 인 ImageView 객체에 아이콘 이미지 리소스 아이디 값을 설정
        contentView.setImageViewResource(R.id.icon, moodId);
        //알림객체의 contentView 속성에 이에서 설정한 RemoteViews 객체를 설정하여, 사용자 정의 레이아웃 적용시킵니다.
        notif.contentView = contentView;

        // we use a string id because is a unique number. we use it later to cancel the
        // notification
        // 알림매니저 객체의 notify 메소드에 알림고유아이디인 status_bar_notifications 레이아웃 리소스 아이디값을
        // 넘기고(이후에 취소할때 이 값을 취소할 알림의 아이디값으로 넘김), 위에서 설정한 알림 객체를
        // 넘겨서, 알림을 발생시키게 됩니다.
        mNotificationManager.notify(R.layout.status_bar_notifications, notif);
    }

    //기본형태의 알림을 발생시키는 함수입니다.
    //알림을 발생시킬때, defaults의 값에 따라서, 진동/빛/사운드를 같이 발생시키게 됩니다.
    // Notification.DEFAULT_ALL : 현재 하드웨어 지원하는 모든것
    // Notification.DEFAULT_VIBRATE : 진동
    // Notification.DEFAULT_SOUND : 사운드
    // Notification.DEFAULT_LIGHTS : 빛
    //이 함수에서는, 위의 함수들과 달리, 알림항목을 클릭하면, NotificationDisplay 클래스
    //액티비티가 실행이 안되고, 현재 액티비티가 실행되어, 다시 돌아오게 됩니다.
    private void setDefault(int defaults) {
        // This method sets the defaults on the notification before posting it.

        // This is who should be launched if the user selects our notification.
    // 현재 액티비티 클래스를 설정하는 인텐트를 설정합니다.
    // 알림 항목을 클릭하면 현재 액티비티로 되돌아오게 됩니다.
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                new Intent(this, StatusBarNotifications.class), 0);

        // In this sample, we'll use the same text for the ticker and the expanded notification
        // 알림바 제목, 알림항목 내용 문자열이 동일합니다.
        CharSequence text = getText(R.string.status_bar_notifications_happy_message);

        //알림객체를 생성합니다. 아이콘이미지, 제목, 발생시간을 설정합니다.
        final Notification notification = new Notification(
                R.drawable.stat_happy,       // the icon for the status bar
                text,                        // the text to display in the ticker
                System.currentTimeMillis()); // the timestamp for the notification

        //알림객체에 알림정보를 설정합니다.
        //제목,내용, 위에서 설정한 알림항목 클릭시 실행할 액티비티정보를 설정한 PendingIntent를
        //넘기고 있습니다.
        notification.setLatestEventInfo(
                this,                        // the context to use
                getText(R.string.status_bar_notifications_mood_title),
                                             // the title for the notification
                text,                        // the details to display in the notification
                contentIntent);              // the contentIntent (see above)

        //인자로 넘어온, 진동/빛/모두/사운드 옵션을 설정합니다.
        notification.defaults = defaults;

        //알림 고유아이디로, status_bar_notifications 레이아웃 리소스 아이디 정수값을 넘기고,
        //위에서 설정한 알림객체를 넘겨서 알림을 발생시킵니다.
        mNotificationManager.notify(
                   R.layout.status_bar_notifications, // we use a string id because it is a unique
                                                      // number. we use it later to cancel the
                   notification);                     // notification
    }
}

원하는 위치에, 알림항목을 클릭했을때, 뜨는 액티비티 클래스인 NotificationDisplay.java 파일을 원하는 위치에 생성해 줍니다.

NotificationDisplay.java

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package 패키지경로;

// Need the following import to get access to the app resources, since this
// class is in a sub-package.
import korsoft.net.Test001.R;
import android.app.Activity;
import android.app.NotificationManager;
import android.content.Intent;
import android.os.Bundle;
import android.view.Gravity;
import android.view.View;
import android.view.WindowManager;
import android.widget.ImageButton;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;

/**
* Activity used by StatusBarNotification to show the notification to the user.
* 부모 액티비티에서 알림발생버튼을 누르면, 알림이 발생하고, 스마트폰 화면 상단의
* 알림바를 밑으로 드래그 해서 열린 창에서, 알림항목을 누르면 현재 액티비티가
* 반투명 배경으로 해서, 중앙에 이미지 버튼이 한개인 상태로 뜨게 됩니다.
* 이 액티비티는 xml 레이아웃 파일이 아닌, onCreate 메소드에서 동적으로
* 레이아웃 객체를 생성하고, 세부내용들을 설정하여, 액티비티에 레이아웃을 적용시킵니다.
*/
public class NotificationDisplay extends Activity implements View.OnClickListener {
    /**
     * Initialization of the Activity after it is first created. Must at least
     * call {@link android.app.Activity#setContentView setContentView()} to
     * describe what is to be displayed in the screen.
     */
    @Override
    protected void onCreate(Bundle icicle) {
        // Be sure to call the super class.
        super.onCreate(icicle);
        // Have the system blur any windows behind this one.
        //현재 액티비티를 반투명하게 설정합니다.
        //즉 아래에서 레이아웃을 배치하면, 그 뒤에 배경이 단색이 아닌
        //반투명하게 밑에 깔린 프로그램 화면들이 보이게 됩니다.
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND,
                WindowManager.LayoutParams.FLAG_BLUR_BEHIND);

        //상대적 배치 레이아웃 컨테이너객체를 만듭니다.
        //지금까지 xml 로 레이아웃을 정의하여, 액티비티에 적용을 했지만,
        //여기서는 xml 이 아닌, 동적으로 코드로 만들어서 현재 액티비티에 적용합니다.
        RelativeLayout container = new RelativeLayout(this);

        //이미지 버튼객체를 생성하고, 부모 액티비티에서 인텐트를 통해 아이콘
        ImageButton button = new ImageButton(this);
        //리소스 아이디값을 넘긴것을, 받아와서 이미지 버튼객체에 셋팅하고,
        button.setImageResource(getIntent().getIntExtra("moodimg", 0));
        //현재 액티비티에 셋팅된 클릭시 처리 핸들러 메소드를 현재 버튼을
        //눌렀을때 처리하는 클릭 핸들러 메소드로 셋팅해줍니다.
        //현재 액티비티가 View.OnClickListener 를 구현(implements)하고 있기때문에
        //클릭처리핸들러로 셋팅할 수 있게 됩니다.
        button.setOnClickListener(this);

        //가로, 세로 사이즈가 화면에 100%로 맞춤
        RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(
                RelativeLayout.LayoutParams.WRAP_CONTENT,
                RelativeLayout.LayoutParams.WRAP_CONTENT);
        //내용들을 화면의 수평/수직상으로 중앙에 배치
        lp.addRule(RelativeLayout.CENTER_IN_PARENT);

        //위의 이미지버튼을 현재 컨테이너에 추가합니다.
        container.addView(button, lp);

        //위에서 xml이 아닌, 동적으로 정의한 레이아웃 컨테이너를
        //현재 액티비티에 적용합니다.
        setContentView(container);
    }
    public void onClick(View v) {
        // The user has confirmed this notification, so remove it.
    //알림매니저 객체를 시스템으로부터 가져와서,
    //status_bar_notifications 레이아웃 리소스 아이디 고유정수값
    //(알림생성시 사용했던 알림ID값)을 인자로 넘겨서, 해당 알림을
    //해제하게 됩니다.(cancel메소드)
        ((NotificationManager) getSystemService(NOTIFICATION_SERVICE))
                .cancel(R.layout.status_bar_notifications);

        // Pressing on the button brings the user back to our mood ring,
        // as part of the api demos app. Note the use of NEW_TASK here,
        // since the notification display activity is run as a separate task.
        //그리고 다시 부모액티비티인 StatusBarNotifications 클래스 액티비티를
        //띄우고, 현재 액티비티를 닫습니다.(finish()메소드)
        Intent intent = new Intent(this, StatusBarNotifications.class);
        intent.setAction(Intent.ACTION_MAIN);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        startActivity(intent);

        // We're done.
        finish();
    }
}

/res/drawable-hdpi/ 폴더안에 stat_happy.png, stat_neutral.png, stat_sad.png 파일을 안드로이드 sdk 샘플폴더에서 복사합니다.

/res/layout/ 폴더안에 다음 두개의 xml 파일을 추가해줍니다.

status_bar_balloon.xml
알림항목에 적용될 사용자 정의 레이아웃 xml 파일입니다.

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:baselineAligned="false"
    android:gravity="center_vertical"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">
   <ImageView android:id="@+id/icon"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginRight="10dip" />
    <TextView android:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textColor="#ffffffff" />
</LinearLayout>
status_bar_notifications.xml
메인 액티비티 레이아웃 파일입니다. 각 알림발생 버튼들을 설정하고 있습니다.

<?xml version="1.0" encoding="utf-8"?>

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/status_bar_notifications_icons_only" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/happy"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_happy" />

            <Button
                android:id="@+id/neutral"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_ok" />

              <Button
                android:id="@+id/sad"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_sad" />

        </LinearLayout>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_icons_and_marquee" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/happyMarquee"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_happy" />

            <Button
                android:id="@+id/neutralMarquee"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_ok" />

              <Button
                android:id="@+id/sadMarquee"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_sad" />

        </LinearLayout>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_remote_views" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/happyViews"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_happy" />

            <Button
                android:id="@+id/neutralViews"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_ok" />

              <Button
                android:id="@+id/sadViews"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_sad" />

        </LinearLayout>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_defaults" />
        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/defaultSound"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_default_sound" />

            <Button
                android:id="@+id/defaultVibrate"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_default_vibrate" />

              <Button
                android:id="@+id/defaultAll"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_default_all" />

        </LinearLayout>

        <Button android:id="@+id/clear"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_clear" />

    </LinearLayout>
</ScrollView>

/res/values/ 폴더 밑에 다음 파일들을 설정해 줍니다.

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, Test001!</string>
    <string name="app_name">Test001</string>

    <string name="status_bar_notifications_icons_only">Icons only</string>
    <string name="status_bar_notifications_icons_and_marquee">Icons and marquee</string>
    <string name="status_bar_notifications_remote_views">Use remote views in balloon</string>
    <string name="status_bar_notifications_defaults">Use default values where applicable</string>
    <string name="status_bar_notifications_happy">:-)</string>
    <string name="status_bar_notifications_ok">:-|</string>
    <string name="status_bar_notifications_sad">:-(</string>
    <string name="status_bar_notifications_happy_message">I am happy</string>
    <string name="status_bar_notifications_ok_message">I am ok</string>
    <string name="status_bar_notifications_sad_message">I am sad</string>
    <string name="status_bar_notifications_clear">Clear notification</string>
    <string name="status_bar_notifications_mood_title">Mood ring</string>
    <string name="status_bar_notifications_default_sound">Sound</string>
    <string name="status_bar_notifications_default_vibrate">Vibrate</string>
    <string name="status_bar_notifications_default_all">All</string>

</resources>
colors.xml

<?xml version="1.0" encoding="utf-8"?>

<resources>

<drawable name="screen_background_black">#ff000000</drawable>
    <drawable name="translucent_background">#e0000000</drawable>
    <drawable name="transparent_background">#00000000</drawable>
</resources>

styles.xml
액티비티의 배경을 투명하게 하기위한 설정값을 설정하고 있습니다.

<?xml version="1.0" encoding="utf-8"?>

<resources>
    
    <style name="Theme" parent="android:Theme">
    </style>
    
    <style name="Theme.Transparent">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowAnimationStyle">@android:style/Animation.Translucent</item>
        <item name="android:windowBackground">@drawable/transparent_background</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:colorForeground">#fff</item>
    </style>
</resources>

마지막으로 AndroidManifest.xml 파일을 다음과 같이 설정합니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="패키지 경로"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />

    
    <uses-permission android:name="android.permission.VIBRATE" />

    <application android:icon="@drawable/icon" android:label="@string/app_name">

        <activity android:name=".NotificationDisplay"
                android:theme="@style/Theme.Transparent"
                android:taskAffinity=""
                android:excludeFromRecents="true"
                android:noHistory="true">
        </activity>

        <activity android:name=".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.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

그럼 모두들 즐프하세요. ^^

[android] 주기적으로 알림을 발생하는 서비스

2011-05-08T13:23:00.001-07:00

안녕하세요?
프쟁이 입니다. ^^

메인 액티비티가 실행되면, 버튼이 두개가 있습니다.

하나는 서비스를 시작하는 버튼이고,

다른 하나는 서비스를 종료하는 버튼입니다.

서비스가 시작되면, 5초간격으로 알림바의 상태가 바뀌게

됩니다. 상태는 세가지이고, 1분동안 세가지의 상태가

총 네번 바뀌게 됩니다.

먼저 메인 액티비티 클래스 파일인 NotifyingController.java

파일을 src 폴더 밑에 원하는 패키지 경로 밑에 추가합니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package 만드신패키지경로;

// Need the following import to get access to the app resources, since this
// class is in a sub-package.
import 만드신패키지경로.R;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

/**
* Controller to start and stop a service. The serivce will update a status bar
* notification every 5 seconds for a minute.
* 버튼 2개가 있고, 하나는 서비스를 시작하고
* 하나는 서비스를 종료합니다.
*/
public class NotifyingController extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.notifying_controller);

        //시작버튼입니다.
        Button button = (Button) findViewById(R.id.notifyStart);
        button.setOnClickListener(mStartListener);

        //종료버튼입니다.
        button = (Button) findViewById(R.id.notifyStop);
        button.setOnClickListener(mStopListener);
    }

    private OnClickListener mStartListener = new OnClickListener() {
        public void onClick(View v) {
            //NotifyingService 클래스가 서비스를 정의한 클래스입니다.
            //서비스를 시작하게 됩니다.
            startService(new Intent(NotifyingController.this,
                    NotifyingService.class));
        }
    };

    private OnClickListener mStopListener = new OnClickListener() {
        public void onClick(View v) {
            //시작된 서비스를 종료시키게 됩니다.
            stopService(new Intent(NotifyingController.this,
                    NotifyingService.class));
        }
    };
}

이제 알림을 주기적으로 발생시키는 서비스 클래스를 정의한 NotifyingService.java

파일을 원하시는 패키지 경로에 추가해주시고, 다음과 같이 입력하시면 됩니다.

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package 해당패키지경로;
// Need the following import to get access to the app resources, since this
// class is in a sub-package.
import 해당패키지경로.R;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.ConditionVariable;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.widget.RemoteViews;
/**
* This is an example of service that will update its status bar balloon
* every 5 seconds for a minute.
*
*/
public class NotifyingService extends Service {

    // Use a layout id for a unique identifier
    // R.layout.status_bar_notifications 는 액티비티를 만들기 위한 뷰레이아웃이
    // 아니고, 알림서비스를 생성하기위한 고유식별자(ID)용으로 사용하기 위한
    // 정수값으로 사용되고 있습니다.
    private static int MOOD_NOTIFICATIONS = R.layout.status_bar_notifications;

    // variable which controls the notification thread
    // 5초간격으로 알림을 발생시키기 위해서, Thread 의 실행을 컨트롤 하는
    // 객체 변수입니다. Thread 의 실행을 5초간격으로 지연시키는 처리를
    // 하게 됩니다.
    private ConditionVariable mCondition;

    @Override
    public void onCreate() {
        //알림관리자 객체를 시스템으로부터 가져옵니다.
        mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        // Start up the thread running the service. Note that we create a
        // separate thread because the service normally runs in the process's
        // main thread, which we don't want to block.
        // mTask 라는 Runnable 클래스변수를 설정한 Thread 를 생성합니다.
        // 이 Thread의 실행내용은, mTask 의 run() 메소드에 정의된 내용이
        // 실행이 됩니다.
        Thread notifyingThread = new Thread(null, mTask, "NotifyingService");
        mCondition = new ConditionVariable(false); //Thread의 실행을 제어할 변수
        notifyingThread.start(); //Thread 시작
    }

    @Override
    public void onDestroy() {
        // Cancel the persistent notification.
        // 식별자가 MOOD_NOTIFICATIONS(레이아웃 리소스 아이디값)인
        // 알림을 취소시킵니다. 알림바에서 알림이 없어집니다.
        mNM.cancel(MOOD_NOTIFICATIONS);

        // Stop the thread from generating further notifications
        // 이전에 실행됐던 Thread 들을 모두 중지시킵니다.
        mCondition.open();
    }

    //현재 서비스 시작시에 생성한 Thread 의 실행내용입니다.
    private Runnable mTask = new Runnable() {
        public void run() {
            //루프 한번돌때, 웃는아이콘 표시하고 5초정지하고,
            //보통아이콘 표시하고 5초 정지하고,
            //슬픈아이콘 표시하고 5초 정지하고
            //이렇게 루프 한번에 15초동안 세번의 알림상태가 갱신되고,
            //루프가 4번 돌게 되므로, 총 1분동안
            //세번의 알림상태가 바뀌는것이 4번 반복됩니다.
            for (int i = 0; i < 4; ++i) {
                //알림바에 알림을 표시합니다.
                //웃는 아이콘이 표시되고, 해당 문자열이 제목과 내용으로
                //알림창에 나오게 됩니다.
                showNotification(R.drawable.stat_happy,
                        R.string.status_bar_notifications_happy_message);
                //5초간 Thread의 실행을 중지시킵니다.
                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;
            }

            // Done with our work... stop the service!
            // 현재 서비스를 중지시켜, onDestroy() 서비스의 메소드가 호출되고,
            // 알림과 Thread 가 모두 종료됩니다.
            NotifyingService.this.stopSelf();
        }
    };

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

    //알림을 처리하는 함수입니다.
    //moodId는 알림바에 표시될 아이콘 이미지의 리소스 아이디입니다.(drawable 폴더의 아이콘)
    //textId는 알림항목에 표시될 제목의 문자열 리소스 아이디값입니다.(R.string.문자열name)
    private void showNotification(int moodId, int textId) {
        // In this sample, we'll use the same text for the ticker and the expanded notification
        // 알림항목의 제목 문자열값을 가져옵니다.
        CharSequence text = getText(textId);

        // Set the icon, scrolling text and timestamp.
        // Note that in this example, we pass null for tickerText. We update the icon enough that
        // it is distracting to show the ticker text every time it changes. We strongly suggest
        // that you do this as well. (Think of of the "New hardware found" or "Network connection
        // changed" messages that always pop up)
        // 알림객체를 생성합니다, moodId는 아이콘이미지의 리소스 아이디입니다.
        Notification notification = new Notification(moodId, null, System.currentTimeMillis());

        // The PendingIntent to launch our activity if the user selects this notification
        // 알림항목을 클릭했을때, NotifyingController 클래스에 정의된 액티비티가 실행이 됩니다.
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                new Intent(this, NotifyingController.class), 0);

        // Set the info for the views that show in the notification panel.
        // 알림항목에 표시될 제목문자열과 내용문자열, 그리고 위에서 만든 인텐트를 설정합니다.
        notification.setLatestEventInfo(this, getText(R.string.status_bar_notifications_mood_title),
                       text, contentIntent);

        // Send the notification.
        // We use a layout id because it is a unique number. We use it later to cancel.
        // 알림 매니저에 위에서 설정한 알림객체를 넘겨서, 알림을 발생시키게 됩니다.
        // MOOD_NOTIFICATIONS 는 레이아웃 리소스 아이디 정수값으로, 알림의 고유식별자 입니다.
        mNM.notify(MOOD_NOTIFICATIONS, notification);
    }

    // This is the object that receives interactions from clients. See
    // RemoteService for a more complete example.
    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;
}

위의 메인액티비티의 레이아웃인 /res/layout/notifying_controller.xml 파일을 추가합니다.

버튼 두개가 정의되어있습니다. 서비스를 시작하는 버튼과 종료하는 버튼 두개 입니다.

<?xml version="1.0" encoding="utf-8"?>




<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:padding="4dip"
    android:gravity="center_horizontal"
    android:layout_width="match_parent" android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent" android:layout_height="wrap_content"
        android:layout_weight="0"
        android:paddingBottom="4dip"
        android:text="@string/notifying_service_controller"/>

    
    <Button android:id="@+id/notifyStart"
        android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:text="@string/start_service">
        <requestFocus />
    </Button>

    
    <Button android:id="@+id/notifyStop"
        android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:text="@string/stop_service">
    </Button>

</LinearLayout>

알림서비스의 고유식별자로 쓰일 /res/layout/status_bar_notifications.xml 레이아웃

파일을 추가해 줍니다. 이 파일의 내용은 현재 프로그램에서는 사용하지 않습니다.

단지 이 파일을 추가했을 때, 생성되는 이 레이아웃의 리소스 아이디 정수값을

알림객체의 고유식별자로 사용할 뿐입니다.

<?xml version="1.0" encoding="utf-8"?>


<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/status_bar_notifications_icons_only" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/happy"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_happy" />

            <Button
                android:id="@+id/neutral"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_ok" />

              <Button
                android:id="@+id/sad"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_sad" />

        </LinearLayout>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_icons_and_marquee" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/happyMarquee"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_happy" />

            <Button
                android:id="@+id/neutralMarquee"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_ok" />

              <Button
                android:id="@+id/sadMarquee"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_sad" />

        </LinearLayout>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_remote_views" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/happyViews"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_happy" />

            <Button
                android:id="@+id/neutralViews"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_ok" />

              <Button
                android:id="@+id/sadViews"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_sad" />

        </LinearLayout>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_defaults" />

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

            <Button
                android:id="@+id/defaultSound"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_default_sound" />

            <Button
                android:id="@+id/defaultVibrate"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_default_vibrate" />

              <Button
                android:id="@+id/defaultAll"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/status_bar_notifications_default_all" />

        </LinearLayout>

        <Button android:id="@+id/clear"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dip"
            android:text="@string/status_bar_notifications_clear" />

    </LinearLayout>

</ScrollView>

/res/values/strings.xml 파일안에 다음의 내용과 같이 셋팅해줍니다.

현재 프로그램에서 사용하는 문자열 값들입니다.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, Test021!</string>
    <string name="app_name">Test021</string>
    <string name="notifying_service_controller">This service will update a status bar notification
                  every 5 seconds for a minute</string>
    <string name="start_service">Start Service</string>
    <string name="stop_service">Stop Service</string>


    <string name="status_bar_notifications_icons_only">Icons only</string>
    <string name="status_bar_notifications_icons_and_marquee">Icons and marquee</string>
    <string name="status_bar_notifications_remote_views">Use remote views in balloon</string>
    <string name="status_bar_notifications_defaults">Use default values where applicable</string>
    <string name="status_bar_notifications_happy">:-)</string>
    <string name="status_bar_notifications_ok">:-|</string>
    <string name="status_bar_notifications_sad">:-(</string>
    <string name="status_bar_notifications_happy_message">I am happy</string>
    <string name="status_bar_notifications_ok_message">I am ok</string>
    <string name="status_bar_notifications_sad_message">I am sad</string>
    <string name="status_bar_notifications_clear">Clear notification</string>
    <string name="status_bar_notifications_mood_title">Mood ring</string>
    <string name="status_bar_notifications_default_sound">Sound</string>
    <string name="status_bar_notifications_default_vibrate">Vibrate</string>
    <string name="status_bar_notifications_default_all">All</string>

</resources>

/res/drawable-hdpi/ 폴더 안에 상태가 갱신될 세개의 아이콘을 추가하시면 됩니다.

현재 샘플들은 모두 안드로이드 SDK 안에 샘플의 내용이므로, 현재 사용자가 sdk를 설치한

폴더에서, (sdk설치폴더)\android-sdk-windows\samples\android-8\ApiDemos

폴더를 보시면 전체 샘플코드들이 있습니다.

그리고 아이콘 이미지는 (sdk설치폴더)\android-sdk-windows\samples\android-8\ApiDemos\res\drawable-hdpi

폴더안에서, stat_happy.png, stat_neutral.png, stat_sad.png 이 세 이미지 파일을

만드신 프로젝트의 /res/drawable-hdpi 폴더로 복사해 오시면 됩니다.

그러면 이 세개의 아이콘이 5초간격으로 돌아가면서 바뀌게 됩니다.

그리고 마지막으로 AndroidManifest.xml 파일을 여시고, 다음과 같이 설정해주시면 됩니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="패키지경로..."
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />

    <application android:icon="@drawable/icon" android:label="@string/app_name">

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

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

    </application>
</manifest>

그럼 모두들 즐프하세요 ^^

[android] toast 메시지를 사용자정의 레이아웃을 적용해서 띄우기

2011-05-07T14:54:00.001-07:00

안녕하세요?
프쟁이 입니다.

지금까지는 토스트메시지를 기본적인 형태의 텍스트만 나오는

형태로 띄웠는데요, 사용자가 직접 디자인한 레이아웃을 적용한

토스트 메시지를 띄울 수 있습니다.

public class 액티비티클래스명 extends Activity {

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

      // /res/layout/incoming_message_panel.xml 레이아웃 파일을,
      // View 객체로 생성해줍니다.
      LayoutInflater vi = (LayoutInflater)getSystemService
          (Context.LAYOUT_INFLATER_SERVICE);
      View view = vi.inflate(R.layout.incoming_message_panel,null);

      // 위의 레이아웃파일 안에 정의된 텍스트뷰에다가, 텍스트를
      // 설정해 줍니다.
      TextView tv = (TextView)view.findViewById(R.id.message);
      tv.setText("메시지");

      // 토스트 메시지를 띄워줍니다.
      // setView 메소드로, 위에서 생성된 뷰객체를 설정해줍니다
      // 그럼 이 뷰객체모양대로 토스트 메시지가 뜨게 됩니다.
      Toast toast = new Toast(this);
      toast.setView(view);
      toast.setDuration(Toast.LENGTH_LONG);
      toast.show();

    }
}

/res/layout/incoming_message_panel.xml 파일을 만들어서,

다음과 같이 입력합니다. 이 레이아웃은 여러분이 직접 정의를

하시면 됩니다.

<?xml version="1.0" encoding="utf-8"?>

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@android:drawable/toast_frame">
    <!--/res/drawable/ 폴더에 toast_frame 라는 이름의 이미지파일을 두시면됩니다.*/

    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

            <ImageView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:src="@drawable/sample_thumb_2"
                />

            <TextView
                android:id="@+id/message"
                android:layout_gravity="center_vertical"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:paddingLeft="6dip"
                />

    </LinearLayout>
</FrameLayout>

그럼 모두들 즐프하세요. ^^

[android] 알림(Notification) 사용하기

2011-05-07T14:16:00.001-07:00

안녕하세요?
프쟁이 입니다.

안드로이드에서 알림은, 스마트폰에서 무언가 이벤트가 발생이

됐을때(예를들어 문자가 온다든지 등), 핸드폰의 진동이 울리고

동시에 스마트폰 상단의 시간이 나오는 라인에 알림 텍스트가

나오게 됩니다. 그리고 그 상단의 알림라인을 터치해서 밑으로

드래그를 하시면 밑으로 주욱 펼쳐지면서, 알림내용이 나오게

됩니다. 그리고 그 알림 상세내용을 누르면, 알림이 사라지면서

액티비티가 뜬다든지, 아니면 특정 액션을 취하게 됩니다.

먼저 액티비티클래스를 다음과 같이 입력을 합니다.

public class 액티비티클래스명 extends Activity {

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

      //알림관리자 객체를 생성합니다.
      NotificationManager nm = (NotificationManager)
          getSystemService(NOTIFICATION_SERVICE);

      // The details of our fake message
      CharSequence from = "제목 문자열";
      CharSequence message = "상세내용 문자열";

      //알림바를 확장했을때, 표시되는 알림항목을 클릭했을때,
      //실행될 액티비티를 지정하는 인텐트를 만듭니다.
      //IncomingMessageView 라는 이름의 액티비티 클래스로
      //지정하고 있습니다.
      PendingIntent contentIntent = PendingIntent.getActivity
        (this, 0, new Intent(this, IncomingMessageView.class), 0);

      /*
        R.string.imcoming_message_ticker_text 는
        /res/values/strings.xml 파일에 다음과 같이 정의되어 있습니다.
        <string name="imcoming_message_ticker_text">New text message:
          <xliff:g id="text">%0$s</xliff:g></string>

        그리고 <xliff:g.. 이와같은 표현이 xml 오류가 나지 않으려면,
        strings.xml 파일의 루트 태그인 <resources 태그를 다음과
        같이 정의합니다.
        <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">

        아래의 getString 함수는 strings.xml 의
        <xliff:g id="text">%0$s</xliff:g> 부분을 message 변수문자열로
        대치하여 가져오게 됩니다.
      */
      String tickerText = getString
        (R.string.imcoming_message_ticker_text, message);

      //알림객체를 생성합니다.
      //R.drawable.stat_sample : /res/drawable stat_sample 폴더안에
      //이름의 이미지를 준비합니다.
      Notification notif = new Notification(R.drawable.stat_sample,
              tickerText, System.currentTimeMillis());

      //발생시킬 이벤트 정보를 셋팅합니다.
      //현재 컨텍스트, 제목, 내용, 알림항목 클릭시 실행할 액티비티정보
      notif.setLatestEventInfo(this, from, message, contentIntent);

      //알림을 발생시켰을때, 진동의 주기를 설정합니다.
      //100ms(밀리세컨드) 후에, 250ms 동안 진동하고,
      //100ms 후에 다시 500ms 동안 진동합니다.
      //즉 총 두번 진동하게 됩니다.
      notif.vibrate = new long[] { 100, 250, 100, 500};

      //실제로 위에서 설정한 알림 내용대로, 알림을 발생시킵니다.
      //알림내용은 notif 알림객체에 위에서 모두 설정했습니다.
      //R.string.imcoming_message_ticker_text 는 알림ID값으로서
      //고유값이면 됩니다.(정수숫자)
      //이후에 알림항목 클릭시 실행되는 액티비티에서 이 알림ID를
      //이용하여 현재 알림에 대한 처리를 계속할 수 있습니다.
      nm.notify(R.string.imcoming_message_ticker_text, notif);

    }
}

이제 위의 메인액티비티에서 알람을 발생시켜서, 알람항목을 클릭했을때

실행될 IncomingMessageView 액티비티 클래스를 다음과 같이 입력합니다.

public class IncomingMessageView extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(/*임의로 레이아웃을 정의하시면됩니다.*/
          R.layout.정의한레이아웃파일명);

        //알림관리자 객체를 시스템에서 가져옵니다.
        NotificationManager nm = (NotificationManager)
          getSystemService(NOTIFICATION_SERVICE);

        //알림항목을 클릭했으니, 사용자가 확인을 했으므로,
        //알림항목을 알림창에서 삭제를 합니다.
        //알림ID는 위에 메인액티비티에서 알림을 생성할때
        //사용했던 알림ID 값을 넘기면 됩니다.
        nm.cancel(R.string.imcoming_message_ticker_text);

    }
}

이제 AndroidManifest.xml 파일을 열어서, 위의 두개의 액티비티와

진동을 사용하기 위해서, 진동권한을 부여해 줍니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="..."
      android:versionCode="1"
      android:versionName="1.0">
<uses-sdk android:minSdkVersion="8" />


<uses-permission android:name="android.permission.VIBRATE" />

<application android:icon="@drawable/icon" android:label="@string/app_name">

      <activity android:name=".IncomingMessage" android:label="App/Notification/IncomingMessage">
            <intent-filter>
              <action android:name="android.intent.action.MAIN" />
              <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".IncomingMessageView" android:label="App/Notification/IncomingMessageView">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.EMBED" />
            </intent-filter>
        </activity>

    </application>
</manifest>

그럼 모두들 즐프하세요. ^^

[android] XML로 메뉴만들기 - 메뉴항목 그룹별 정렬하기

2011-05-05T03:20:00.001-07:00

안녕하세요?
프쟁이 입니다.

메뉴항목들을 그룹별로 묶어서, 각 그룹별로 그 안에서 정렬을 설정할

수 있습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <group android:id="@+id/most_used_items">

        <item android:id="@+id/last_most_item"
            android:orderInCategory="10"
            android:title="@string/last_most_often" />

        <item android:id="@+id/middle_most_item"
            android:orderInCategory="7"
            android:title="@string/middle_most_often" />

        <item android:id="@+id/first_most_item"
            android:orderInCategory="4"
            android:title="@string/first_most_often" />

    </group>

    <group android:id="@+id/least_used_items"
        android:menuCategory="secondary">

        <item android:id="@+id/last_least_item"
            android:orderInCategory="3"
            android:title="@string/last_least_often" />

        <item android:id="@+id/middle_least_item"
            android:orderInCategory="2"
            android:title="@string/middle_least_often" />

        <item android:id="@+id/first_least_item"
            android:orderInCategory="0"
            android:title="@string/first_least_often" />

    </group>
</menu>

먼저 menu 루트태그안에 item 태그가 여섯개가 있으므로, 스마트폰 메뉴버튼을

누르면, 하단에 메뉴가 네개가 나오게 됩니다.

그런데 위의 item 메뉴항목들이 세개씩 두개의 group 태그로 묶여있습니다.

그리고 모든 item 태그들이 android:orderInCategory="1" 속성이 설정되어있습니다.

이렇게 되면, 각 그룹별로 그 안에서 item 항목들이 정렬을 하게 됩니다.

먼저 첫번째 그룹과 두번째 그룹이 나뉘어서, 첫번째 그룹의 메뉴항목들이 먼저

나오고, 그리고 두번째 그룹의 메뉴항목들이 나오게 되고, 그리고 그 안에서

위의 android:orderInCategory="1" 속성값 순서대로 그룹별로 정렬이 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.last_most_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.middle_most_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.first_most_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.last_least_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.middle_least_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.first_least_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 메뉴항목 정렬하기

2011-05-04T16:35:00.000-07:00

안녕하세요?
프쟁이 입니다.

메뉴 항목들을 나열된 순서대로만 출력할 수 있는것이 아니고,

메뉴를 정렬하는 속성값이 있어서, 이 속성값을 설정하여 메뉴항목들을

원하시는 순서대로 정렬을 처리하실 수 있습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/fourth_item"
        android:orderInCategory="3"
        android:title="Fourth" />
    <item android:id="@+id/third_item"
        android:orderInCategory="2"
        android:title="Third" />
    <item android:id="@+id/second_item"
        android:orderInCategory="1"
        android:title="Second" />
    <item android:id="@+id/first_item"
        android:orderInCategory="0"
        android:title="First" />
</menu>

먼저 menu 루트태그안에 item 태그가 네개가 있으므로, 스마트폰 메뉴버튼을

누르면, 하단에 메뉴가 네개가 나오게 됩니다.

그런데 위의 item 메뉴항목들이 나열된 순서대로 메뉴가 나타나는 것이 아니고,

item태그의 android:orderInCategory="1" 속성값의 순서대로 정렬이 되어서,

메뉴가 출력이 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.fourth_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.third_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.second_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.first_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 서브메뉴 형태의 메뉴

2011-05-04T16:00:00.001-07:00

안녕하세요?
프쟁이 입니다.

서브메뉴란 스마트폰 하단 좌측의 메뉴버튼을 누르면 나오는 화면하단의

메뉴를 클릭했을때, 화면중앙에 리스트가 나와서 다시 선택을 할 수

있는데요, 그 리스트가 특정 메뉴의 서브메뉴가 됩니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:title="Normal 1" />
    <item android:id="@+id/submenu"
        android:title="Emotions">
        <menu>
            <item android:id="@+id/happy"
                android:title="Happy"
                android:icon="@drawable/stat_happy" />

            <item android:id="@+id/neutral"
                android:title="Neutral"
                android:icon="@drawable/stat_neutral" />

            <item android:id="@+id/sad"
                android:title="Sad"
                android:icon="@drawable/stat_sad" />

        </menu>

    </item>
    <item android:title="Normal 2" />
</menu>

먼저 menu 루트태그안에 item 태그가 세개가 있으므로, 스마트폰 메뉴버튼을

누르면, 하단에 메뉴가 세개가 나오게 됩니다.

그런데 첫번째, 세번째 메뉴는 그냥 단순히 선택을 하면, 해당 처리를 하고

끝나게 되는데요, 두번째 item 항목은 안에 또 menu 태그가 있고, 그 안에

해당 메뉴의 item 항목들을 가지고 있습니다. 이 menu 태그가 바로 서브메뉴

입니다. 그리고 이 menu 태그안의 item 항목들이 화면중앙에 서브메뉴 리스트로

나오게 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.happy: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.neutral: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.sad: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 메뉴항목을 보이고 안보이게 하기

2011-05-04T15:37:00.001-07:00

안녕하세요?
프쟁이 입니다.

메뉴항목을 처음에 안보이게 했다가, 프로그램을 사용하면서,

특정 조건이나, 조작을 했을때 다시 보이게 했다가, 다시 숨기는 등의

처리를 하는 경우가 있을 수 있습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/visible_item"
        android:title="Visible"
        android:alphabeticShortcut="a" />
    <item android:id="@+id/hidden_item"
        android:title="Hidden"
        android:visible="false"
        android:alphabeticShortcut="b" />
    <group android:id="@+id/hidden_group"
        android:visible="false">

        <item android:id="@+id/hidden_by_group"
            android:title="Hidden by group"
            android:alphabeticShortcut="c" />

    </group>
</menu>

먼저 menu 루트태그안에 item 태그가 세개가 있지만,

두번째 item 태그의 속성이 android:visible="false"로 되어있고,

세번째 item태그를 감싸는 group태그의 속성이

android:visible="false" 로 되어있어서, 첫번째 item 태그의

메뉴항목만 메뉴를 표시했을때 보이게 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.visible_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            /*
              메뉴객체의 findItem 메소드에 메뉴항목의 리소스아이디값을 넘겨서,
              메뉴항목객체를 구하고(MenuItem), 그 메뉴항목의 isVisible() 메소드로
              현재 보이는지 안보이는지 true/false 값을 가져와서,
              그룹안의 모든 item 메뉴항목들을 보이고, 안보이게 해주는 메뉴객체의
              setGroupVisible(..) 메소드를 호출하여, 해당 그룹안의 모든 메뉴항목들을
              보이고 안보이게 컨트롤 할 수 있습니다.
            */
            final boolean is_visible = !mMenu.findItem(R.id.hidden_item).isVisible();
            mMenu.setGroupVisible(R.id.hidden_group, is_visible);
            break;
          case R.id.hidden_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.hidden_by_group: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 메뉴항목을 비활성화 시키기

2011-05-04T10:14:00.001-07:00

안녕하세요?
프쟁이 입니다.

메뉴항목을 누르면 하단의 메뉴항목중에 비활성화가 되어 텍스트와 이미지가

회색으로 표시되어, 클릭을 해도 아무런 반응이 없게 만들 수 있습니다.

처음에 그렇게 비활성화 시켯다가, 프로그램을 사용하면서, 특정 조건이나

조작을 했을때, 다시 프로그램에서 활성화 시켜주는 식으로 처리를 할 수

있습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/enabled_item"
        android:title="Enabled"
        android:icon="@drawable/enabled_image" />
    <item android:id="@+id/disabled_item"
        android:title="Disabled"
        android:enabled="false"
        android:icon="@drawable/disabled_image" />
</menu>

먼저 menu 루트태그안에 item 태그가 두개가 있으므로, 스마트폰 메뉴버튼을

누르시면, 하단에 한개의 메뉴항목이 나오게 되고, 하나는 정상적으로

활성화가 되어있고, 다른 하나의 메뉴항목은 클릭을 해도 반응하지 않는,

비활성화 상태가 되어있습니다.

item 태그를 보시면, android:enabled="false" 속성을 주면 비활성화가 되고,

설정을 안해주시거나 android:enabled="true" 로 설정을 하시면 메뉴항목이

활성화가 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.enabled_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.disabled_item: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 라디오버튼(단일선택) 형태의 메뉴

2011-05-04T09:59:00.000-07:00

안녕하세요?
프쟁이 입니다.

메뉴항목을 누르면 화면중앙에 리스트 선택항목이 떠서, 메뉴항목을

라디오형태로 한나의 항목만 선택할 수 있는 메뉴를 만들어보겠습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:title="Single">
        <menu>
            <group android:id="@+id/single_group"
                    android:checkableBehavior="single">
                <item android:id="@+id/item_1"
                        android:title="@string/item_1" />
                <item android:id="@+id/item_2"
                        android:title="@string/item_2" />
                <item android:id="@+id/item_3"
                        android:title="@string/item_3"
                        android:checked="true" />
            </group>
        </menu>
    </item>
</menu>

먼저 menu 루트태그안에 item 태그가 한개가 있으므로, 스마트폰 메뉴버튼을

누르시면, 하단에 한개의 메뉴항목이 나오게 되고, 그 메뉴항목을 클릭하시면

위에서 한개의 item 태그안에 정의된 menu 태그의 항목들이 라디어버튼 형태의

단일선택 리스트가 화면중앙에 나오게 됩니다.

menu 태그안에 라디오버튼 item 항목들이 group 태그로 묶여있고,

group 태그의 android:checkableBehavior="single" 속성값을 설정함으로서,

group 태그안의 item 메뉴항목들이 라디오버튼 형태가 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.item_1: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.item_2: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.item_3: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 체크박스(다중선택) 형태의 메뉴

2011-05-04T09:22:00.000-07:00

안녕하세요?
프쟁이 입니다.

메뉴항목을 누르면 화면중앙에 리스트 선택항목이 떠서, 메뉴항목을

체크박스형태로 여러개 선택할 수 있는 메뉴를 만들어보겠습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:title="group checkbox">
        <menu>
            <group android:id="@+id/groupCheckbox"
                    android:checkableBehavior="all">
                <item android:id="@+id/chk_item_1"
                        android:title="@string/item_1" />
                <item android:id="@+id/chk_item_2"
                        android:title="@string/item_2"
                        android:checked="true" />
                <item android:id="@+id/chk_item_3"
                        android:title="@string/item_3"
                        android:checked="true" />
            </group>
        </menu>
    </item>
    <item android:title="item each checkbox">
        <menu>
            <item android:id="@+id/each_chk_item_1"
                    android:title="@string/item_1"
                    android:checkable="true" />
            <item android:id="@+id/each_chk_item_2"
                    android:title="@string/item_2"
                    android:checkable="true"
                    android:checked="true" />
            <item android:id="@+id/each_chk_item_3"
                    android:title="@string/item_3"
                    android:checkable="true"
                    android:checked="true" />
        </menu>
    </item>
</menu>

먼저 menu 루트태그안에 item 태그가 두개가 있으므로, 스마트폰 메뉴버튼을

누르시면, 하단에 두개의 메뉴항목이 나오게 되고, 그 메뉴항목을 클릭하시면

위에서 두개의 각 item 태그안에 정의된 체크박스 형태의 선택리스트가

화면중앙에 나오게 됩니다.

두 메뉴가 모두 체크박스 항목을 띄우게 되는데요, 두 메뉴의 차이점은,

위에 있는 item 태그의 메뉴항목은 체크박스리스트를 group 태그로 묶어서

그 안의 메뉴항목들을 체크박스로 만들고 있습니다.

그리고 아래의 item 태그의 체크박스 리스트 메뉴는, group 태그를 사용하지

않고, 안의 menu 태그안의 item 각 항목들 하나하나마다

android:checkable="true" 속성을 설정하여, 체크박스로 만들고 있습니다.

결과적으로는 두 메뉴항목 모두 체크박스 리스트를 띄우게 됩니다.

group 태그에서는 android:checkableBehavior="all" 속성을 설정하여,

group 태그 안의 모든 item 태그들을 체크박스로 만들게 됩니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
      메뉴를 생성할때, 생성한 메뉴를 저장했다가,
      메뉴항목을 선택했을때 호출되는 메소드에서,
      메뉴에서 가져와야할 정보들을 이 변수에서
      가져와서 처리를 하게됩니다.
    */
    Menu mMenu;
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        mMenu = menu;
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //그룹으로 묶여있는 체크박스메뉴항목을 눌렀을때,
        //현재 선택한 체크박스 메뉴항목의 getGroupId() 메소드로
        //그룹의 리소스아이디와 비교하여, 일치하면
        //해당그룹의 메뉴항목을 의미하게 됩니다.
        //즉 여기서는 그룹으로 묶인 체크박스항목들을 클릭하면
        //모두 여기로 분기를 합니다.
    if(item.getGroupId()==R.id.groupCheckbox){
          String checkedItems = "";
          //mMenu는 메뉴생성시에 생성된 메뉴객체를 저장했던 변수입니다.
          //이 메뉴객체에서 이 메뉴객체안의 모든 메뉴항목들을 findItem()
          //메소드로 리소스아이디를 통해서 가져올 수 있습니다.
          //그룹안의 메뉴항목들을 객체변수로 가져옵니다.
          MenuItem item1 = mMenu.findItem(R.id.checkable_item_1);
          MenuItem item2 = mMenu.findItem(R.id.checkable_item_2);
          MenuItem item3 = mMenu.findItem(R.id.checkable_item_3);
          //각 메뉴항목별로 체크된 정보를 isChecked() 메소드로 체크하여
          //체크된 메뉴항목들에 대해서 임의의 처리를 하시면 됩니다.
          if(item1.isChecked()) checkedItems+=item1.getItemId()+",";
          if(item2.isChecked()) checkedItems+=item2.getItemId()+",";
          if(item3.isChecked()) checkedItems+=item3.getItemId()+",";

          Toast.makeText(this, "checked items : "+checkedItems,
            Toast.LENGTH_SHORT).show();

          return false;
    }

        //각 체크박스 메뉴항목별로 선택했을때 처리..
        switch (item.getItemId()) {
          case R.id.each_chk_item_1: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.each_chk_item_2: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.each_chk_item_3: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 일반리스트 선택 형태의 메뉴

2011-05-04T08:14:00.000-07:00

안녕하세요?
프쟁이 입니다.

메뉴항목을 누르면 화면중앙에 리스트 선택항목이 떠서,

메뉴항목을 선택할 수 있는 메뉴를 만들어보겠습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:title="select">
        <menu>
            <group android:id="@+id/group1"
                    android:checkableBehavior="none">
                <item android:id="@+id/item_1"
                        android:title="@string/item_1" />
                <item android:id="@+id/item_2"
                        android:title="@string/item_2" />
                <item android:id="@+id/item_3"
                        android:title="@string/item_3" />
            </group>
        </menu>
    </item>
</menu>

먼저 menu 루트태그안에 item 태그가 하나만 있으므로, 스마트폰 메뉴버튼을

누르시면, 하단에 하나의 메뉴항목이 나오게 되고, 그 메뉴항목을 클릭하시면

위에서 item 태그안에 정의된 또 하나의 menu태그가 리스트 형태로 화면중앙에

item 태그 세개가(item_1, item_2, item_3) 리스트형태로 선택할 수 있게 나옵니다.

위에서 내부의 menu태그안에 group 태그로 item 태그 세개를 감싸고 있는데,

group 태그는 감싸고 있는 item 태그 세개에 공통의 속성을 부여하기 위해서

item 태그들을 감싸고 있습니다. 여기서는 android:checkableBehavior="none" 이라는

속성을 부여하여, 메뉴항목을 클릭했을때 뜨는 리스트가 체크박스(다중선택)냐

혹은 라디오버튼(단일선택)이냐, 혹은 단순리스트 형태인가를 설정하게 됩니다.

위에서 android:checkableBehavior="none" 는 단순리스트 형태입니다.

android:checkableBehavior="single" 은 라디오버튼 형태로 단일선택형입니다.

android:checkableBehavior="all" 은 체크박스 형태로 다중선택형입니다.

이제 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
          case R.id.item_1: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.item_2: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.item_3: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 텍스트 제목 + 아이콘 형태의 메뉴

2011-05-04T07:42:00.000-07:00

안녕하세요?
프쟁이 입니다.

텍스트와 아이콘이 나오는 메뉴를 만들어보겠습니다.

먼저 /res/menu/menuTemplate.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/happy"
        android:title="Happy"
        android:icon="@drawable/stat_happy" />
    <item android:id="@+id/neutral"
        android:title="Neutral"
        android:icon="@drawable/stat_neutral" />
    <item android:id="@+id/sad"
        android:title="Sad"
        android:icon="@drawable/stat_sad" />
</menu>

item 태그가 세개이므로, 현재 메뉴가 떴을때 선택항목이 세개가 나오게 됩니다.

id속성은 이후에 선택된 메뉴항목을 식별하게 됩니다.

title속성은 메뉴항목에 나오는 텍스트 입니다.

그리고 icon 속성이 /res/drawable/ 폴더 밑에 위치하는 이미지 파일명을

설정해 주시면, 해당 아이콘파일이 메뉴항목에 텍스트와 같이 표시됩니다.

그리고 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.

public class 액티비티클래스명 extends Activity {
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.menuTemplate, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
          case R.id.happy: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.neutral: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.sad: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^

[android] XML로 메뉴만들기 - 텍스트 제목의 메뉴

2011-05-04T06:34:00.001-07:00

안녕하세요?
프쟁이 입니다.

가장 기본형태의 텍스트만 나오는 메뉴를 만들어보겠습니다.

먼저 /res/menu/title.xml 파일을 만드시고, 아래와 같이 입력합니다.

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/jump"
        android:title="@string/jump" />
    <item android:id="@+id/dive"
        android:title="@string/dive" />
</menu>

메뉴xml 파일이고, menu 를 루트태그로, 그 안에 item 태그를 필요한만큼

입력하시고, id 속성과 title 속성을 입력하시면 됩니다.

id 속성값은 이후에 액티비티 자바파일에서 메뉴항목을 선택했을때,

이 id속성값이 넘어와서, 어느 메뉴항목을 선택했는지를 알 수 있게 됩니다.

title속성은 메뉴항목에 표시될 텍스트 값입니다.

그리고 액티비티 자바파일을 만드시고, 다음과 같이 입력합니다.
public class 액티비티클래스명 extends Activity {
    /*
     스마트폰 하단의 메뉴버튼을 눌렀을때 호출되는 함수입니다.
     반환값을 false 로 하시면, 스마트폰 하단의 메뉴버튼을 눌렀을때,
     메뉴가 안나오게 됩니다. true 를 리턴하셔야 메뉴가 나옵니다.
    */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        //위에서 만들었던 xml 파일의 리소스아이디값을 넘겨줍니다.
        inflater.inflate(R.menu.title, menu);
        return true;
    }
    /*
      메뉴항목을 선택했을때, 호출되는 함수입니다.
    */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
          case R.id.jump: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
            break;
          case R.id.div: // 메뉴 xml 파일에서 정의한 id속성값 입니다.
            //메뉴항목선택시 처리내용...
        }

        return true;
    }
}

그럼 모두 즐프하세요. ^^