src/com/android/fmradio/FmStation.java - fp2-dev/platform/packages/apps/FMRadio - Gitiles

 /*
  * Copyright (C) 2014 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.fmradio;

 import android.content.ContentValues;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.database.Cursor;
 import android.net.Uri;
 import android.preference.PreferenceManager;
 import android.provider.BaseColumns;
 import android.text.TextUtils;

 /**
  * This class provider interface to operator databases, use by activity and
  * service
  */
 public class FmStation {
     private static final String TAG = "FmStation";
     // authority use composite content provider uri
     public static final String AUTHORITY = "com.android.fmradio";
     // use to composite content provider uri
     public static final String STATION = "station";
     // store current station in share preference with this key
     public static final String CURRENT_STATION = "curent_station";

     public static final String[] COLUMNS = new String[] {
         Station._ID,
         Station.FREQUENCY,
         Station.IS_FAVORITE,
         Station.STATION_NAME,
         Station.PROGRAM_SERVICE,
         Station.RADIO_TEXT,
     };

     /**
      * This class provider the columns of StationList table
      */
     public static final class Station implements BaseColumns {
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + STATION);

         /**
          * Station frequency(Hz)
          * <P>Type: INTEGER </P>
          */
         public static final String FREQUENCY = "frequency";

         /**
          * If this station is favorite, it is 1, otherwise 0
          * <P>Type: INTEGER (boolean)</P>
          */
         public static final String IS_FAVORITE = "is_favorite";

         /**
          * Station name, if user rename a station, this must be not null, otherwise is null.
          * <P>Type: TEXT</P>
          */
         public static final String STATION_NAME = "station_name";

         /**
          * Program service(PS), station name provide by RDS station
          * <P>Type: TEXT</P>
          */
         public static final String PROGRAM_SERVICE = "program_service";

         /**
          * Radio text(RT or rds), detail ration text provide by RDS station.
          * <P>Type: TEXT</P>
          */
         public static final String RADIO_TEXT = "radio_text";
     }

     /**
      * Insert station information to database
      *
      * @param context The context
      * @param frequency The station frequency
      * @param stationName The station name
      */
     public static void insertStationToDb(Context context, int frequency, String stationName) {
         ContentValues values = new ContentValues(2);
         values.put(Station.FREQUENCY, frequency);
         values.put(Station.STATION_NAME, stationName);
         context.getContentResolver().insert(Station.CONTENT_URI, values);
     }

     /**
      * Insert station information to database with given frequency, station name, PS and RT
      *
      * @param context The context
      * @param frequency The station frequency
      * @param stationName The station name
      * @param ps The program service
      * @param rt The radio text
      */
     public static void insertStationToDb(
             Context context, int frequency, String stationName, String ps, String rt) {
         ContentValues values = new ContentValues(4);
         values.put(Station.FREQUENCY, frequency);
         values.put(Station.STATION_NAME, stationName);
         values.put(Station.PROGRAM_SERVICE, ps);
         values.put(Station.RADIO_TEXT, rt);
         context.getContentResolver().insert(Station.CONTENT_URI, values);
     }

     /**
      * Insert station information to database with given values
      *
      * @param context The context
      * @param values Need inserted values
      */
     public static void insertStationToDb(Context context, ContentValues values) {
         context.getContentResolver().insert(Station.CONTENT_URI, values);
     }

     /**
      * Update station name according to given frequency
      *
      * @param context The context
      * @param frequency the station frequency need to update
      * @param stationName The new station's name
      */
     public static void updateStationToDb(Context context, int frequency, String stationName) {
         final int size = 1;
         ContentValues values = new ContentValues(size);
         values.put(Station.STATION_NAME, stationName);
         context.getContentResolver().update(
                 Station.CONTENT_URI,
                 values,
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency)});
     }

     /**
      * Update station information according to given frequency
      *
      * @param context The context
      * @param frequency the station frequency need to update
      * @param values The new station's values
      */
     public static void updateStationToDb(Context context, int frequency, ContentValues values) {
         context.getContentResolver().update(
                 Station.CONTENT_URI,
                 values,
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency)});
     }

     /**
      * Delete station according to given frequency
      *
      * @param context The context
      * @param frequency The station frequency
      */
     public static void deleteStationInDb(Context context, int frequency) {
         context.getContentResolver().delete(
                 Station.CONTENT_URI,
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency)});
     }

     /**
      * Check whether the given frequency station is exist in database
      *
      * @param context The context
      * @param frequency The station frequency
      *
      * @return true or false indicate whether station is exist
      */
     public static boolean isStationExist(Context context, int frequency) {
         boolean isExist = false;
         Cursor cursor = null;
         try {
             cursor = context.getContentResolver().query(
                 Station.CONTENT_URI,
                 new String[] { Station.STATION_NAME },
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency) },
                 null);
             if (cursor != null && cursor.moveToFirst()) {
                 isExist = true;
             }
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
         }
         return isExist;
     }

     /**
      * Get current station from share preference
      *
      * @param context The context
      *
      * @return the current station in store share preference
      */
     public static int getCurrentStation(Context context) {
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
         int currentStation = prefs.getInt(CURRENT_STATION, FmUtils.DEFAULT_STATION);
         return currentStation;
     }

     /**
      * store current station to share preference
      *
      * @param context The context
      * @param frequency The current station frequency
      */
     public static void setCurrentStation(Context context, int frequency) {
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
         SharedPreferences.Editor editor = prefs.edit();
         editor.putInt(CURRENT_STATION, frequency);
         editor.commit();
     }

     /**
      * Get station name, if user rename station, we return user set station name, otherwise
      * return program service.
      *
      * @param context The context
      * @param frequency The station frequency
      *
      * @return The station name
      */
     public static String getStationName(Context context, int frequency) {
         String stationName = null;
         Cursor cursor = null;
         try {
             cursor = context.getContentResolver().query(
                     Station.CONTENT_URI,
                     new String[] { Station.STATION_NAME, Station.PROGRAM_SERVICE },
                     Station.FREQUENCY + "=?",
                     new String[] { String.valueOf(frequency) },
                     null);
             if (cursor != null && cursor.moveToFirst()) {
                 // If the station name is not exist, show program service(PS) instead
                 stationName = cursor.getString(cursor.getColumnIndex(Station.STATION_NAME));
                 if (TextUtils.isEmpty(stationName)) {
                     stationName = cursor.getString(cursor.getColumnIndex(Station.PROGRAM_SERVICE));
                 }
             }
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
         }
         return stationName;
     }

     /**
      * Judge whether station is a favorite station
      *
      * @param context The context
      * @param frequency The station frequency
      *
      * @return true or false indicate whether the station is favorite
      */
     public static boolean isFavoriteStation(Context context, int frequency) {
         boolean isFavorite = false;
         Cursor cursor = null;
         try {
             cursor = context.getContentResolver().query(
                 Station.CONTENT_URI,
                 new String[] { Station.IS_FAVORITE },
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency) },
                 null);
             if (cursor != null && cursor.moveToFirst()) {
                 isFavorite = cursor.getInt(0) > 0;
             }
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
         }
         return isFavorite;
     }

     /**
      * update db to mark it is a favorite frequency
      *
      * @param context The context
      * @param frequency The target frequency
      */
     public static void addToFavorite(Context context, int frequency) {
         ContentValues values = new ContentValues(1);
         values.put(Station.IS_FAVORITE, true);
         context.getContentResolver().update(
                 Station.CONTENT_URI,
                 values,
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency) });
     }

     /**
      * update db to mark it is a normal frequency
      *
      * @param context The context
      * @param frequency The target frequency
      */
     public static void removeFromFavorite(Context context, int frequency) {
         ContentValues values = new ContentValues(1);
         values.put(Station.IS_FAVORITE, false);
         values.put(Station.STATION_NAME, "");
         context.getContentResolver().update(
                 Station.CONTENT_URI,
                 values,
                 Station.FREQUENCY + "=?",
                 new String[] { String.valueOf(frequency) });
     }

     /**
      * Get station count
      *
      * @param context The context
      *
      * @return The numbers of station
      */
     public static int getStationCount(Context context) {
         int stationNus = 0;
         Cursor cursor = null;
         try {
             cursor = context.getContentResolver().query(
                     Station.CONTENT_URI,
                     new String[] { Station._ID },
                     null,
                     null,
                     null);
                 if (cursor != null) {
                     stationNus = cursor.getCount();
                 }
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
         }
         return stationNus;
     }

     /**
      * Clean all stations which station type is searched
      *
      * @param context The context
      */
     public static void cleanSearchedStations(Context context) {
         context.getContentResolver().delete(Station.CONTENT_URI,
                 Station.IS_FAVORITE + "=0", null);
     }

     /**
      * Clear all station of FMRadio database
      *
      * @param context The context
      */
     public static void cleanAllStations(Context context) {
         context.getContentResolver().delete(Station.CONTENT_URI, null, null);
     }
 }
	/*
	* Copyright (C) 2014 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.fmradio;

	import android.content.ContentValues;
	import android.content.Context;
	import android.content.SharedPreferences;
	import android.database.Cursor;
	import android.net.Uri;
	import android.preference.PreferenceManager;
	import android.provider.BaseColumns;
	import android.text.TextUtils;

	/**
	* This class provider interface to operator databases, use by activity and
	* service
	*/
	public class FmStation {
	private static final String TAG = "FmStation";
	// authority use composite content provider uri
	public static final String AUTHORITY = "com.android.fmradio";
	// use to composite content provider uri
	public static final String STATION = "station";
	// store current station in share preference with this key
	public static final String CURRENT_STATION = "curent_station";

	public static final String[] COLUMNS = new String[] {
	Station._ID,
	Station.FREQUENCY,
	Station.IS_FAVORITE,
	Station.STATION_NAME,
	Station.PROGRAM_SERVICE,
	Station.RADIO_TEXT,
	};

	/**
	* This class provider the columns of StationList table
	*/
	public static final class Station implements BaseColumns {
	public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + STATION);

	/**
	* Station frequency(Hz)
	* <P>Type: INTEGER </P>
	*/
	public static final String FREQUENCY = "frequency";

	/**
	* If this station is favorite, it is 1, otherwise 0
	* <P>Type: INTEGER (boolean)</P>
	*/
	public static final String IS_FAVORITE = "is_favorite";

	/**
	* Station name, if user rename a station, this must be not null, otherwise is null.
	* <P>Type: TEXT</P>
	*/
	public static final String STATION_NAME = "station_name";

	/**
	* Program service(PS), station name provide by RDS station
	* <P>Type: TEXT</P>
	*/
	public static final String PROGRAM_SERVICE = "program_service";

	/**
	* Radio text(RT or rds), detail ration text provide by RDS station.
	* <P>Type: TEXT</P>
	*/
	public static final String RADIO_TEXT = "radio_text";
	}

	/**
	* Insert station information to database
	*
	* @param context The context
	* @param frequency The station frequency
	* @param stationName The station name
	*/
	public static void insertStationToDb(Context context, int frequency, String stationName) {
	ContentValues values = new ContentValues(2);
	values.put(Station.FREQUENCY, frequency);
	values.put(Station.STATION_NAME, stationName);
	context.getContentResolver().insert(Station.CONTENT_URI, values);
	}

	/**
	* Insert station information to database with given frequency, station name, PS and RT
	*
	* @param context The context
	* @param frequency The station frequency
	* @param stationName The station name
	* @param ps The program service
	* @param rt The radio text
	*/
	public static void insertStationToDb(
	Context context, int frequency, String stationName, String ps, String rt) {
	ContentValues values = new ContentValues(4);
	values.put(Station.FREQUENCY, frequency);
	values.put(Station.STATION_NAME, stationName);
	values.put(Station.PROGRAM_SERVICE, ps);
	values.put(Station.RADIO_TEXT, rt);
	context.getContentResolver().insert(Station.CONTENT_URI, values);
	}

	/**
	* Insert station information to database with given values
	*
	* @param context The context
	* @param values Need inserted values
	*/
	public static void insertStationToDb(Context context, ContentValues values) {
	context.getContentResolver().insert(Station.CONTENT_URI, values);
	}

	/**
	* Update station name according to given frequency
	*
	* @param context The context
	* @param frequency the station frequency need to update
	* @param stationName The new station's name
	*/
	public static void updateStationToDb(Context context, int frequency, String stationName) {
	final int size = 1;
	ContentValues values = new ContentValues(size);
	values.put(Station.STATION_NAME, stationName);
	context.getContentResolver().update(
	Station.CONTENT_URI,
	values,
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency)});
	}

	/**
	* Update station information according to given frequency
	*
	* @param context The context
	* @param frequency the station frequency need to update
	* @param values The new station's values
	*/
	public static void updateStationToDb(Context context, int frequency, ContentValues values) {
	context.getContentResolver().update(
	Station.CONTENT_URI,
	values,
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency)});
	}

	/**
	* Delete station according to given frequency
	*
	* @param context The context
	* @param frequency The station frequency
	*/
	public static void deleteStationInDb(Context context, int frequency) {
	context.getContentResolver().delete(
	Station.CONTENT_URI,
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency)});
	}

	/**
	* Check whether the given frequency station is exist in database
	*
	* @param context The context
	* @param frequency The station frequency
	*
	* @return true or false indicate whether station is exist
	*/
	public static boolean isStationExist(Context context, int frequency) {
	boolean isExist = false;
	Cursor cursor = null;
	try {
	cursor = context.getContentResolver().query(
	Station.CONTENT_URI,
	new String[] { Station.STATION_NAME },
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency) },
	null);
	if (cursor != null && cursor.moveToFirst()) {
	isExist = true;
	}
	} finally {
	if (cursor != null) {
	cursor.close();
	}
	}
	return isExist;
	}

	/**
	* Get current station from share preference
	*
	* @param context The context
	*
	* @return the current station in store share preference
	*/
	public static int getCurrentStation(Context context) {
	SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
	int currentStation = prefs.getInt(CURRENT_STATION, FmUtils.DEFAULT_STATION);
	return currentStation;
	}

	/**
	* store current station to share preference
	*
	* @param context The context
	* @param frequency The current station frequency
	*/
	public static void setCurrentStation(Context context, int frequency) {
	SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
	SharedPreferences.Editor editor = prefs.edit();
	editor.putInt(CURRENT_STATION, frequency);
	editor.commit();
	}

	/**
	* Get station name, if user rename station, we return user set station name, otherwise
	* return program service.
	*
	* @param context The context
	* @param frequency The station frequency
	*
	* @return The station name
	*/
	public static String getStationName(Context context, int frequency) {
	String stationName = null;
	Cursor cursor = null;
	try {
	cursor = context.getContentResolver().query(
	Station.CONTENT_URI,
	new String[] { Station.STATION_NAME, Station.PROGRAM_SERVICE },
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency) },
	null);
	if (cursor != null && cursor.moveToFirst()) {
	// If the station name is not exist, show program service(PS) instead
	stationName = cursor.getString(cursor.getColumnIndex(Station.STATION_NAME));
	if (TextUtils.isEmpty(stationName)) {
	stationName = cursor.getString(cursor.getColumnIndex(Station.PROGRAM_SERVICE));
	}
	}
	} finally {
	if (cursor != null) {
	cursor.close();
	}
	}
	return stationName;
	}

	/**
	* Judge whether station is a favorite station
	*
	* @param context The context
	* @param frequency The station frequency
	*
	* @return true or false indicate whether the station is favorite
	*/
	public static boolean isFavoriteStation(Context context, int frequency) {
	boolean isFavorite = false;
	Cursor cursor = null;
	try {
	cursor = context.getContentResolver().query(
	Station.CONTENT_URI,
	new String[] { Station.IS_FAVORITE },
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency) },
	null);
	if (cursor != null && cursor.moveToFirst()) {
	isFavorite = cursor.getInt(0) > 0;
	}
	} finally {
	if (cursor != null) {
	cursor.close();
	}
	}
	return isFavorite;
	}

	/**
	* update db to mark it is a favorite frequency
	*
	* @param context The context
	* @param frequency The target frequency
	*/
	public static void addToFavorite(Context context, int frequency) {
	ContentValues values = new ContentValues(1);
	values.put(Station.IS_FAVORITE, true);
	context.getContentResolver().update(
	Station.CONTENT_URI,
	values,
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency) });
	}

	/**
	* update db to mark it is a normal frequency
	*
	* @param context The context
	* @param frequency The target frequency
	*/
	public static void removeFromFavorite(Context context, int frequency) {
	ContentValues values = new ContentValues(1);
	values.put(Station.IS_FAVORITE, false);
	values.put(Station.STATION_NAME, "");
	context.getContentResolver().update(
	Station.CONTENT_URI,
	values,
	Station.FREQUENCY + "=?",
	new String[] { String.valueOf(frequency) });
	}

	/**
	* Get station count
	*
	* @param context The context
	*
	* @return The numbers of station
	*/
	public static int getStationCount(Context context) {
	int stationNus = 0;
	Cursor cursor = null;
	try {
	cursor = context.getContentResolver().query(
	Station.CONTENT_URI,
	new String[] { Station._ID },
	null,
	null,
	null);
	if (cursor != null) {
	stationNus = cursor.getCount();
	}
	} finally {
	if (cursor != null) {
	cursor.close();
	}
	}
	return stationNus;
	}

	/**
	* Clean all stations which station type is searched
	*
	* @param context The context
	*/
	public static void cleanSearchedStations(Context context) {
	context.getContentResolver().delete(Station.CONTENT_URI,
	Station.IS_FAVORITE + "=0", null);
	}

	/**
	* Clear all station of FMRadio database
	*
	* @param context The context
	*/
	public static void cleanAllStations(Context context) {
	context.getContentResolver().delete(Station.CONTENT_URI, null, null);
	}
	}