android 弹出进度条对话框的方法

new AlertDialog.Builder(this)
.setTitle(getString(R.string.info))
.setMessage(getString(R.string.auto_search_confirm))
.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int w) {
dialog.dismiss();
searchProcess();
}

private void searchProcess() {
LinearLayout myLayout;
LayoutInflater layoutInflater;
AlertDialog.Builder dialogBuilder;

myLayout = new LinearLayout(SetAlarm.this);
layoutInflater=(LayoutInflater) getSystemService(SetAlarm.this.LAYOUT_INFLATER_SERVICE);
myLayout=(LinearLayout) layoutInflater.inflate(R.layout.progress_dialog, null);

progressBar=(ProgressBar)myLayout.findViewById(R.id.progressBar);
progressBar.setMax(205);

dialogBuilder = new AlertDialog.Builder(SetAlarm.this);
dialogBuilder.setView(myLayout);
dialogBuilder.setMessage(SetAlarm.this.getString(R.string.channel_searching));
dialog = dialogBuilder.show();
dialog.setCancelable(false);
if (localAudioManager != null && localAudioManager.isWiredHeadsetOn()) {
registerReceiver(searchBroadcast, new IntentFilter(SEARCH_DONE));
registerReceiver(searchBroadcast, new IntentFilter(SET_PROGRESS));
mFMAlarmPref.searchChannel();
} else {
if(dialog != null && dialog.isShowing())
{
dialog.dismiss();
}
Toast toast = Toast.makeText(SetAlarm.this, SetAlarm.this.getString(R.string.plug_in_headset), Toast.LENGTH_LONG);
ToastMaster.setToast(toast);
toast.show();
}
}
})
.setNegativeButton(android.R.string.cancel,
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog,
int which) {
mFMRingState.setChecked(false);
mAlarmPref.setEnabled(true);
dialog.dismiss();
}

}).show();

static String SEARCH_DONE = "com.android.deskclock.search_done";
static String SET_PROGRESS = "com.android.deskclock.set_progress";
static String FMSERVICE = "net.kindroid.aidl.service.IFMService";
static String PROGRESS = "progress";
private AlertDialog dialog;
private ProgressBar progressBar;
final BroadcastReceiver searchBroadcast = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(SEARCH_DONE)) {
progressBar.setProgress(205);
mFMAlarmPref.updateEntres();
if(mFMAlarmPref.mEntries != null && mFMAlarmPref.mEntries.length > 0)
{
mFMAlarmPref.setEnabled(true);
} else
{
mFMAlarmPref.setEnabled(false);
}
if(dialog != null && dialog.isShowing())
{
dialog.dismiss();
}
} else if (action.equals(SET_PROGRESS)) {
int progress = intent.getIntExtra(PROGRESS, 205);
if (progress > progressBar.getProgress()) {
progressBar.setProgress(progress);
} else {
progressBar.setProgress(205);
}
} else if (action.equals(Intent.ACTION_HEADSET_PLUG)) {
// head-set plugged
if (intent.getIntExtra("state", 0) == 0) {
if(mFMRingState.isChecked()) {
mFMRingState.setChecked(false);
}
mFMRingState.setEnabled(false);
mFMAlarmPref.setEnabled(false);
Dialog alarmDialog = mFMAlarmPref.getDialog();
if(alarmDialog != null && alarmDialog.isShowing()) {
alarmDialog.dismiss();
}
mAlarmPref.setEnabled(true);
} else {
mFMRingState.setEnabled(true);
mFMRingState.setChecked(mOriginalAlarm.fmState);
if (mFMAlarmPref.mEntries != null) {
mFMAlarmPref.setEnabled(mOriginalAlarm.fmState);
mAlarmPref.setEnabled(!mOriginalAlarm.fmState);
} else {
mFMAlarmPref.setEnabled(false);
mAlarmPref.setEnabled(true);
}
}
}
}
};

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

package com.android.deskclock;

import net.kindroid.fm.IFMService;

import com.android.deskclock.R;
import android.app.AlertDialog.Builder;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.ServiceConnection;
import android.database.Cursor;
import android.media.AudioManager;
import android.net.Uri;
import android.os.IBinder;
import android.os.RemoteException;
import android.preference.ListPreference;
import android.util.AttributeSet;
import android.util.Log;

