Android’s drawables are extremely useful to easily build applications.
A Drawable is pluggable drawing container that is usually associated with a
View. For instance, a BitmapDrawable is used to display images, a ShapeDrawable
to draw shapes and gradients, etc. You can even combine them to create
complex renderings.
Drawable star = context.getResources().getDrawable(R.drawable.star); if (your specific condition) { star.setAlpha(255); // opaque } else { star.setAlpha(70); // translucent }
Here cathodal of specific sea item in the following screen is opaque remaningare transculacent 
1 | http://chart.apis.google.com/chart?cht=p3&chd=t:30,60,10&chs=250x100&chl=cars|bikes|trucks |
1 2 3 4 5 6 7 8 | @Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);WebView googleChartView = new WebView(this);setContentView(googleChartView);String mUrl = "http://chart.apis.google.com/chart?cht=p3&chd=t:30,60,10&chs=250x100&chl=cars|bikes|trucks";googleChartView.loadUrl(mUrl);} |
1 | <uses-permission android:name="android.permission.INTERNET" /> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | public class AChartExample {public Intent execute(Context context) {int[] colors = new int[] { Color.RED, Color.YELLOW, Color.BLUE };DefaultRenderer renderer = buildCategoryRenderer(colors);CategorySeries categorySeries = new CategorySeries("Vehicles Chart");categorySeries.add("cars ", 30);categorySeries.add("trucks", 20);categorySeries.add("bikes ", 60);return ChartFactory.getPieChartIntent(context, categorySeries, renderer);}protected DefaultRenderer buildCategoryRenderer(int[] colors) {DefaultRenderer renderer = new DefaultRenderer();for (int color : colors) {SimpleSeriesRenderer r = new SimpleSeriesRenderer();r.setColor(color);renderer.addSeriesRenderer(r);}return renderer;}} |
ChartFactory.getPieChartIntent(context, categorySeries, renderer);
1 2 | Intent achartIntent = new AChartExample().execute(this);startActivity(achartIntent); |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | public class ChartDroidDataProvider extends ContentProvider {static final String AUTHORITY = "com.xyz.contentprovider.chardroid";@Overridepublic String getType(Uri uri) {return "vnd.android.cursor.dir/vnd.com.googlecode.chartdroid.graphable";}public static final Uri PROVIDER_URI = new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).authority(AUTHORITY).build();@Overridepublic Cursor query(Uri uri, String[] projection, String selection,String[] selectionArgs, String sortOrder) {// Fetch the actual dataMatrixCursor c = new MatrixCursor(new String[] { BaseColumns._ID,"COLUMN_AXIS_INDEX", "COLUMN_SERIES_INDEX","COLUMN_DATUM_VALUE", "COLUMN_DATUM_LABEL" });c.newRow().add(1).add(0).add(1).add(30).add(null);c.newRow().add(2).add(0).add(1).add(10).add(null);c.newRow().add(3).add(0).add(1).add(60).add(null);return c;}} |
1 2 3 4 5 6 | Intent chartDroidIntent = new Intent(Intent.ACTION_VIEW,ChartDroidDataProvider.PROVIDER_URI);chartDroidIntent.putExtra(Intent.EXTRA_TITLE, "Chart droid");chartDroidIntent.addCategory("com.googlecode.chartdroid.intent.category.PIE_CHART");startActivity(chartDroidIntent); |
<translate android:fromXDelta="200%" android:toXDelta="0%" android:fromYDelta="200%" android:toYDelta="0%" android:duration="3000" android:zAdjustment="top" />
1 2 3 4 5 6 7 8 | @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); showDialog(LOADING_DIALOG); this.listItems = retrieveListLongRunning(); refreshListView(); dismissDialog(LOADING_DIALOG); } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | /** * Our background task split up into 3 sections * * onPreExecute - showing the dialog in the UI thread (just before doInBackground is called). * doInBackground - launches a seperate thread to refresh the list data * onPostExecute - dismisses the dialog and refreshes the list control. * */ private class ListRefresher extends AsyncTask<Uri, Void, Void> { /** * This is executed in the UI thread. The only place where we can show the dialog. */ @Override protected void onPreExecute() { showDialog(LOADING_DIALOG); } /** * This is executed in the background thread. */ @Override protected Void doInBackground(Uri... params) { refreshListLongRunning(); return null; } /** * This is executed in the UI thread. The only place where we can show the dialog. */ @Override protected void onPostExecute(Void unused) { dismissDialog(LOADING_DIALOG); refreshListView(); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | java.lang.IllegalArgumentException: no dialog with id 0 was ever shown via Activity#showDialog at android.app.Activity.missingDialog(Activity.java:2521) at android.app.Activity.dismissDialog(Activity.java:2511) at com.ecs.android.listview.sample.AsyncTaskSimple$ListRefresher.onPostExecute(AsyncTaskSimple.java:92) at com.ecs.android.listview.sample.AsyncTaskSimple$ListRefresher.onPostExecute(AsyncTaskSimple.java:1) at android.os.AsyncTask.finish(AsyncTask.java:417) at android.os.AsyncTask.access$300(AsyncTask.java:127) at android.os.AsyncTask$InternalHandler.handleMessage(AsyncTask.java:429) at android.os.Handler.dispatchMessage(Handler.java:99) at android.os.Looper.loop(Looper.java:123) at android.app.ActivityThread.main(ActivityThread.java:4363) at java.lang.reflect.Method.invokeNative(Native Method) at java.lang.reflect.Method.invoke(Method.java:521) at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:860) at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:618) at dalvik.system.NativeStart.main(Native Method) |
1 2 3 4 5 6 7 8 | /** * Cache the already fetched listItems. * This will be picked up in the onCreate method. */ @Override public Object onRetainNonConfigurationInstance() { return listItems; } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * Intelligent onCreate that takes into account the last known configuration instance. * When an activity is destroyed (as a result of a screen rotate), the onRetainNonConfigurationInstance * method is called, where we can return any state that we want to restore here. */ @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Object retained = getLastNonConfigurationInstance(); if (retained==null) { new ListRefresher().execute(); } else { this.listItems = (List<Map<String, String>>) retained; refreshListView(); } } |
1 2 3 | <activity android:name=".AsyncTaskSimpleConfigured" android:configChanges="keyboardHidden|orientation" android:label="AsyncTaskSimpleConfigured"/> |
1 2 3 4 5 | @Override public void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); setContentView(R.layout.myLayout); } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | /** * Our complex async task that holds a reference to the Activity that started it, * and a boolean to determine if the task completed. */ private class ListRefresher extends AsyncTask<Uri, Void, Void> { private AsyncTaskComplex activity; private boolean completed; private List<Map<String, String>> items = new ArrayList<Map<String, String>>(); private ListRefresher(AsyncTaskComplex activity) { this.activity = activity; } public List<Map<String, String>> getItems() { return items; } /** * Showing the dialog on the UI thread. */ @Override protected void onPreExecute() { activity.showDialog(LOADING_DIALOG); } /** * Performing the heavy lifting in the background thread thread. */ @Override protected Void doInBackground(Uri... params) { items = retrieveListLongRunning(); return null; } /** * When the task is completed, notifiy the Activity. */ @Override protected void onPostExecute(Void unused) { completed = true; notifyActivityTaskCompleted(); } private void setActivity(AsyncTaskComplex activity) { this.activity = activity; if ( completed ) { notifyActivityTaskCompleted(); } } /** * Helper method to notify the activity that this task was completed. */ private void notifyActivityTaskCompleted() { if ( null != activity ) { activity.onTaskCompleted(); } } } |
1 2 3 4 5 6 7 8 9 10 | /** * After a screen orientation change, this method is invoked. * As we're going to state save the task, we can no longer associate * it with the Activity that is going to be destroyed here. */ @Override public Object onRetainNonConfigurationInstance() { mTask.setActivity(null); return mTask; } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /** * After a screen orientation change, we associate the current ( = newly created) activity * with the restored asyncTask. * On a clean activity startup, we create a new task and associate the current activity. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Object retained = getLastNonConfigurationInstance(); if ( retained instanceof ListRefresher ) { Log.i(TAG, "Reclaiming previous background task."); mTask = (ListRefresher) retained; mTask.setActivity(this); } else { Log.i(TAG, "Creating new background task."); mTask = new ListRefresher(this); mTask.execute(); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | /** * When the aSyncTask has notified the activity that it has completed, * we can refresh the list control, and attempt to dismiss the dialog. */ private void onTaskCompleted() { Log.i(TAG, "Activity " + this + " has been notified the task is complete."); this.listItems = mTask.getItems(); refreshListView(); //Check added because dismissDialog throws an exception if the current //activity hasn't shown it. This Happens if task finishes early enough //before an orientation change that the dialog is already gone when //the previous activity bundles up the dialogs to reshow. if ( mShownDialog ) { dismissDialog(LOADING_DIALOG); Toast.makeText(this, "Finished..", Toast.LENGTH_LONG).show(); } } |