Developer Libraries » Trusted Intents

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

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent" >

    <fragment

        android:id="@+id/fragment_app_list"

        android:layout_width="fill_parent"

        android:layout_height="fill_parent"

        class="info.guardianproject.checkey.AppListFragment" />

</RelativeLayout>

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

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

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:orientation="horizontal" >

    <ImageView

        android:id="@+id/icon"

        android:layout_width="48dip"

        android:layout_height="48dip"

        android:contentDescription="@string/icon" />

    <TextView

        android:id="@+id/text"

        android:layout_width="fill_parent"

        android:layout_height="wrap_content"

        android:gravity="left|center_vertical"

        android:textSize="24sp" />

</LinearLayout>

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

<!--

     Copyright (C) 2010 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.

-->

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

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:background="?android:attr/activatedBackgroundIndicator"

    android:minHeight="?android:attr/listPreferredItemHeight"

    android:paddingBottom="2dip"

    android:paddingTop="2dip"

    tools:ignore="NewApi" >

    <!-- TODO remove NewApi ignore when appcompat-v7 is in place -->

    <ImageView

        android:id="@+id/icon"

        android:layout_width="48dip"

        android:layout_height="48dip"

        android:layout_marginLeft="?android:attr/listPreferredItemPaddingLeft"

        android:layout_marginStart="?android:attr/listPreferredItemPaddingLeft"

        android:layout_marginTop="6dip"

        tools:ignore="ContentDescription" />

    <TwoLineListItem

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:mode="twoLine" >

        <TextView

            android:id="@+id/application_label"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:layout_marginLeft="?android:attr/listPreferredItemPaddingLeft"

            android:layout_marginStart="?android:attr/listPreferredItemPaddingLeft"

            android:layout_marginTop="6dip"

            android:textAppearance="?android:attr/textAppearanceListItem" />

        <TextView

            android:id="@+id/package_name"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:layout_alignStart="@+id/application_label"

            android:layout_below="@+id/application_label"

            android:textAppearance="?android:attr/textAppearanceSmall" />

    </TwoLineListItem>

</LinearLayout>

        android:icon="@android:drawable/ic_menu_preferences"

</menu>

    <string name="icon">icon</string>

    <string name="no_applications_found">No applications found</string>

</resources>

/*

 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.

Based on Paul Blundell's Tutorial:

http://blog.blundell-apps.com/tut-asynctask-loader-using-support-library/

which is originally based on:

https://developer.android.com/reference/android/content/AsyncTaskLoader.html

 */

package info.guardianproject.checkey;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageManager;

import android.graphics.drawable.Drawable;

import java.io.File;

public class AppEntry {

    public static final String TAG = "AppEntry";

    private final AppListLoader loader;

    private final ApplicationInfo info;

    private final File apkFile;

    private boolean enabled;

    private String label;

    private Drawable icon;

    private boolean mounted;

    public AppEntry(AppListLoader loader, ApplicationInfo info) {

        this.loader = loader;

        this.info = info;

        apkFile = new File(info.sourceDir);

    }

    public ApplicationInfo getApplicationInfo() {

        return info;

    }

    public String getPackageName() {

        return info.packageName;

    }

    public String getLabel() {

        return label;

    }

    public boolean isEnabled() {

        return enabled;

    }

    public void setEnabled(boolean enabled) {

        this.enabled = enabled;

    }

    public Drawable getIcon() {

        if (icon == null) {

            if (apkFile.exists()) {

                icon = info.loadIcon(loader.pm);

                return icon;

            } else {

                mounted = false;

            }

        } else if (!mounted) {

            // If the app wasn't mounted but is now mounted, reload its icon

            if (apkFile.exists()) {

                mounted = true;

                icon = info.loadIcon(loader.pm);

            }

        } else {

            return icon;

        }

        return loader.getContext().getResources().getDrawable(android.R.drawable.sym_def_app_icon);

    }

    @Override

    public String toString() {

        return label;

    }

    public void loadLabel(PackageManager pm) {

        if (label == null || !mounted) {

            if (apkFile.exists()) {

                mounted = true;

                CharSequence label = null;

                label = info.loadLabel(pm);

                this.label = label != null ? label.toString() : info.packageName;

            } else {

                mounted = false;

                label = info.packageName;

            }

        }

    }

}

/*

 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.

Based on Paul Blundell's Tutorial:

http://blog.blundell-apps.com/tut-asynctask-loader-using-support-library/

which is originally based on:

https://developer.android.com/reference/android/content/AsyncTaskLoader.html

 */

package info.guardianproject.checkey;

import android.content.Context;

import android.util.SparseArray;

import android.view.LayoutInflater;

import android.view.View;

import android.view.ViewGroup;

import android.widget.BaseAdapter;

import android.widget.ImageView;

import android.widget.TextView;

import java.util.List;

public class AppListAdapter extends BaseAdapter {

    private final LayoutInflater inflater;

    private List<AppEntry> data;

