@andycui/react-native-get-music-files 3.0.1

package/ios/TurboSongs.mm

@@ -0,0 +1,420 @@
+#import "TurboSongs.h"
+#import <MediaPlayer/MediaPlayer.h>
+
+
+@implementation TurboSongs
+RCT_EXPORT_MODULE()
+
+// Example method
+// See // https://reactnative.dev/docs/native-modules-ios
+RCT_EXPORT_METHOD(getAll:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    if([MPMediaLibrary authorizationStatus] != MPMediaLibraryAuthorizationStatusAuthorized){
+        reject(@"Permission denied",@"Permission denied",0);
+        return;
+    }
+    
+    NSInteger limit = [options objectForKey:@"limit"] ? [options[@"limit"] integerValue] : 20;
+    NSInteger offset =  [options objectForKey:@"offset"] ? [options[@"offset"] integerValue] : 0;
+    NSInteger coverQty = [options objectForKey:@"coverQuality"] ? [options[@"coverQuality"] integerValue] : 100;
+    NSInteger minSongDuration = [options objectForKey:@"minSongDuration"] ? [options[@"minSongDuration"] integerValue] / 1000 : 100;
+    
+    BOOL needCover = [options objectForKey:@"coverQuality"] != nil || [options[@"coverQuality"] integerValue] == 0;
+    
+    id sortOrderValue = [options objectForKey:@"sortOrder"];
+
+    NSString *sortOrder;
+    if ([sortOrderValue isKindOfClass:[NSString class]]) {
+        sortOrder = sortOrderValue;
+    } else {
+        sortOrder = @"ASC";
+    }
+    
+    id sortByValue = [options objectForKey:@"sortBy"];
+    
+    NSString *sortBy;
+    if ([sortByValue isKindOfClass:[NSString class]]) {
+        sortBy = sortByValue;
+    } else {
+        sortBy = @"TITLE";
+    }
+    
+    NSMutableArray *mutableSongsToSerialize = [NSMutableArray array];
+
+    MPMediaQuery *mediaQuery = [MPMediaQuery songsQuery]; // run a query on song media type
+    [mediaQuery addFilterPredicate:[MPMediaPropertyPredicate predicateWithValue:@(NO)
+                       forProperty:MPMediaItemPropertyIsCloudItem]]; // ensure what we retrieve is on device
+
+    NSArray *allMediaItems = [mediaQuery items];
+    
+    // Define the range for the limited subset
+    NSRange range = NSMakeRange(offset, MIN(limit, allMediaItems.count - offset));
+    
+    // Get the subset of media items within the specified range
+    NSArray<MPMediaItem *> *limitedMediaItems = [allMediaItems subarrayWithRange:range];
+    
+    // Sort items
+    NSArray<MPMediaItem *> *sortedMediaItems = [self sortMediaItems:limitedMediaItems byKey: sortBy sortOrder: sortOrder];
+    
+    for (MPMediaItem *song in sortedMediaItems) {
+        NSDictionary *songDictionary = [NSMutableDictionary dictionary];
+        
+        NSString *durationStr = [song valueForProperty: MPMediaItemPropertyPlaybackDuration];
+        NSInteger durationInt = [durationStr integerValue];
+        
+        NSURL *assetURL = [song valueForProperty:MPMediaItemPropertyAssetURL];
+        AVAsset *asset = [AVAsset assetWithURL:assetURL];
+
+        if ([asset hasProtectedContent] == NO and durationInt >= minSongDuration) {
+            
+            NSString *title = [song valueForProperty: MPMediaItemPropertyTitle];
+            NSString *albumTitle = [song valueForProperty: MPMediaItemPropertyAlbumTitle];
+            NSString *albumArtist = [song valueForProperty: MPMediaItemPropertyAlbumArtist];
+            NSString *genre = [song valueForProperty: MPMediaItemPropertyGenre]; // filterable
+            
+            [songDictionary setValue:[NSString stringWithString:assetURL.absoluteString] forKey:@"url"];
+            [songDictionary setValue:[NSString stringWithString:title] forKey:@"title"];
+            [songDictionary setValue:[NSString stringWithString:albumTitle] forKey:@"album"];
+            [songDictionary setValue:[NSString stringWithString:albumArtist] forKey:@"artist"];
+            [songDictionary setValue:[NSNumber numberWithInt:durationInt * 1000] forKey:@"duration"];
+            [songDictionary setValue:[NSString stringWithString:genre] forKey:@"genre"];
+            
+            if (needCover) {
+                MPMediaItemArtwork *artwork = [song valueForProperty: MPMediaItemPropertyArtwork];
+                if (artwork != nil) {
+                    UIImage *image = [artwork imageWithSize:CGSizeMake(coverQty, coverQty)];
+                    // http://www.12qw.ch/2014/12/tooltip-decoding-base64-images-with-chrome-data-url/
+                    // http://stackoverflow.com/a/510444/185771
+                    NSString *base64 = [NSString stringWithFormat:@"%@%@", @"data:image/jpeg;base64,", [self imageToNSString:image]];
+                    [songDictionary setValue:base64 forKey:@"cover"];
+                } else {
+                    [songDictionary setValue:@"" forKey:@"cover"];
+                }
+            } else {
+                [songDictionary setValue:@"" forKey:@"cover"];
+            }
+            
+            [mutableSongsToSerialize addObject:songDictionary];
+        }
+    }
+
+    resolve(mutableSongsToSerialize);
+}
+
+RCT_EXPORT_METHOD(getAlbums:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    
+    if([MPMediaLibrary authorizationStatus] != MPMediaLibraryAuthorizationStatusAuthorized){
+        reject(@"Permission denied",@"Permission denied",0);
+        return;
+    }
+    
+    NSInteger limit = [options objectForKey:@"limit"] ? [options[@"limit"] integerValue] : 20;
+    NSInteger offset =  [options objectForKey:@"offset"] ? [options[@"offset"] integerValue] : 0;
+    NSInteger coverQty = [options objectForKey:@"coverQuality"] ? [options[@"coverQuality"] integerValue] : 100;
+    NSString *artist = options[@"artist"];
+    
+    BOOL needCover = [options objectForKey:@"coverQuality"] != nil || [options[@"coverQuality"] integerValue] == 0;
+    
+    id sortOrderValue = [options objectForKey:@"sortOrder"];
+
+    NSString *sortOrder;
+    if ([sortOrderValue isKindOfClass:[NSString class]]) {
+        sortOrder = sortOrderValue;
+    } else {
+        sortOrder = @"ASC";
+    }
+    
+    id sortByValue = [options objectForKey:@"sortBy"];
+    
+    NSString *sortBy;
+    if ([sortByValue isKindOfClass:[NSString class]]) {
+        sortBy = sortByValue;
+    } else {
+        sortBy = @"TITLE";
+    }
+    
+    if(artist.length == 0){
+        reject(@"Artist name must not be empty",@"Artist name must not be empty",0);
+        return;
+    }
+
+    NSMutableArray *mutableSongsToSerialize = [NSMutableArray array];
+
+    MPMediaQuery *mediaQuery = [MPMediaQuery albumsQuery]; // run a query on song media type
+    [mediaQuery addFilterPredicate:[MPMediaPropertyPredicate predicateWithValue:@(NO)
+                       forProperty:MPMediaItemPropertyIsCloudItem]]; // ensure what we retrieve is on device
+    // this is returning all songs no matter what
+    [mediaQuery addFilterPredicate:[
+        MPMediaPropertyPredicate
+        predicateWithValue:artist
+        forProperty:MPMediaItemPropertyArtist
+        comparisonType: MPMediaPredicateComparisonContains
+    ]
+    ];
+
+    NSArray *allMediaItems = [mediaQuery items];
+    
+    // Define the range for the limited subset
+    NSRange range = NSMakeRange(offset, MIN(limit, allMediaItems.count - offset));
+    
+    // Get the subset of media items within the specified range
+    NSArray<MPMediaItem *> *limitedMediaItems = [allMediaItems subarrayWithRange:range];
+    
+    // Sort items
+    NSArray<MPMediaItem *> *sortedMediaItems = [self sortMediaItems:limitedMediaItems byKey: sortBy sortOrder: sortOrder];
+  
+    for (MPMediaItem *album in sortedMediaItems) {
+        NSDictionary *songDictionary = [NSMutableDictionary dictionary];
+        
+        NSURL *assetURL = [album valueForProperty:MPMediaItemPropertyAssetURL];
+        AVAsset *asset = [AVAsset assetWithURL:assetURL];
+
+        if ([asset hasProtectedContent] == NO) {
+            
+            NSString *albumTitle = [album valueForProperty: MPMediaItemPropertyAlbumTitle]; // filterable
+            NSString *albumArtist = [album valueForProperty: MPMediaItemPropertyAlbumArtist]; //
+            NSString *numberOfSongs = [album valueForProperty: MPMediaItemPropertyAlbumTrackCount]; //
+            
+            [songDictionary setValue:[NSString stringWithString:assetURL.absoluteString] forKey:@"url"];
+            [songDictionary setValue:[NSString stringWithString:albumTitle] forKey:@"album"];
+            [songDictionary setValue:[NSString stringWithString:albumArtist] forKey:@"artist"];
+            [songDictionary setValue:[NSString stringWithString:numberOfSongs] forKey:@"numberOfSongs"];
+            
+            if (needCover) {
+                MPMediaItemArtwork *artwork = [album valueForProperty: MPMediaItemPropertyArtwork];
+                if (artwork != nil) {
+                    UIImage *image = [artwork imageWithSize:CGSizeMake(coverQty, coverQty)];
+                    // http://www.12qw.ch/2014/12/tooltip-decoding-base64-images-with-chrome-data-url/
+                    // http://stackoverflow.com/a/510444/185771
+                    NSString *base64 = [NSString stringWithFormat:@"%@%@", @"data:image/jpeg;base64,", [self imageToNSString:image]];
+                    [songDictionary setValue:base64 forKey:@"cover"];
+                } else {
+                    [songDictionary setValue:@"" forKey:@"cover"];
+                }
+            } else {
+                [songDictionary setValue:@"" forKey:@"cover"];
+            }
+            
+            [mutableSongsToSerialize addObject:songDictionary];
+        }
+    }
+
+    resolve(mutableSongsToSerialize);
+}
+
+RCT_EXPORT_METHOD(search:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    if([MPMediaLibrary authorizationStatus] != MPMediaLibraryAuthorizationStatusAuthorized){
+        reject(@"Permission denied",@"Permission denied",0);
+        return;
+    }
+    
+    NSInteger limit = [options objectForKey:@"limit"] ? [options[@"limit"] integerValue] : 20;
+    NSInteger offset =  [options objectForKey:@"offset"] ? [options[@"offset"] integerValue] : 0;
+    NSInteger coverQty = [options objectForKey:@"coverQuality"] ? [options[@"coverQuality"] integerValue] : 100;
+    NSString *searchBy = options[@"searchBy"];
+    
+    BOOL needCover = [options objectForKey:@"coverQuality"] != nil || [options[@"coverQuality"] integerValue] == 0;
+    
+    id sortOrderValue = [options objectForKey:@"sortOrder"];
+
+    NSString *sortOrder;
+    if ([sortOrderValue isKindOfClass:[NSString class]]) {
+        sortOrder = sortOrderValue;
+    } else {
+        sortOrder = @"ASC";
+    }
+    
+    id sortByValue = [options objectForKey:@"sortBy"];
+    
+    NSString *sortBy;
+    if ([sortByValue isKindOfClass:[NSString class]]) {
+        sortBy = sortByValue;
+    } else {
+        sortBy = @"TITLE";
+    }
+    
+    if(searchBy.length == 0){
+        reject(@"Search param must not be empty",@"Search param must not be empty",0);
+        return;
+    }
+
+    NSMutableArray *mutableSongsToSerialize = [NSMutableArray array];
+    
+    MPMediaQuery *mediaQuery = [MPMediaQuery songsQuery]; // run a query on song media type
+    [mediaQuery addFilterPredicate:[MPMediaPropertyPredicate predicateWithValue:@(NO)
+                       forProperty:MPMediaItemPropertyIsCloudItem]]; // ensure what we retrieve is on device
+    
+    NSPredicate *filters = [NSPredicate predicateWithFormat:@"title contains[cd] %@ OR albumTitle contains[cd] %@ OR artist contains[cd] %@", searchBy, searchBy, searchBy];
+    
+    NSArray *allMediaItems = [[mediaQuery items] filteredArrayUsingPredicate:filters];
+
+    
+    // Define the range for the limited subset
+    NSRange range = NSMakeRange(offset, MIN(limit, allMediaItems.count - offset));
+    
+    // Get the subset of media items within the specified range
+    NSArray<MPMediaItem *> *limitedMediaItems = [allMediaItems subarrayWithRange:range];
+    
+    // Sort items
+    NSArray<MPMediaItem *> *sortedMediaItems = [self sortMediaItems:limitedMediaItems byKey: sortBy sortOrder: sortOrder];
+  
+    for (MPMediaItem *song in sortedMediaItems) {
+        NSDictionary *songDictionary = [NSMutableDictionary dictionary];
+        
+        NSURL *assetURL = [song valueForProperty:MPMediaItemPropertyAssetURL];
+        AVAsset *asset = [AVAsset assetWithURL:assetURL];
+
+        if ([asset hasProtectedContent] == NO) {
+            
+            NSString *durationStr = [song valueForProperty: MPMediaItemPropertyPlaybackDuration];
+            NSInteger durationInt = [durationStr integerValue];
+            
+            NSString *title = [song valueForProperty: MPMediaItemPropertyTitle];
+            NSString *albumTitle = [song valueForProperty: MPMediaItemPropertyAlbumTitle];
+            NSString *albumArtist = [song valueForProperty: MPMediaItemPropertyAlbumArtist];
+            NSString *genre = [song valueForProperty: MPMediaItemPropertyGenre]; // filterable
+            
+            [songDictionary setValue:[NSString stringWithString:assetURL.absoluteString] forKey:@"url"];
+            [songDictionary setValue:[NSString stringWithString:title] forKey:@"title"];
+            [songDictionary setValue:[NSString stringWithString:albumTitle] forKey:@"album"];
+            [songDictionary setValue:[NSString stringWithString:albumArtist] forKey:@"artist"];
+            [songDictionary setValue:[NSNumber numberWithInt:durationInt * 1000] forKey:@"duration"];
+            [songDictionary setValue:[NSString stringWithString:genre] forKey:@"genre"];
+            
+            if (needCover) {
+                MPMediaItemArtwork *artwork = [song valueForProperty: MPMediaItemPropertyArtwork];
+                if (artwork != nil) {
+                    UIImage *image = [artwork imageWithSize:CGSizeMake(coverQty, coverQty)];
+                    // http://www.12qw.ch/2014/12/tooltip-decoding-base64-images-with-chrome-data-url/
+                    // http://stackoverflow.com/a/510444/185771
+                    NSString *base64 = [NSString stringWithFormat:@"%@%@", @"data:image/jpeg;base64,", [self imageToNSString:image]];
+                    [songDictionary setValue:base64 forKey:@"cover"];
+                } else {
+                    [songDictionary setValue:@"" forKey:@"cover"];
+                }
+            } else {
+                [songDictionary setValue:@"" forKey:@"cover"];
+            }
+            
+            [mutableSongsToSerialize addObject:songDictionary];
+        }
+    }
+
+    resolve(mutableSongsToSerialize);
+}
+
+// http://stackoverflow.com/questions/22243854/encode-image-to-base64-get-a-invalid-base64-string-ios-using-base64encodedstri
+- (NSString *)imageToNSString:(UIImage *)image
+{
+    NSData *data = UIImagePNGRepresentation(image);
+    
+    return [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithLineFeed];
+}
+
+- (NSArray<MPMediaItem *> *)sortMediaItems:(NSArray<MPMediaItem *> *)mediaItems byKey:(NSString *)sortKey sortOrder:(NSString *)sortOrder {
+    NSArray<MPMediaItem *> *sortedMediaItems;
+
+    if ([sortKey isEqualToString:@"DURATION"]) {
+        sortedMediaItems = [mediaItems sortedArrayUsingComparator:^NSComparisonResult(MPMediaItem *item1, MPMediaItem *item2) {
+            NSNumber *duration1 = [item1 valueForProperty:MPMediaItemPropertyPlaybackDuration];
+            NSNumber *duration2 = [item2 valueForProperty:MPMediaItemPropertyPlaybackDuration];
+            NSComparisonResult result = [duration1 compare:duration2];
+            
+            if ([sortOrder isEqualToString:@"DESC"]) {
+                return (result == NSOrderedAscending) ? NSOrderedDescending :
+                       (result == NSOrderedDescending) ? NSOrderedAscending : NSOrderedSame;
+            }
+            
+            return result;
+        }];
+    } else if ([sortKey isEqualToString:@"TITLE"]) {
+        sortedMediaItems = [mediaItems sortedArrayUsingComparator:^NSComparisonResult(MPMediaItem *item1, MPMediaItem *item2) {
+            NSString *title1 = [item1 valueForProperty:MPMediaItemPropertyTitle];
+            NSString *title2 = [item2 valueForProperty:MPMediaItemPropertyTitle];
+            NSComparisonResult result = [title1 compare:title2];
+            
+            if ([sortOrder isEqualToString:@"DESC"]) {
+                return (result == NSOrderedAscending) ? NSOrderedDescending :
+                       (result == NSOrderedDescending) ? NSOrderedAscending : NSOrderedSame;
+            }
+            
+            return result;
+        }];
+    } else if ([sortKey isEqualToString:@"ARTIST"]) {
+        sortedMediaItems = [mediaItems sortedArrayUsingComparator:^NSComparisonResult(MPMediaItem *item1, MPMediaItem *item2) {
+            NSString *artist1 = [item1 valueForProperty:MPMediaItemPropertyArtist];
+            NSString *artist2 = [item2 valueForProperty:MPMediaItemPropertyArtist];
+            NSComparisonResult result = [artist1 compare:artist2];
+            
+            if ([sortOrder isEqualToString:@"DESC"]) {
+                return (result == NSOrderedAscending) ? NSOrderedDescending :
+                       (result == NSOrderedDescending) ? NSOrderedAscending : NSOrderedSame;
+            }
+            
+            return result;
+        }];
+    } else if ([sortKey isEqualToString:@"ALBUM"]) {
+        sortedMediaItems = [mediaItems sortedArrayUsingComparator:^NSComparisonResult(MPMediaItem *item1, MPMediaItem *item2) {
+            NSString *album1 = [item1 valueForProperty:MPMediaItemPropertyAlbumTitle];
+            NSString *album2 = [item2 valueForProperty:MPMediaItemPropertyAlbumTitle];
+            NSComparisonResult result = [album1 compare:album2];
+            
+            if ([sortOrder isEqualToString:@"DESC"]) {
+                return (result == NSOrderedAscending) ? NSOrderedDescending :
+                       (result == NSOrderedDescending) ? NSOrderedAscending : NSOrderedSame;
+            }
+            
+            return result;
+        }];
+    } else if ([sortKey isEqualToString:@"GENDER"]) {
+        sortedMediaItems = [mediaItems sortedArrayUsingComparator:^NSComparisonResult(MPMediaItem *item1, MPMediaItem *item2) {
+            NSString *gender1 = [item1 valueForProperty:MPMediaItemPropertyGenre];
+            NSString *gender2 = [item2 valueForProperty:MPMediaItemPropertyGenre];
+            NSComparisonResult result = [gender1 compare:gender2];
+            
+            if ([sortOrder isEqualToString:@"DESC"]) {
+                return (result == NSOrderedAscending) ? NSOrderedDescending :
+                       (result == NSOrderedDescending) ? NSOrderedAscending : NSOrderedSame;
+            }
+            
+            return result;
+        }];
+    } else if ([sortKey isEqualToString:@"DATE_ADDED"]) {
+        sortedMediaItems = [mediaItems sortedArrayUsingComparator:^NSComparisonResult(MPMediaItem *item1, MPMediaItem *item2) {
+            NSString *dateAdded1 = [item1 valueForProperty:MPMediaItemPropertyDateAdded];
+            NSString *dateAdded2 = [item2 valueForProperty:MPMediaItemPropertyDateAdded];
+            NSComparisonResult result = [dateAdded1 compare:dateAdded2];
+            
+            if ([sortOrder isEqualToString:@"DESC"]) {
+                return (result == NSOrderedAscending) ? NSOrderedDescending :
+                       (result == NSOrderedDescending) ? NSOrderedAscending : NSOrderedSame;
+            }
+            
+            return result;
+        }];
+    } else {
+        // Default sorting (by title)
+        sortedMediaItems = mediaItems;
+    }
+
+    return sortedMediaItems;
+}
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeTurboSongsSpecJSI>(params);
+}
+#endif
+
+@end