/**
* The FMRingtonePreference does not have a way to get/set the current ringtone
* so we override onSaveRingtone and onRestoreRingtone to get the same behavior.
*/
public class FMAlarmPreference extends ListPreference {
CharSequence[] mEntries;
CharSequence[] mEntryValues;
public static final String NO_SELECTION = "0";
private int mClickedDialogEntryIndex;
private Context mContext;
private int mChannel;
public boolean first = true;
public boolean isFMPreferenceFocus = false;

/**
* The content:// style URL for FM channel list table
*/
public static final Uri CONTENT_URI = Uri.parse("content://"
+ "net.kindroid.provider.fm_list" + "/" + "FMTable");

public FMAlarmPreference(Context context, AttributeSet attrs) {
super(context, attrs);
this.mContext = context;
this.setSummary(R.string.select_channel);
getDataFromDatabases();
this.setEntries(mEntries);
this.setEntryValues(mEntryValues);
this.setDefaultValue(NO_SELECTION);
this.setDialogTitle(R.string.fm_channel_list);
}

private void getDataFromDatabases() {
ContentResolver resolver = mContext.getContentResolver();
String order = "tune ASC";
Cursor cur = resolver.query(CONTENT_URI, null, null, null, order);

if (cur != null && cur.getCount() > 0) {
int count = cur.getCount();
mEntries = new CharSequence[count];
mEntryValues = new CharSequence[count];

cur.moveToFirst();

for (int i = 0; i < count; i++) {
String channel = cur.getString(cur
.getColumnIndexOrThrow("tune"));
String title = cur
.getString(cur.getColumnIndexOrThrow("title"));
mChannel = Integer.parseInt(channel);
int index = channel.length() - 1;
channel = channel.substring(0, index) + "."
+ channel.substring(index);
mEntries[i] = channel + " MHz";
if (title == null) {
title = mContext.getString(R.string.no_title);
}
mEntryValues[i] = title;
cur.moveToNext();
}
} else {

mEntries = null;
mEntryValues = null;
return;
}
}

public void updateEntres() {
getDataFromDatabases();
this.setEntries(mEntries);
this.setEntryValues(mEntryValues);
this.setDefaultValue(NO_SELECTION);
this.setDialogTitle(R.string.fm_channel_list);
this.notifyChanged();
}

private void closeVoice() {
Intent closeVolume = new Intent();
closeVolume.setAction(Intent.ACTION_FM);
closeVolume.putExtra("state", 0);
closeVolume.putExtra("speaker", 0);
mContext.sendBroadcast(closeVolume);
}
public void searchChannel() {
new Thread(new Runnable() {
@Override
public void run() {
int start = 875;
int sq = 875;
ContentValues values = null;
ContentResolver resolver = mContext.getContentResolver();
closeVoice();
mContext.startService(new Intent(SetAlarm.FMSERVICE));
mContext.bindService(new Intent(SetAlarm.FMSERVICE),
serviceConnection, Context.BIND_AUTO_CREATE);
try {
Thread.sleep(500);
} catch (Exception e) {
}
try {
if (mFMService == null) {
mContext.bindService(new Intent(SetAlarm.FMSERVICE),
serviceConnection, Context.BIND_AUTO_CREATE);
try {
Thread.sleep(1000);
} catch (Exception e) {
}
}
if(mFMService != null){
mFMService.openFM();
if (mFMService.isOpen()) {
Intent setProgress = new Intent();
setProgress.setAction(SetAlarm.SET_PROGRESS);
while (mFMService.searchStation(start, 1, 0, 0)) {
// get the search tune
sq = mFMService.getCurrentFrequency();
Log.e("autosearch", "sq = " + sq);

if (sq >= 875 && sq <= 1080) {
setProgress.putExtra(SetAlarm.PROGRESS,
sq - 875);
mContext.sendBroadcast(setProgress);

String where = "tune = " + sq;
Cursor cur = null;

cur = resolver.query(CONTENT_URI, null, where,
null, null);
if (cur != null && cur.getCount() < 1) {
// insert
values = new ContentValues();
values.put("tune", sq);
values.put("title", "");
values.put("comment", 0);
resolver.insert(CONTENT_URI, values);
}
}
if (start >= sq) {
releaseFM();

break;
}
start = sq;
}
}
}

} catch (Exception e) {
}
mContext.sendBroadcast(new Intent(SetAlarm.SEARCH_DONE));
}
}).start();
}

@Override
public void onDismiss(DialogInterface dialog) {
releaseFM();
first = true;
isFMPreferenceFocus = false;

super.onDismiss(dialog);
}

@Override
protected void onPrepareDialogBuilder(Builder builder) {
super.onPrepareDialogBuilder(builder);
updateEntres();
if (mEntries == null || mEntryValues == null) {
throw new IllegalStateException(
"ListPreference requires an entries array and an entryValues array.");
}
isFMPreferenceFocus = true;
try
{
mContext.bindService(new Intent(SetAlarm.FMSERVICE), serviceConnection, Context.BIND_AUTO_CREATE);
} catch (Exception e)
{
}
String str = (String) this.getSummary();
for (int i = 0; i < mEntries.length; i++) {
if (mEntries[i].equals(str)) {
mClickedDialogEntryIndex = i;
break;
}
}

if (str != mContext.getString(R.string.select_channel)) {
mChannel = (int) (Float.parseFloat(str.substring(0,
str.lastIndexOf(" "))) * 10);
}
builder.setSingleChoiceItems(mEntries, mClickedDialogEntryIndex,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
mClickedDialogEntryIndex = which;

String str = (String) mEntries[mClickedDialogEntryIndex];
mChannel = (int) ((Float.parseFloat(str.substring(0,
str.lastIndexOf(" ")))) * 10);
try {
if(first) {
if(mFMService == null) {
try
{
mContext.bindService(new Intent(SetAlarm.FMSERVICE), serviceConnection, Context.BIND_NOT_FOREGROUND);
} catch (Exception e)
{
}
}
if (mFMService != null && !mFMService.isOpen()) {
mFMService.openFM();
mFMService.setCurrentFrequency(mChannel);
setVolume();
}
first = false;
}
if (mFMService != null) {
mFMService.setCurrentFrequency(mChannel);
}
} catch (RemoteException e) {
}
}
});

