trackbrowseractivity.java

Android平台上的media player, iPhone风格

            }
        }
        
        if (mGenre != null) {
            mSortOrder = MediaStore.Audio.Genres.Members.DEFAULT_SORT_ORDER;
            ret = MusicUtils.query(this,
                    MediaStore.Audio.Genres.Members.getContentUri("external", Integer.valueOf(mGenre)),
                    mCursorCols, where.toString(), keywords, mSortOrder);
        } else if (mPlaylist != null) {
            if (mPlaylist.equals("nowplaying")) {
                if (MusicUtils.sService != null) {
                    ret = new NowPlayingCursor(MusicUtils.sService, mCursorCols);
                    if (ret.getCount() == 0) {
                        finish();
                    }
                } else {
                    // Nothing is playing.
                }
            } else {
                mSortOrder = MediaStore.Audio.Playlists.Members.DEFAULT_SORT_ORDER;
                ret = MusicUtils.query(this,
                        MediaStore.Audio.Playlists.Members.getContentUri("external", Long.valueOf(mPlaylist)),
                        mPlaylistMemberCols, where.toString(), keywords, mSortOrder);
            }
        } else {
            if (mAlbumId != null) {
                where.append(" AND " + MediaStore.Audio.Media.ALBUM_ID + "='" + mAlbumId + "'");
                mSortOrder = MediaStore.Audio.Media.TRACK + ", " + mSortOrder;
            }
            where.append(" AND " + MediaStore.Audio.Media.IS_MUSIC + "=1");
            ret = MusicUtils.query(this, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
                mCursorCols, where.toString() , keywords, mSortOrder);
        }
        return ret;
    }

    private class NowPlayingCursor extends AbstractCursor
    {
        public NowPlayingCursor(IMediaPlaybackService service, String [] cols)
        {
            mCols = cols;
            mService  = service;
            makeNowPlayingCursor();
        }
        private void makeNowPlayingCursor() {
            mCurrentPlaylistCursor = null;
            try {
                mNowPlaying = mService.getQueue();
            } catch (RemoteException ex) {
                mNowPlaying = new int[0];
            }
            mSize = mNowPlaying.length;
            if (mSize == 0) {
                return;
            }

            StringBuilder where = new StringBuilder();
            where.append(MediaStore.Audio.Media._ID + " IN (");
            for (int i = 0; i < mSize; i++) {
                where.append(mNowPlaying[i]);
                if (i < mSize - 1) {
                    where.append(",");
                }
            }
            where.append(")");

            mCurrentPlaylistCursor = MusicUtils.query(TrackBrowserActivity.this,
                    MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
                    mCols, where.toString(), null, MediaStore.Audio.Media._ID);

            if (mCurrentPlaylistCursor == null) {
                mSize = 0;
                return;
            }
            
            int size = mCurrentPlaylistCursor.getCount();
            mCursorIdxs = new int[size];
            mCurrentPlaylistCursor.moveToFirst();
            int colidx = mCurrentPlaylistCursor.getColumnIndex(MediaStore.Audio.Media._ID);
            for (int i = 0; i < size; i++) {
                mCursorIdxs[i] = mCurrentPlaylistCursor.getInt(colidx);
                mCurrentPlaylistCursor.moveToNext();
            }
            mCurrentPlaylistCursor.moveToFirst();
            mCurPos = -1;
        }

        @Override
        public int getCount()
        {
            return mSize;
        }

        @Override
        public boolean onMove(int oldPosition, int newPosition)
        {
            if (oldPosition == newPosition)
                return true;
            
            if (mNowPlaying == null || mCursorIdxs == null) {
                return false;
            }

            // The cursor doesn't have any duplicates in it, and is not ordered
            // in queue-order, so we need to figure out where in the cursor we
            // should be.
           
            int newid = mNowPlaying[newPosition];
            int crsridx = Arrays.binarySearch(mCursorIdxs, newid);
            mCurrentPlaylistCursor.moveToPosition(crsridx);
            mCurPos = newPosition;
            
            return true;
        }

//        @Override
//        public boolean deleteRow()
//        {
//            try {
//                if (mService.removeTracks((int)mCurPos, (int)mCurPos) == 0) {
//                    return false; // delete failed
//                }
//                int i = (int) mCurPos;
//                mSize--;
//                while (i < mSize) {
//                    mNowPlaying[i] = mNowPlaying[i+1];
//                    i++;
//                }
//                onMove(-1, (int) mCurPos);
//            } catch (RemoteException ex) {
//            }
//            return true;
//        }
        
        public void moveItem(int from, int to) {
            try {
                mService.moveQueueItem(from, to);
                mNowPlaying = mService.getQueue();
                onMove(-1, mCurPos); // update the underlying cursor
            } catch (RemoteException ex) {
            }
        }

        private void dump() {
            String where = "(";
            for (int i = 0; i < mSize; i++) {
                where += mNowPlaying[i];
                if (i < mSize - 1) {
                    where += ",";
                }
            }
            where += ")";
            Log.i("NowPlayingCursor: ", where);
        }

        @Override
        public String getString(int column)
        {
            try {
                return mCurrentPlaylistCursor.getString(column);
            } catch (Exception ex) {
                onChange(true);
                return "";
            }
        }

        @Override
        public short getShort(int column)
        {
            return mCurrentPlaylistCursor.getShort(column);
        }

        @Override
        public int getInt(int column)
        {
            try {
                return mCurrentPlaylistCursor.getInt(column);
            } catch (Exception ex) {
                onChange(true);
                return 0;
            }
        }

        @Override
        public long getLong(int column)
        {
            return mCurrentPlaylistCursor.getLong(column);
        }

        @Override
        public float getFloat(int column)
        {
            return mCurrentPlaylistCursor.getFloat(column);
        }

        @Override
        public double getDouble(int column)
        {
            return mCurrentPlaylistCursor.getDouble(column);
        }

        @Override
        public boolean isNull(int column)
        {
            return mCurrentPlaylistCursor.isNull(column);
        }

        @Override
        public String[] getColumnNames()
        {
            return mCols;
        }
        
        @Override
        public void deactivate()
        {
            if (mCurrentPlaylistCursor != null)
                mCurrentPlaylistCursor.deactivate();
        }

        @Override
        public boolean requery()
        {
            makeNowPlayingCursor();
            return true;
        }

        private String [] mCols;
        private Cursor mCurrentPlaylistCursor;     // updated in onMove
        private int mSize;          // size of the queue
        private int[] mNowPlaying;
        private int[] mCursorIdxs;
        private int mCurPos;
        private IMediaPlaybackService mService;
    }
    
    class TrackListAdapter extends SimpleCursorAdapter {
        boolean mIsNowPlaying;

        final int mTitleIdx;
        final int mArtistIdx;
        final int mAlbumIdx;
        final int mDurationIdx;
        int mAudioIdIdx;

        private final StringBuilder mBuilder = new StringBuilder();
        private final String mUnknownArtist;
        private final String mUnknownAlbum;

        class ViewHolder {
            TextView line1;
            TextView line2;
            TextView duration;
//            ImageView play_indicator;
            CharArrayBuffer buffer1;
            char [] buffer2;
        }
        
        TrackListAdapter(Context context, int layout, Cursor cursor, String[] from, int[] to,
                boolean isnowplaying) {
            super(context, layout, cursor, from, to);
            mIsNowPlaying = isnowplaying;
            mUnknownArtist = context.getString(R.string.unknown_artist_name);
            mUnknownAlbum = context.getString(R.string.unknown_album_name);
            
            mTitleIdx = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE);
            mArtistIdx = cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST);
            mAlbumIdx = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM);
            mDurationIdx = cursor.getColumnIndex(MediaStore.Audio.Media.DURATION);
            mAudioIdIdx = cursor.getColumnIndex(MediaStore.Audio.Playlists.Members.AUDIO_ID);
            if (mAudioIdIdx < 0) {
                mAudioIdIdx = cursor.getColumnIndex(MediaStore.Audio.Media._ID);
            }
        }

        @Override
        public View newView(Context context, Cursor cursor, ViewGroup parent) {
            View v = super.newView(context, cursor, parent);
            ImageView iv = (ImageView) v.findViewById(R.id.icon);
            if (mEditMode) {
                iv.setVisibility(View.VISIBLE);
                iv.setImageResource(R.drawable.ic_mp_move);
                ViewGroup.LayoutParams p = iv.getLayoutParams();
                p.width = ViewGroup.LayoutParams.WRAP_CONTENT;
                p.height = ViewGroup.LayoutParams.WRAP_CONTENT;
            } else {
                iv.setVisibility(View.GONE);
            }
            
            ViewHolder vh = new ViewHolder();
            vh.line1 = (TextView) v.findViewById(R.id.line1);
            vh.line2 = (TextView) v.findViewById(R.id.line2);
            vh.duration = (TextView) v.findViewById(R.id.duration);
//            vh.play_indicator = (ImageView) v.findViewById(R.id.play_indicator);
            vh.buffer1 = new CharArrayBuffer(100);
            vh.buffer2 = new char[200];
            v.setTag(vh);
            return v;
        }

        @Override
        public void bindView(View view, Context context, Cursor cursor) {
            
            ViewHolder vh = (ViewHolder) view.getTag();
            
            cursor.copyStringToBuffer(mTitleIdx, vh.buffer1);
            vh.line1.setText(vh.buffer1.data, 0, vh.buffer1.sizeCopied);
            
            int secs = cursor.getInt(mDurationIdx) / 1000;
            if (secs == 0) {
                vh.duration.setText("");
            } else {
                vh.duration.setText(MusicUtils.makeTimeString(context, secs));
            }
            
            final StringBuilder builder = mBuilder;
            builder.delete(0, builder.length());

            String name = cursor.getString(mAlbumIdx);
            if (name == null || name.equals(MediaFile.UNKNOWN_STRING)) {
                builder.append(mUnknownAlbum);
            } else {
                builder.append(name);
            }
            builder.append('\n');
            name = cursor.getString(mArtistIdx);
            if (name == null || name.equals(MediaFile.UNKNOWN_STRING)) {
                builder.append(mUnknownArtist);
            } else {
                builder.append(name);
            }
            int len = builder.length();
            if (vh.buffer2.length < len) {
                vh.buffer2 = new char[len];
            }
            builder.getChars(0, len, vh.buffer2, 0);
            vh.line2.setText(vh.buffer2, 0, len);

//            ImageView iv = vh.play_indicator;
//            int id = -1;
//            if (MusicUtils.sService != null) {
//                // TODO: IPC call on each bind??
//                try {
//                    if (mIsNowPlaying) {
//                        id = MusicUtils.sService.getQueuePosition();
//                    } else {
//                        id = MusicUtils.sService.getAudioId();
//                    }
//                } catch (RemoteException ex) {
//                }
//            }
//            if ( (mIsNowPlaying && cursor.getPosition() == id) ||
//                 (!mIsNowPlaying && cursor.getInt(mAudioIdIdx) == id)) {
//                iv.setImageResource(R.drawable.indicator_ic_mp_playing_list);
//                iv.setVisibility(View.VISIBLE);
//            } else {
//                iv.setVisibility(View.GONE);
//            }
        }
        
        @Override
        public void changeCursor(Cursor cursor) {
            super.changeCursor(cursor);
            mTrackCursor = cursor;
        }
        @Override
        public Cursor runQueryOnBackgroundThread(CharSequence constraint) {
            return getTrackCursor(constraint.toString());
        }
    }

    private ListView mTrackList;
    private Cursor mTrackCursor;
    private String mAlbumId;
    private String mArtistId;
    private String mPlaylist;
    private String mGenre;
    private String mSortOrder;
    private int mSelectedPosition;
    private long mSelectedId;
}