package/package.json

@@ -0,0 +1,171 @@
+{
+  "name": "@andycui/react-native-get-music-files",
+  "version": "3.0.1",
+  "description": "React Native package to get music files from local and sd for iOS and Android",
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "types": "lib/typescript/src/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-turbo-songs-example",
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "release": "release-it"
+  },
+  "keywords": [
+    "react-native",
+    "music",
+    "files",
+    "metadata",
+    "ios",
+    "android",
+    "react",
+    "native"
+  ],
+  "repository": "https://github.com/andy380743909/react-native-get-music-files",
+  "author": "Andy Cui <andy380743909@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/andy380743909/react-native-get-music-files/issues"
+  },
+  "homepage": "https://github.com/andy380743909/react-native-get-music-files#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^17.0.2",
+    "@evilmartians/lefthook": "^1.5.0",
+    "@react-native/eslint-config": "^0.72.2",
+    "@release-it/conventional-changelog": "^5.0.0",
+    "@types/jest": "^28.1.2",
+    "@types/react": "~17.0.21",
+    "@types/react-native": "0.70.0",
+    "commitlint": "^17.0.2",
+    "del-cli": "^5.0.0",
+    "eslint": "^8.4.1",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^28.1.1",
+    "pod-install": "^0.1.0",
+    "prettier": "^2.0.5",
+    "react": "18.2.0",
+    "react-native": "0.72.5",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^15.0.0",
+    "turbo": "^1.10.7",
+    "typescript": "^5.0.2"
+  },
+  "resolutions": {
+    "@types/react": "17.0.21"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@3.6.1",
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": "angular"
+      }
+    }
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native",
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "RNTurboSongsSpec",
+    "type": "modules",
+    "jsSrcsDir": "src"
+  }
+}