builder.setPositiveButton(android.R.string.ok, new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
String str = Integer.toString(mChannel);
FMAlarmPreference.this.setSummary(str.substring(0,
str.length() - 1)
+ "."
+ str.substring(str.length() - 1) + " MHz");
FMAlarmPreference.this.callChangeListener(null);
}
});
builder.setNegativeButton(android.R.string.cancel, null);
}

/**
* bind FM service
*/
public void bindService() {
if(mFMService == null) {
try
{
mContext.bindService(new Intent(SetAlarm.FMSERVICE), serviceConnection, Context.BIND_AUTO_CREATE);
first = true;
} catch (Exception e)
{
}
}
}

/**
* close FM devices and stop service
*/
public void releaseFM() {
if (mFMService != null) {
mContext.unbindService(serviceConnection);
mFMService = null;

//this will send to FMService
mContext.sendBroadcast(new Intent("net.kindroid.ALARM_FM_SWITCH"));
}
}

/**
* open voice
*/
private void openVoice()
{
Intent voiceIntent = new Intent();
voiceIntent.setAction(Intent.ACTION_FM);
voiceIntent.putExtra("state", 1);
voiceIntent.putExtra("speaker", 0);
mContext.sendBroadcast(voiceIntent);
}

/**
* return the selected channel
*
* @return
*/
public int getChannel() {
return mChannel;
}

/**
* fm service
*/
private IFMService mFMService = null;

/**
* fm service connection
*/
private ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
mFMService = null;
}

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mFMService = (IFMService) IFMService.Stub.asInterface(service);
}
};

/**
* set current fm volume sync with framework
*/
private void setVolume() {
AudioManager am = (AudioManager) mContext
.getSystemService(Context.AUDIO_SERVICE);
int fm_volume = am.getStreamVolume(AudioManager.STREAM_FM);
openVoice();
try {
mFMService.setVolume(fm_volume);
} catch (RemoteException e) {
}
}
}