    public AppListAdapter(Context context) {

        inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

    }

    public void setData(List<AppEntry> data) {

        this.data = data;

        notifyDataSetChanged();

    }

    @Override

    public View getView(int position, View view, ViewGroup parent) {

        if (view == null)

            view = inflater.inflate(R.layout.select_local_apps_list_item, parent, false);

        AppEntry appEntry = data.get(position);

        ImageView iconView = ViewHolder.get(view, R.id.icon);

        iconView.setImageDrawable(appEntry.getIcon());

        TextView labelView = ViewHolder.get(view, R.id.application_label);

        labelView.setText(appEntry.getLabel());

        TextView packageView = ViewHolder.get(view, R.id.package_name);

        packageView.setText(appEntry.getPackageName());

        return view;

    }

    @Override

    public int getCount() {

        return data == null ? 0 : data.size();

    }

    @Override

    public Object getItem(int position) {

        return data == null ? null : data.get(position);

    }

    @Override

    public long getItemId(int position) {

        return position;

    }

    /* from http://www.piwai.info/android-adapter-good-practices/#Update */

    public static class ViewHolder {

        // a generic return type to reduce the casting noise in client code

        @SuppressWarnings("unchecked")

        public static <T extends View> T get(View view, int id) {

            SparseArray<View> viewHolder = (SparseArray<View>) view.getTag();

            if (viewHolder == null) {

                viewHolder = new SparseArray<View>();

                view.setTag(viewHolder);

            }

            View childView = viewHolder.get(id);

            if (childView == null) {

                childView = view.findViewById(id);

                viewHolder.put(id, childView);

            }

            return (T) childView;

        }

    }

}

/*

 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.

Based on Paul Blundell's Tutorial:

http://blog.blundell-apps.com/tut-asynctask-loader-using-support-library/

which is originally based on:

https://developer.android.com/reference/android/content/AsyncTaskLoader.html

 */

package info.guardianproject.checkey;

import android.annotation.TargetApi;

import android.os.Bundle;

import android.support.v4.app.ListFragment;

import android.support.v4.app.LoaderManager.LoaderCallbacks;

import android.support.v4.content.Loader;

import android.view.View;

import android.widget.ListView;

import java.util.List;

public class AppListFragment extends ListFragment implements LoaderCallbacks<List<AppEntry>> {

    private AppListAdapter adapter;

    @Override

    public void onActivityCreated(Bundle savedInstanceState) {

        super.onActivityCreated(savedInstanceState);

        setEmptyText(getString(R.string.no_applications_found));

        adapter = new AppListAdapter(getActivity());

        setListAdapter(adapter);

        setListShown(false);

        // Prepare the loader

        // either reconnect with an existing one or start a new one

        getLoaderManager().initLoader(0, null, this);

    }

    @TargetApi(11)

    // TODO replace with appcompat-v7

    @Override

    public void onListItemClick(ListView l, View v, int position, long id) {

        AppEntry appEntry = (AppEntry) adapter.getItem(position);

        // TODO search androidobs here

    }

    @Override

    public Loader<List<AppEntry>> onCreateLoader(int id, Bundle args) {

        // This is called when a new loader needs to be created.

        // This sample only has one Loader with no arguments, so it is simple.

        return new AppListLoader(getActivity());

    }

    @Override

    public void onLoadFinished(Loader<List<AppEntry>> loader, List<AppEntry> data) {

        adapter.setData(data);

        // The list should now be shown

        if (isResumed()) {

            setListShown(true);

        } else {

            setListShownNoAnimation(true);

        }

    }

    @Override

    public void onLoaderReset(Loader<List<AppEntry>> loader) {

        // Clear the data in the adapter

        adapter.setData(null);

    }

}

/*

 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.

Based on Paul Blundell's Tutorial:

http://blog.blundell-apps.com/tut-asynctask-loader-using-support-library/

which is originally based on:

https://developer.android.com/reference/android/content/AsyncTaskLoader.html

 */

package info.guardianproject.checkey;

import android.content.Context;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageManager;

import android.support.v4.content.AsyncTaskLoader;