package/react-native-turbo-songs.podspec

@@ -0,0 +1,41 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-turbo-songs"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+  s.dependency "React-Core"
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+   end
+  end    
+end

package/src/NativeTurboSongs.ts

@@ -0,0 +1,60 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Song {
+  url: string;
+  title: string;
+  album: string;
+  artist: string;
+  duration: number;
+  genre: string;
+  cover: string;
+}
+
+enum SortSongOrder {
+  ASC = 'ASC',
+  DESC = 'DESC',
+}
+
+enum SortSongFields {
+  TITLE = 'TITLE',
+  DURATION = 'DURATION',
+  ARTIST = 'ARTIST',
+  GENRE = 'GENRE',
+  ALBUM = 'ALBUM',
+  DATE_ADDED = 'DATE_ADDED',
+}
+
+export interface SongOptions {
+  limit?: number;
+  offset?: number;
+  coverQuality?: number;
+  minSongDuration?: number;
+  searchBy?: string;
+  sortOrder?: SortSongOrder;
+  sortBy?: SortSongFields;
+}
+
+export interface Album {
+  url: string;
+  album: string;
+  artist: string;
+  numberOfSongs: string;
+  cover: string;
+}
+export interface AlbumOptions {
+  limit?: number;
+  offset?: number;
+  coverQuality?: number;
+  artist: string;
+  sortOrder?: SortSongOrder;
+  sortBy?: SortSongOrder;
+}
+
+export interface Spec extends TurboModule {
+  getAll(options?: SongOptions): Promise<Song[] | string>;
+  getAlbums(options?: AlbumOptions): Promise<Album[] | string>;
+  searchSongs(options?: SongOptions): Promise<Song[] | string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('TurboSongs');