/*
* 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 com.android.deskclock;

import java.util.Timer;
import java.util.TimerTask;

import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.app.TimePickerDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.CheckBoxPreference;
import android.preference.EditTextPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import android.text.format.DateFormat;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TimePicker;
import android.widget.Toast;
import android.text.InputFilter;
import android.text.Spanned;

/**
* Manages each alarm
*/
public class SetAlarm extends PreferenceActivity
implements TimePickerDialog.OnTimeSetListener,
Preference.OnPreferenceChangeListener {

private EditTextPreference mLabel;
private CheckBoxPreference mEnabledPref;
private Preference mTimePref;
private AlarmPreference mAlarmPref;
private FMAlarmPreference mFMAlarmPref;
private CheckBoxPreference mFMRingState;
private CheckBoxPreference mVibratePref;
private RepeatPreference mRepeatPref;
private MenuItem mTestAlarmItem;
private AudioManager localAudioManager;

private int     mId;
private int     mHour;
private int     mMinutes;
private boolean mTimePickerCancelled;
private Alarm   mOriginalAlarm;
static String SEARCH_DONE = "com.android.deskclock.search_done";
static String SET_PROGRESS = "com.android.deskclock.set_progress";
static String FMSERVICE = "net.kindroid.aidl.service.IFMService";
static String PROGRESS = "progress";
private AlertDialog dialog;
private ProgressBar progressBar;
final BroadcastReceiver searchBroadcast = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(SEARCH_DONE)) {
progressBar.setProgress(205);
mFMAlarmPref.updateEntres();
if(mFMAlarmPref.mEntries != null && mFMAlarmPref.mEntries.length > 0)
{
mFMAlarmPref.setEnabled(true);
} else
{
mFMAlarmPref.setEnabled(false);
}
if(dialog != null && dialog.isShowing())
{
dialog.dismiss();
}
} else if (action.equals(SET_PROGRESS)) {
int progress = intent.getIntExtra(PROGRESS, 205);
if (progress > progressBar.getProgress()) {
progressBar.setProgress(progress);
} else {
progressBar.setProgress(205);
}
} else if (action.equals(Intent.ACTION_HEADSET_PLUG)) {
// head-set plugged
if (intent.getIntExtra("state", 0) == 0) {
if(mFMRingState.isChecked()) {
mFMRingState.setChecked(false);
}
mFMRingState.setEnabled(false);
mFMAlarmPref.setEnabled(false);
Dialog alarmDialog = mFMAlarmPref.getDialog();
if(alarmDialog != null && alarmDialog.isShowing()) {
alarmDialog.dismiss();
}
mAlarmPref.setEnabled(true);
} else {
mFMRingState.setEnabled(true);
mFMRingState.setChecked(mOriginalAlarm.fmState);
if (mFMAlarmPref.mEntries != null) {
mFMAlarmPref.setEnabled(mOriginalAlarm.fmState);
mAlarmPref.setEnabled(!mOriginalAlarm.fmState);
} else {
mFMAlarmPref.setEnabled(false);
mAlarmPref.setEnabled(true);
}
}
}
}
};

private Timer pTimer ;
private TimerTask pTimerTask ;
private Handler pHandler ;
private boolean top_flag ;
private TimePickerDialog tpd ;

private Toast sameAlarmToast ;
private boolean mFlag = false;
private static final int MAX_LABLE = 150;
private static final int MAX_LABLE_SEND         = 102;
private static final int MAX_LABLE_DELAY = 700;
private Handler mHandler = new Handler(){
public void handleMessage(Message message){
switch(message.what){
case MAX_LABLE_SEND:
Toast.makeText(getApplicationContext(),getString(R.string.alarm_lable_too_long),Toast.LENGTH_SHORT)
.show();
break;
default:
break;

}
}
};
/**
* Set an alarm.  Requires an Alarms.ALARM_ID to be passed in as an
* extra. FIXME: Pass an Alarm object like every other Activity.
*/
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);

// Override the default content view.
setContentView(R.layout.set_alarm);

addPreferencesFromResource(R.xml.alarm_prefs);

localAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
// Get each preference so we can retrieve the value later.
mLabel = (EditTextPreference) findPreference("label");
mLabel.getEditText().setFilters(new InputFilter[]{new FilenameLength(MAX_LABLE)}); //add by spreadst modify bug 13250 begin:
mLabel.setOnPreferenceChangeListener(
new Preference.OnPreferenceChangeListener() {
public boolean onPreferenceChange(Preference p,
Object newValue) {
String val = (String) newValue;
// Set the summary based on the new label.
p.setSummary(val);
mFlag = false;
if (val != null && !val.equals(mLabel.getText())) {
// Call through to the generic listener.
return SetAlarm.this.onPreferenceChange(p,
newValue);
}
return true;
}
});
mEnabledPref = (CheckBoxPreference) findPreference("enabled");
mEnabledPref.setOnPreferenceChangeListener(
new Preference.OnPreferenceChangeListener() {
public boolean onPreferenceChange(Preference p,
Object newValue) {
// Pop a toast when enabling alarms.
//if (!mEnabledPref.isChecked()) {
//    popAlarmSetToast(SetAlarm.this, mHour, mMinutes,
//        mRepeatPref.getDaysOfWeek());
//}
return SetAlarm.this.onPreferenceChange(p, newValue);
}
});
mTimePref = findPreference("time");
mAlarmPref = (AlarmPreference) findPreference("alarm");
mAlarmPref.setOnPreferenceChangeListener(this);
mFMRingState = (CheckBoxPreference) findPreference("fm_state");
mFMRingState.setOnPreferenceChangeListener(this);
mFMAlarmPref = (FMAlarmPreference) findPreference("fm_channel");
mFMAlarmPref.setOnPreferenceChangeListener(this);
mVibratePref = (CheckBoxPreference) findPreference("vibrate");
mVibratePref.setOnPreferenceChangeListener(this);
mRepeatPref = (RepeatPreference) findPreference("setRepeat");
mRepeatPref.setOnPreferenceChangeListener(this);

Intent i = getIntent();
mId = i.getIntExtra(Alarms.ALARM_ID, -1);
if (Log.LOGV) {
Log.v("In SetAlarm, alarm id = " + mId);
}

Alarm alarm = null;
if (mId == -1) {
// No alarm id means create a new alarm.
alarm = new Alarm();
} else {
/* load alarm details from database */
alarm = Alarms.getAlarm(getContentResolver(), mId);
// Bad alarm, bail to avoid a NPE.
if (alarm == null) {
finish();
return;
}
}
mOriginalAlarm = alarm;

updatePrefs(mOriginalAlarm);

// We have to do this to get the save/cancel buttons to highlight on
// their own.
getListView().setItemsCanFocus(true);

// Attach actions to each button.
Button b = (Button) findViewById(R.id.alarm_save);
b.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
//if there is a alarm witch has the same hour and minutes , show timepicker again
if(Alarms.isSametimeAlarm(getContentResolver(), mHour, mMinutes,mId)){
sameAlarmShow(mHour, mMinutes);
return;
}
saveAlarm();
// Save the alarm and pop a toast.
if(mEnabledPref.isChecked()){
popAlarmSetToast(SetAlarm.this, mHour, mMinutes, mRepeatPref.getDaysOfWeek());
}
finish();
}
});
final Button revert = (Button) findViewById(R.id.alarm_revert);
revert.setEnabled(false);
revert.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
int newId = mId;
updatePrefs(mOriginalAlarm);
// "Revert" on a newly created alarm should delete it.
/*
if (mOriginalAlarm.id == -1) {
if(newId!=-1)
Alarms.deleteAlarm(SetAlarm.this, newId);
} else {
saveAlarm();
}
*/
revert.setEnabled(false);
}
});
b = (Button) findViewById(R.id.alarm_delete);
if (mId == -1) {
b.setEnabled(false);
mTimePickerCancelled = true;
} else {
b.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
deleteAlarm();
}
});
}

// The last thing we do is pop the time picker if this is a new alarm.
if (mId == -1) {
// Assume the user hit cancel
mTimePickerCancelled = true;
showTimePicker();
}
registerReceiver(searchBroadcast, new IntentFilter(Intent.ACTION_HEADSET_PLUG));
}

@Override
protected void onPause(){
super.onPause() ;
top_flag = false ;
mFlag = false;
}

private class PickerTimerTask extends TimerTask{
@Override
public void run(){
if(pTimerTask != null){
pTimerTask.cancel();
pTimerTask = null ;
}
if(pTimer != null){
pTimer.cancel() ;
pTimer = null ;
}
if( top_flag ){
Message msg = pHandler.obtainMessage(0);
msg.sendToTarget();
}
}
}

