एलबम्स तक कलाकारों

Question

मेरे प्रश्न है कि की संख्या =)

MPMediaQuery *artistQuery = [MPMediaQuery artistsQuery]; 
NSArray *songsByArtist = [artistQuery collections]; 

मैं कैसे songsByArtist में MPMediaItemCollections में से प्रत्येक के कलाकारों के एलबम की संख्या प्राप्त कर सकते हैं?

उदाहरण:

बीटल्स

3 एल्बम

एसी/डीसी 6 एल्बम

धन्यवाद !!

Answer 1

artistsQuery सुविधा निर्माता सॉर्ट नहीं है और समूह इस लिंक पर और अधिक देखने एल्बम द्वारा। artistsQuery कलाकार नाम द्वारा क्रमबद्ध रूप से क्रमबद्ध सभी कलाकारों के मीडिया आइटम संग्रह की एक सरणी देता है। प्रत्येक कलाकार संग्रह के अंदर नेस्टेड उस कलाकार के सभी गीतों से जुड़े मीडिया आइटमों की एक श्रृंखला है। नेस्टेड सरणी को गीत शीर्षक द्वारा क्रमबद्ध रूप से क्रमबद्ध किया जाता है।

कलाकार द्वारा एल्बमों की गिनती रखने का एक तरीका प्रत्येक कलाकार संग्रह के लिए सभी गीत वस्तुओं के माध्यम से गिनना है और प्रत्येक गीत से जुड़े विशिष्ट एल्बम शीर्षकों का ट्रैक रखने के लिए NSMutableSet का उपयोग करना है। फिर NSMutableDictionary में प्रत्येक कलाकार कुंजी के मान के रूप में सेट की गिनती जोड़ें। किसी भी डुप्लिकेट एल्बम शीर्षक नहीं जोड़ा जाएगा के बाद से एक NSMutableSet केवल विभेदित ऑब्जेक्ट्स ले जाएगा:

MPMediaQuery *artistQuery = [MPMediaQuery artistsQuery]; 
NSArray *songsByArtist = [artistQuery collections]; 
NSMutableDictionary *artistDictionary = [NSMutableDictionary dictionary]; 
NSMutableSet *tempSet = [NSMutableSet set]; 

[songsByArtist enumerateObjectsUsingBlock:^(MPMediaItemCollection *artistCollection, NSUInteger idx, BOOL *stop) { 
    NSString *artistName = [[artistCollection representativeItem] valueForProperty:MPMediaItemPropertyArtist]; 

    [[artistCollection items] enumerateObjectsUsingBlock:^(MPMediaItem *songItem, NSUInteger idx, BOOL *stop) { 
     NSString *albumName = [songItem valueForProperty:MPMediaItemPropertyAlbumTitle]; 
     [tempSet addObject:albumName]; 
    }]; 
    [artistDictionary setValue:[NSNumber numberWithUnsignedInteger:[tempSet count]] 
         forKey:artistName]; 
    [tempSet removeAllObjects]; 
}]; 
NSLog(@"Artist Album Count Dictionary: %@", artistDictionary); 

यह क्लीनर यदि आप albumsQuery करने के लिए क्वेरी को बदलने होगा। यह क्वेरी समूह और एल्बम नाम से संग्रह को व्यवस्थित करता है। तो फिर यह एल्बम संग्रह में से सरणी के माध्यम से गणना और एक NSCountedSet में प्रत्येक एल्बम के लिए प्रतिनिधि कलाकार का नाम की गिनती रखने का सिर्फ एक मामला है। गिना सेट ट्रैक करेगा बार वस्तुओं की संख्या डाला जाता है:

MPMediaQuery *albumQuery = [MPMediaQuery albumsQuery]; 
NSArray *albumCollection = [albumQuery collections]; 
NSCountedSet *artistAlbumCounter = [NSCountedSet set]; 