import java.text.Collator;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class AppListLoader extends AsyncTaskLoader<List<AppEntry>> {

    public final PackageManager pm;

    List<AppEntry> apps;

    PackageIntentReceiver packageObserver;

    public AppListLoader(Context context) {

        super(context);

        // Retrieve the package manager for later use; note we don't

        // use 'context' directly but instead the safe global application

        // context returned by getContext().

        pm = getContext().getPackageManager();

    }

    @Override

    protected void onStartLoading() {

        super.onStartLoading();

        // AsyncTaskLoader doesnt start unless you forceLoad

        // http://code.google.com/p/android/issues/detail?id=14944

        if (apps != null) {

            deliverResult(apps);

        }

        if (takeContentChanged() || apps == null) {

            forceLoad();

        }

    }

    /**

     * This is where the bulk of the work. This function is called in a

     * background thread and should generate a new set of data to be published

     * by the loader.

     */

    @Override

    public List<AppEntry> loadInBackground() {

        // Retrieve all known applications

        List<ApplicationInfo> apps = pm.getInstalledApplications(

                PackageManager.GET_UNINSTALLED_PACKAGES |

                        PackageManager.GET_DISABLED_COMPONENTS);

        if (apps == null) {

            apps = new ArrayList<ApplicationInfo>();

        }

        // Create corresponding array of entries and load their labels

        List<AppEntry> entries = new ArrayList<AppEntry>(apps.size());

        for (ApplicationInfo applicationInfo : apps) {

            AppEntry entry = new AppEntry(this, applicationInfo);

            entry.loadLabel(pm);

            entries.add(entry);

        }

        Collections.sort(entries, Comparator.ALPHA_COMPARATOR);

        return entries;

    }

    /**

     * Called when there is new data to deliver to the client. The super class

     * will take care of delivering it; the implementation just adds a little

     * more logic

     */

    @Override

    public void deliverResult(List<AppEntry> apps) {

        if (isReset()) {

            // An async query came in while the loader is stopped. We don't need

            // the result

            if (apps != null) {

                onReleaseResources(apps);

            }

        }

        List<AppEntry> oldApps = this.apps;

        this.apps = apps;

        if (isStarted()) {

            // If the loader is currently started, we can immediately deliver a

            // result

            super.deliverResult(apps);

        }

        // At this point we can release the resources associated with 'oldApps'

        // if needed;

        // now that the new result is delivered we know that it is no longer in

        // use

        if (oldApps != null) {

            onReleaseResources(oldApps);

        }

    }

    @Override

    protected void onStopLoading() {

        // Attempts to cancel the current load task if possible

        cancelLoad();

    }

    @Override

    public void onCanceled(List<AppEntry> apps) {

        super.onCanceled(apps);

        // At this point we can release the resources associated with 'apps' if

        // needed

        onReleaseResources(apps);

    }

    /**

     * Handles request to completely reset the loader

     */

    @Override

    protected void onReset() {

        super.onReset();

        // ensure the loader is stopped

        onStopLoading();

        // At this point we can release the resources associated with 'apps' if

        // needed

        if (apps != null) {

            onReleaseResources(apps);

            apps = null;

        }

        // Stop monitoring for changes

        if (packageObserver != null) {

            getContext().unregisterReceiver(packageObserver);

            packageObserver = null;

        }

    }

    /**

     * Helper function to take care of releasing resources associated with an

     * actively loaded data set

     */

    private void onReleaseResources(List<AppEntry> apps) {

        // For a simple list there is nothing to do

        // but for a Cursor we would close it here

    }

    /**

     * Perform alphabetical comparison on AppEntry objects

     */

    static class Comparator {

        static final java.util.Comparator<AppEntry> ALPHA_COMPARATOR = new java.util.Comparator<AppEntry>() {

            private final Collator collator = Collator.getInstance();

            @Override

            public int compare(AppEntry lhs, AppEntry rhs) {

                return collator.compare(lhs.getLabel(), rhs.getLabel());

            }

        };

    }

}

import android.annotation.TargetApi;

import android.support.v4.app.FragmentActivity;

@TargetApi(11)

// TODO replace with appcompat-v7

public class MainActivity extends FragmentActivity {

    private final String TAG = "MainActivity";

    private AppListFragment appListFragment = null;

        setContentView(R.layout.activity_app_select);

    }

    @Override

    protected void onResume() {

        super.onResume();

        if (appListFragment == null)

            appListFragment = (AppListFragment) getSupportFragmentManager().findFragmentById(

                    R.id.fragment_app_list);

        switch (item.getItemId()) {

            case android.R.id.home:

                setResult(RESULT_CANCELED);

                finish();

                return true;

            case R.id.action_settings:

                return true;

/*

 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.

Based on Paul Blundell's Tutorial:

http://blog.blundell-apps.com/tut-asynctask-loader-using-support-library/

which is originally based on:

https://developer.android.com/reference/android/content/AsyncTaskLoader.html

 */

package info.guardianproject.checkey;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

/**

 * Looks for changes to the installed apps so the loader can be updated

 */

public class PackageIntentReceiver extends BroadcastReceiver {

    final AppListLoader loader;

    public PackageIntentReceiver(AppListLoader loader) {

        this.loader = loader;

        IntentFilter filter = new IntentFilter();

        filter.addAction(Intent.ACTION_PACKAGE_ADDED);

        filter.addAction(Intent.ACTION_PACKAGE_REMOVED);

        filter.addAction(Intent.ACTION_PACKAGE_CHANGED);

        filter.addDataScheme("package");

        loader.getContext().registerReceiver(this, filter);

        // Register for events related to SD Card installation

        IntentFilter sdFilter = new IntentFilter();

        sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);

        sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);

        loader.getContext().registerReceiver(this, sdFilter);

    }

    @Override

    public void onReceive(Context context, Intent intent) {

        loader.onContentChanged();

    }

}