@Override
protected void onResume() {
mFMAlarmPref.updateEntres();
if (mFMAlarmPref.mEntries == null) {
mFMAlarmPref.setEnabled(false);
}
if(mFMAlarmPref != null && mFMAlarmPref.isFMPreferenceFocus) {
mFMAlarmPref.bindService();
}
super.onResume();
}

@Override
protected void onStop() {
mFMAlarmPref.releaseFM();
mFMAlarmPref.first = true;
if(dialog != null && dialog.isShowing())
{
dialog.dismiss();
dialog = null;
}
super.onStop();
}

@Override
protected void onDestroy() {
unregisterReceiver(searchBroadcast);
super.onDestroy();
}

// Used to post runnables asynchronously.
private static final Handler sHandler = new Handler();

public boolean onPreferenceChange(final Preference p, Object newValue) {
// Asynchronously save the alarm since this method is called _before_
// the value of the preference has changed.
sHandler.post(new Runnable() {
public void run() {
// Editing any preference (except enable) enables the alarm.
if (p != mEnabledPref) {
mEnabledPref.setChecked(true);
}
final Button revert = (Button) findViewById(R.id.alarm_revert);
revert.setEnabled(true);
}
});
return true;
}

private void updatePrefs(Alarm alarm) {
mId = alarm.id;
mEnabledPref.setChecked(alarm.enabled);
mLabel.setText(alarm.label);
mLabel.setSummary(alarm.label);
mHour = alarm.hour;
mMinutes = alarm.minutes;
mRepeatPref.setDaysOfWeek(alarm.daysOfWeek);
mVibratePref.setChecked(alarm.vibrate);
mFMRingState.setChecked(alarm.fmState);

if (localAudioManager != null &&  !localAudioManager.isWiredHeadsetOn()) {
mFMRingState.setEnabled(false);
mFMAlarmPref.setEnabled(false);
mAlarmPref.setEnabled(true);
} else if (mFMAlarmPref.mEntries == null) {
mFMAlarmPref.setEnabled(false);
mFMRingState.setEnabled(true);
if (mFMRingState.isChecked()) {
searchConfirm();
}
} else {
mFMRingState.setEnabled(true);
mFMAlarmPref.setEnabled(alarm.fmState);
mAlarmPref.setEnabled(!alarm.fmState);
}
// Give the alert uri to the preference.
mAlarmPref.setAlert(alarm.alert);
if (alarm.fmChannel != 0) {
String str = Integer.toString(alarm.fmChannel);
mFMAlarmPref.setSummary(str.substring(0, str.length() - 1) + "."
+ str.substring(str.length() - 1) + " MHz");
} else {
mFMAlarmPref.setSummary(getString(R.string.select_channel));
}
mAlarmPref.setAlert(alarm.alert , alarm.alert_title);
updateTime();
}

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
Preference preference) {
if (preference == mTimePref) {
showTimePicker();
} else if (preference == mFMRingState) {
mAlarmPref.setEnabled(!mFMRingState.isChecked());
mFMAlarmPref.updateEntres();
if (mFMAlarmPref.mEntries == null) {
mFMAlarmPref.setEnabled(false);
if (mFMRingState.isChecked()) {
searchConfirm();
}
} else {
mFMAlarmPref.setEnabled(mFMRingState.isChecked());
}
}

return super.onPreferenceTreeClick(preferenceScreen, preference);
}

@Override
public void onBackPressed() {
// In the usual case of viewing an alarm, mTimePickerCancelled is
// initialized to false. When creating a new alarm, this value is
// assumed true until the user changes the time.
/*
if (!mTimePickerCancelled) {
saveAlarm();
}
*/
//when setting a new alarm,should not save this new alarm
//if someone want cancel the new alarm eventhough setting changed been listened.
//and existed clock should not save any alarm setting info before "done" button is click.
finish();
}

private void showTimePicker() {
if( tpd != null ){
if( tpd.isShowing() ){
tpd.cancel() ;
}
}

tpd = new TimePickerDialog(this, this, mHour, mMinutes,
DateFormat.is24HourFormat(this)) ;
tpd.show() ;
mTimePickerCancelled = false;
}