[albumCollection enumerateObjectsUsingBlock:^(MPMediaItemCollection *album, NSUInteger idx, BOOL *stop) { 
    NSString *artistName = [[album representativeItem] valueForProperty:MPMediaItemPropertyArtist]; 
    [artistAlbumCounter addObject:artistName]; 
}]; 
NSLog(@"Artist Album Counted Set: %@", artistAlbumCounter); 

तुम भी गिनती एक दिया वस्तु के लिए एक NSCountedSet में countForObject: विधि के साथ प्राप्त कर सकते हैं।

Answer 2

हमें इस albumsQuery

अगर यह यू मदद करता है या नीचे

http://developer.apple.com/library/ios/#documentation/mediaplayer/reference/MPMediaQuery_ClassReference/Reference/Reference.html

Answer 3

मैं का उपयोग कर कलाकार के लिए एलबम और गीतों की संख्या प्राप्त विधेय:

MPMediaPropertyPredicate *artistNamePredicate = [MPMediaPropertyPredicate predicateWithValue:@"ArtistName" forProperty:MPMediaItemPropertyArtist]; 
MPMediaQuery *myComplexQuery = [[MPMediaQuery alloc] init]; 
[myComplexQuery addFilterPredicate: artistNamePredicate]; 
NSInteger songCount = [[myComplexQuery collections] count]; //number of songs 
myComplexQuery.groupingType = MPMediaGroupingAlbum; 
NSInteger albumCount = [[myComplexQuery collections] count]; //number of albums 

Answer 4

ब्रायन के जवाब की स्विफ्ट 2 अनुवाद:

var artistQuery = MPMediaQuery.artistsQuery() 
var artistQuery.groupingType = MPMediaGrouping.AlbumArtist 
var songsByArtist = artistQuery.collections 
var artistDictionary = NSMutableDictionary() 
var tempSet = NSMutableSet() 

songsByArtist.enumerateObjectsUsingBlock { (artistCollection, idx, stop) -> Void in 
    let collection = artistCollection as! MPMediaItemCollection 
    let rowItem = collection.representativeItem 

    let artistName = rowItem?.valueForProperty(MPMediaItemPropertyAlbumArtist) 

    let collectionContent:NSArray = collection.items 

    collectionContent.enumerateObjectsUsingBlock { (songItem, idx, stop) -> Void in 
      let item = songItem as! MPMediaItem 

      let albumName = item.valueForProperty(MPMediaItemPropertyAlbumTitle) 
      self.tempSet.addObject(albumName!) 
    } 

    self.artistDictionary.setValue(NSNumber(unsignedInteger: self.tempSet.count), forKey: artistName! as! String) 
    self.tempSet.removeAllObjects() 
} 
print("Album Count Dictionary: \(artistDictionary)") 

Answer 5

धन्यवाद टिम ई, मैं अपने कोड काम करने के लिए नहीं मिल सका पहली बार, लेकिन मैंने इसे संशोधित किया और अब यह काम करता है।

let artistQuery = MPMediaQuery.artistsQuery() 
    artistQuery.groupingType = MPMediaGrouping.AlbumArtist 

    let songsByArtist = artistQuery.collections! as NSArray 
    let artistDictionary = NSMutableDictionary() 
    let tempSet = NSMutableSet() 

    songsByArtist.enumerateObjectsUsingBlock({ (artistCollection, idx, stop) -> Void in 
     let collection = artistCollection as! MPMediaItemCollection 
     let rowItem = collection.representativeItem 

     let artistName = rowItem?.valueForProperty(MPMediaItemPropertyAlbumArtist) 

     let collectionContent:NSArray = collection.items 

     collectionContent.enumerateObjectsUsingBlock({ (songItem, idx, stop) -> Void in 
      let item = songItem as! MPMediaItem 

      let albumName = item.valueForProperty(MPMediaItemPropertyAlbumTitle) 
      tempSet.addObject(albumName!) 
     }) 

     artistDictionary.setValue(NSNumber(unsignedInteger: UInt(tempSet.count)), forKey: artistName! as! String) 
     tempSet.removeAllObjects() 
    }) 

    print("Album Count Dictionary: \(artistDictionary)") 

Answer 6

देर से उत्तर के लिए खेद है।

