android彈出進度條對話框的方法

實際代碼是做和做FM鬧鐘相關功能,收藏防止以後查閱

[java] 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(); 
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();
 

 

[java] 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); 
                    } 
                } 
            } 
        } 
    }; 
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);
     }
    }
   }
  }
 };

FMAlarmPreference.java文件

[java] /*
 * 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) 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) {
  }
 }
}
 

SetAlarm.java

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

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

}
 

progress_dialog.xml

[html] <?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> 
<?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>
 

 

 

摘自 知識空間

發佈留言