public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
// onTimeSet is called when the user clicks "Set"
mTimePickerCancelled = false;
//if there is a alarm witch has the same hour and minutes , show timepicker again
if(Alarms.isSametimeAlarm(getContentResolver(), hourOfDay, minute,mId)){
sameAlarmShow(hourOfDay, minute);
return;
}
mHour = hourOfDay;
mMinutes = minute;
updateTime();
// If the time has been changed, enable the alarm.
mEnabledPref.setChecked(true);
//popAlarmSetToast(this, saveAlarmAndEnableRevert());
final Button revert = (Button) findViewById(R.id.alarm_revert);
revert.setEnabled(true);
}

private void updateTime() {
if (Log.LOGV) {
Log.v("updateTime " + mId);
}
mTimePref.setSummary(Alarms.formatTime(this, mHour, mMinutes,
mRepeatPref.getDaysOfWeek()));
}

private long saveAlarmAndEnableRevert() {
// Enable "Revert" to go back to the original Alarm.
long time=saveAlarm();
final Button revert = (Button) findViewById(R.id.alarm_revert);
revert.setEnabled(true);
return time;
}

private long saveAlarm() {
Alarm alarm = new Alarm();
alarm.id = mId;
alarm.enabled = mEnabledPref.isChecked();
alarm.hour = mHour;
alarm.minutes = mMinutes;
alarm.daysOfWeek = mRepeatPref.getDaysOfWeek();
alarm.vibrate = mVibratePref.isChecked();
alarm.fmState = mFMRingState.isChecked();
String str = (String) mFMAlarmPref.getSummary();
if (str != getString(R.string.select_channel)) {
alarm.fmChannel = (int) (Float.parseFloat(str.substring(0,
str.lastIndexOf(" "))) * 10);
} else {
alarm.fmChannel = mFMAlarmPref.getChannel();
}
alarm.label = mLabel.getText();
alarm.alert = mAlarmPref.getAlert();
alarm.alert_title = mAlarmPref.getAlertTitle() ;
long time;
if (alarm.id == -1) {
time = Alarms.addAlarm(this, alarm);
// addAlarm populates the alarm with the new id. Update mId so that
// changes to other preferences update the new alarm.
mId = alarm.id;
} else {
time = Alarms.setAlarm(this, alarm);
}
return time;
}

private void deleteAlarm() {
new AlertDialog.Builder(this)
.setTitle(getString(R.string.delete_alarm))
.setMessage(getString(R.string.delete_alarm_confirm))
.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface d, int w) {
Alarms.deleteAlarm(SetAlarm.this, mId);
finish();
}
})
.setNegativeButton(android.R.string.cancel, null)
.show();
}

private void searchConfirm() {
new AlertDialog.Builder(this)
.setTitle(getString(R.string.info))
.setMessage(getString(R.string.auto_search_confirm))
.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int w) {
dialog.dismiss();
searchProcess();
}

private void searchProcess() {
LinearLayout myLayout;
LayoutInflater layoutInflater;
AlertDialog.Builder dialogBuilder;

myLayout = new LinearLayout(SetAlarm.this);
layoutInflater=(LayoutInflater) getSystemService(SetAlarm.this.LAYOUT_INFLATER_SERVICE);
myLayout=(LinearLayout) layoutInflater.inflate(R.layout.progress_dialog, null);

progressBar=(ProgressBar)myLayout.findViewById(R.id.progressBar);
progressBar.setMax(205);

dialogBuilder = new AlertDialog.Builder(SetAlarm.this);
dialogBuilder.setView(myLayout);
dialogBuilder.setMessage(SetAlarm.this.getString(R.string.channel_searching));
dialog = dialogBuilder.show();
dialog.setCancelable(false);
if (localAudioManager != null && localAudioManager.isWiredHeadsetOn()) {
registerReceiver(searchBroadcast, new IntentFilter(SEARCH_DONE));
registerReceiver(searchBroadcast, new IntentFilter(SET_PROGRESS));
mFMAlarmPref.searchChannel();
} else {
if(dialog != null && dialog.isShowing())
{
dialog.dismiss();
}
Toast toast = Toast.makeText(SetAlarm.this, SetAlarm.this.getString(R.string.plug_in_headset), Toast.LENGTH_LONG);
ToastMaster.setToast(toast);
toast.show();
}
}
})
.setNegativeButton(android.R.string.cancel,
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog,
int which) {
mFMRingState.setChecked(false);
mAlarmPref.setEnabled(true);
dialog.dismiss();
}

}).show();}