मामले में मेरा उत्तर पोस्ट कर रहा है यह किसी के लिए उपयोगी है।

कोड नीचे एल्बम कलाकार द्वारा सभी कलाकारों समूह हो जाता है और अपनी एलबम के अंदर सभी एल्बम और गीत मिलता है।

/// Get all artists and their songs 
/// 
func getAllArtists() { 
    let query: MPMediaQuery = MPMediaQuery.artists() 
    query.groupingType = .albumArtist 

    let artistsColelctions = query.collections 

    artists.removeAll() 


    var tempSet = NSMutableSet() 



    guard artistsColelctions != nil else { 
     return 
    } 

    // 1. Create Artist Objects from collection 

    for collection in artistsColelctions! { 
     let item: MPMediaItem? = collection.representativeItem 

     var artistName = item?.value(forKey: MPMediaItemPropertyArtist) as? String ?? "<Unknown>" 
     artistName = artistName.trimmingCharacters(in: NSCharacterSet.whitespacesAndNewlines) 
     let artistId = item!.value(forProperty: MPMediaItemPropertyArtistPersistentID) as! NSNumber 


     // temp 
     let albumName = item?.albumTitle 
     let albumID = item?.albumPersistentID 

     print(albumName) 
     print(albumID) 



     // Create artist item 

     let artist = Artist() 
     artist.name = artistName 
     artist.artworkTitle = String(artistName.characters.prefix(1)).uppercased() 
     artist.artistId = String(describing: artistId) 


     // 2. Get Albums for respective Artist object 
     //-------------------------------------------- 

     let mediaQuery2 = MPMediaQuery.albums() 
     let predicate2 = MPMediaPropertyPredicate.init(value: artistId, forProperty: MPMediaItemPropertyArtistPersistentID) 
     mediaQuery2.addFilterPredicate(predicate2) 

     let albums = mediaQuery2.collections 

     for collection in albums! { 
      let item: MPMediaItem? = collection.representativeItem 

      let albumName = item?.value(forKey: MPMediaItemPropertyAlbumTitle) as? String ?? "<Unknown>" 
      let albumId = item!.value(forProperty: MPMediaItemPropertyAlbumPersistentID) as! NSNumber 
      let artistName = item?.value(forKey: MPMediaItemPropertyAlbumArtist) as? String ?? "unknown" 

      let genreName = item?.genre ?? "" 

      let year = item?.releaseDate ?? item?.dateAdded 

      let dateAdded = item?.dateAdded 

      // Create album object 

      let album = Album() 
      album.name = albumName 
      album.artistName = artistName 
      album.genre = genreName 
      album.releaseDate = year 
      album.dateAdded = dateAdded 
      album.albumId = String(describing: albumId) 

      // Add artwork to album object 
      let artwork = Artwork.init(forAlbum: item) 
      album.artwork = artwork 


      // 3. Get Songs inside the resepctive Album object 
      //--------------------------------------------------- 

      let mediaQuery = MPMediaQuery.songs() 
      let predicate = MPMediaPropertyPredicate.init(value: albumId, forProperty: MPMediaItemPropertyAlbumPersistentID) 
      mediaQuery.addFilterPredicate(predicate) 
      let song = mediaQuery.items 

      if let allSongs = song { 
       var index = 0 

       for item in allSongs { 
        let pathURL: URL? = item.value(forProperty: MPMediaItemPropertyAssetURL) as? URL 
        let isCloud = item.value(forProperty: MPMediaItemPropertyIsCloudItem) as! Bool 

        let trackInfo = TrackInfo() 
        trackInfo.index = index 
        trackInfo.mediaItem = item 
        trackInfo.isCloudItem = isCloud 

        trackInfo.isExplicitItem = item.isExplicitItem 

        trackInfo.isSelected = false 
        trackInfo.songURL = pathURL 
        album.songs?.append(trackInfo) 
        index += 1 
       } 
      } 


      artist.albums?.append(album) 

     } 

     // Finally add the artist object to Artists Array 
     artists.append(artist) 

     } 


    }