/**
* Display a toast that tells the user how long until the alarm
* goes off.  This helps prevent "am/pm" mistakes.
*/
static void popAlarmSetToast(Context context, int hour, int minute,
Alarm.DaysOfWeek daysOfWeek) {
popAlarmSetToast(context,
Alarms.calculateAlarm(hour, minute, daysOfWeek)
.getTimeInMillis());
}

static void popAlarmSetToast(Context context, long timeInMillis) {
String toastText = formatToast(context, timeInMillis);
Toast toast = Toast.makeText(context, toastText, Toast.LENGTH_LONG);
ToastMaster.setToast(toast);
toast.show();
}

/**
* format "Alarm set for 2 days 7 hours and 53 minutes from
* now"
*/
static String formatToast(Context context, long timeInMillis) {
long delta = timeInMillis - System.currentTimeMillis();
long hours = delta / (1000 * 60 * 60);
long minutes = delta / (1000 * 60) % 60;
long days = hours / 24;
hours = hours % 24;

String daySeq = (days == 0) ? "" :
(days == 1) ? context.getString(R.string.day) :
context.getString(R.string.days, Long.toString(days));

String minSeq = (minutes == 0) ? "" :
(minutes == 1) ? context.getString(R.string.minute) :
context.getString(R.string.minutes, Long.toString(minutes));

String hourSeq = (hours == 0) ? "" :
(hours == 1) ? context.getString(R.string.hour) :
context.getString(R.string.hours, Long.toString(hours));

boolean dispDays = days > 0;
boolean dispHour = hours > 0;
boolean dispMinute = minutes > 0;

int index = (dispDays ? 1 : 0) |
(dispHour ? 2 : 0) |
(dispMinute ? 4 : 0);

String[] formats = context.getResources().getStringArray(R.array.alarm_set);
return String.format(formats[index], daySeq, hourSeq, minSeq);
}
/**
* when new set time has already been set by other alarms , show timepicker again
* @param hour
* @param minute
*/
private void sameAlarmShow(int hour,int minute){
String time = hour+":"+minute;
if(minute<10){
time = hour+":0"+minute;
}

if( sameAlarmToast != null ){
sameAlarmToast.setText(getString(R.string.alarm_alread_exist, time)) ;
sameAlarmToast.show() ;
showTimePicker();
return ;

}
sameAlarmToast = new Toast(this).makeText(this, getString(R.string.alarm_alread_exist, time), Toast.LENGTH_LONG);
sameAlarmToast.show() ;
showTimePicker();
}

//add by spreadst modify bug 13250 begin:
public class FilenameLength implements InputFilter {
public FilenameLength(int max) {
mMax = max;
}
public CharSequence filter(CharSequence source, int start, int end,
Spanned dest, int dstart, int dend) {
int keep = mMax - (dest.length() - (dend - dstart));
if (keep <= 0) {
sendFilenameToast(MAX_LABLE_DELAY);
return "";
} else if (keep >= end - start) {
return null; // keep original
} else {
sendFilenameToast(MAX_LABLE_DELAY);
return source.subSequence(start, start + keep);
}
}
private int mMax;
}

public void sendFilenameToast(int delay){
mHandler.removeMessages(MAX_LABLE_SEND);
if(mFlag){
mHandler.sendEmptyMessageDelayed(MAX_LABLE_SEND, delay);
}else{
mHandler.sendMessage(mHandler.obtainMessage(MAX_LABLE_SEND));
mFlag = true;
}

}

//add by spreadst modify bug 13250 end:

}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_gravity="center_horizontal"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<ProgressBar
android:layout_gravity="center_vertical"
android:layout_height="wrap_content"
android:layout_width="match_parent"
android:layout_marginTop="10dp"
android:layout_marginBottom="10dp"
style="?android:attr/progressBarStyleHorizontal"
android:id="@+id/progressBar">
</ProgressBar>
</LinearLayout>